Beispiel #1
0
notrace void probe_syscall_entry(struct pt_regs *regs, long id)
{
	struct marker *marker;
	struct serialize_long_int data;

	data.f1 = instruction_pointer(regs);
	data.f2 = (int)id;

	marker = &GET_MARKER(kernel_syscall_entry);
	ltt_specialized_trace(marker->single.probe_private,
		&data, serialize_sizeof(data), sizeof(long));
}
Beispiel #2
0
notrace void probe_page_free(void *_data, struct page *page, unsigned int order)
{
	struct marker *marker;
	struct serialize_long_int data;

	data.f1 = page_to_pfn(page);
	data.f2 = order;

	marker = &GET_MARKER(mm, page_free);
	ltt_specialized_trace(marker, marker->single.probe_private,
		&data, serialize_sizeof(data), sizeof(long));
}
Beispiel #3
0
notrace void probe_net_dev_receive(void *_data, struct sk_buff *skb)
{
	struct marker *marker;
	struct serialize_long_short data;

	data.f1 = (unsigned long)skb;
	data.f2 = skb->protocol;

	marker = &GET_MARKER(net, dev_receive);
	ltt_specialized_trace(marker, marker->single.probe_private,
		&data, serialize_sizeof(data), sizeof(long));
}
Beispiel #4
0
notrace void probe_irq_next_handler(void *_data, unsigned int id, struct irqaction *action,
		irqreturn_t prev_ret)
{
	struct marker *marker;
	struct serialize_long_char data;

	data.f1 = (unsigned long) (action ? action->handler : NULL);
	data.f2 = prev_ret;

	marker = &GET_MARKER(kernel, irq_next_handler);
	ltt_specialized_trace(marker, marker->single.probe_private,
		&data, serialize_sizeof(data), sizeof(long));
}
Beispiel #5
0
notrace void probe_kernel_page_fault_get_user_entry(void *_data, struct mm_struct *mm,
	struct vm_area_struct *vma, unsigned long address, int write_access)
{
	struct marker *marker;
	struct serialize_long_char data;

	data.f1 = address;
	data.f2 = (unsigned char)!!write_access;

	marker = &GET_MARKER(kernel, page_fault_get_user_entry);
	ltt_specialized_trace(marker, marker->single.probe_private,
		&data, serialize_sizeof(data), sizeof(long));
}
Beispiel #6
0
notrace void probe_timer_set(void *_data, struct timer_list *timer)
{
	struct marker *marker;
	struct serialize_long_long_long data;

	data.f1 = timer->expires;
	data.f2 = (unsigned long)timer->function;
	data.f3 = timer->data;

	marker = &GET_MARKER(kernel, timer_set);
	ltt_specialized_trace(marker, marker->single.probe_private,
		&data, serialize_sizeof(data), sizeof(long));
}
Beispiel #7
0
notrace void probe_sched_wakeup(void *_data, struct task_struct *p, int success)
{
	struct marker *marker;
	struct serialize_int_int_short data;

	data.f1 = p->pid;
	data.f2 = task_cpu(p);
	data.f3 = p->state;

	marker = &GET_MARKER(kernel, sched_try_wakeup);
	ltt_specialized_trace(marker, marker->single.probe_private,
		&data, serialize_sizeof(data), sizeof(int));
}
Beispiel #8
0
notrace void probe_sched_switch(void *_data, struct task_struct *prev,
		struct task_struct *next)
{
	struct marker *marker;
	struct serialize_int_int_short data;

	data.f1 = prev->pid;
	data.f2 = next->pid;
	data.f3 = prev->state;

	marker = &GET_MARKER(kernel, sched_schedule);
	ltt_specialized_trace(marker, marker->single.probe_private,
		&data, serialize_sizeof(data), sizeof(int));
}
Beispiel #9
0
notrace void probe_memory_handle_fault_entry(struct mm_struct *mm,
	struct vm_area_struct *vma, unsigned long address, int write_access)
{
	struct marker *marker;
	struct serialize_long_long_int data;

	data.f1 = address;
	data.f2 = KSTK_EIP(current);
	data.f3 = write_access;

	marker = &GET_MARKER(mm_handle_fault_entry);
	ltt_specialized_trace(marker->single.probe_private,
		&data, serialize_sizeof(data), sizeof(long));
}
Beispiel #10
0
notrace void probe_trap_entry(struct pt_regs *regs, long id)
{
	struct marker *marker;
	struct serialize_long_short data;

	if (likely(regs))
		data.f1 = instruction_pointer(regs);
	else
		data.f1 = 0UL;
	data.f2 = (unsigned short)id;

	marker = &GET_MARKER(kernel, trap_entry);
	ltt_specialized_trace(marker, marker->single.probe_private,
		&data, serialize_sizeof(data), sizeof(long));
}
Beispiel #11
0
notrace void probe_page_alloc(struct page *page, unsigned int order)
{
	struct marker *marker;
	struct serialize_long_int data;

	if (unlikely(!page))
		return;

	data.f1 = page_to_pfn(page);
	data.f2 = order;

	marker = &GET_MARKER(mm, page_alloc);
	ltt_specialized_trace(marker, marker->single.probe_private,
		&data, serialize_sizeof(data), sizeof(long));
}
Beispiel #12
0
notrace void probe_socket_sendmsg(void *_data, struct socket *sock, struct msghdr *msg,
	size_t size, int ret)
{
	struct marker *marker;
	struct serialize_long_long_sizet_int data;

	data.f1 = (unsigned long)sock;
	data.f2 = (unsigned long)msg;
	data.f3 = size;
	data.f4 = ret;

	marker = &GET_MARKER(net, socket_sendmsg);
	ltt_specialized_trace(marker, marker->single.probe_private,
		&data, serialize_sizeof(data), sizeof(size_t));
}
Beispiel #13
0
notrace void probe_kernel_page_fault_nosem_entry(void *_data, struct pt_regs *regs,
	int trapnr, unsigned long address)
{
	struct marker *marker;
	struct serialize_long_long_short data;

	if (likely(regs))
		data.f1 = instruction_pointer(regs);
	else
		data.f1 = 0UL;
	data.f2 = address;
	data.f3 = (unsigned short)trapnr;

	marker = &GET_MARKER(kernel, page_fault_nosem_entry);
	ltt_specialized_trace(marker, marker->single.probe_private,
		&data, serialize_sizeof(data), sizeof(long));
}
Beispiel #14
0
notrace void probe_kernel_page_fault_entry(struct pt_regs *regs, int trapnr,
	struct mm_struct *mm, struct vm_area_struct *vma,
	unsigned long address, int write_access)
{
	struct marker *marker;
	struct serialize_long_long_short_char data;

	if (likely(regs))
		data.f1 = instruction_pointer(regs);
	else
		data.f1 = 0UL;
	data.f2 = address;
	data.f3 = (unsigned short)trapnr;
	data.f4 = (unsigned char)!!write_access;

	marker = &GET_MARKER(kernel, page_fault_entry);
	ltt_specialized_trace(marker, marker->single.probe_private,
		&data, serialize_sizeof(data), sizeof(long));
}
Beispiel #15
0
notrace void probe_irq_entry(void *_data, unsigned int id, struct pt_regs *regs,
	struct irqaction *action)
{
	struct marker *marker;
	struct serialize_long_long_short_char data;

	if (unlikely(!regs))
		regs = get_irq_regs();
	if (likely(regs)) {
		data.f1 = instruction_pointer(regs);
		data.f4 = !user_mode(regs);
	} else {
		data.f1 = 0UL;
		data.f4 = 1;
	}
	data.f2 = (unsigned long) (action ? action->handler : NULL);
	data.f3 = id;

	marker = &GET_MARKER(kernel, irq_entry);
	ltt_specialized_trace(marker, marker->single.probe_private,
		&data, serialize_sizeof(data), sizeof(long));
}