void probe_block_rq_requeue(void *data, struct request_queue *q, struct request *rq)
{
int rw = rq->cmd_flags & 0x03;
if (blk_discard_rq(rq))
rw |= (1 << BIO_RW_DISCARD);
if (blk_pc_request(rq)) {
trace_mark_tp(block, rq_requeue_pc, block_rq_requeue,
probe_block_rq_requeue,
"data_len %u rw %d errors %d",
blk_rq_bytes(rq), rw, rq->errors);
} else {
/*
* FIXME Using a simple trace_mark for the second event
* possibility because tracepoints do not support multiple
* connections to the same probe yet. They should have some
* refcounting. Need to enable both rq_requeue_pc and
* rq_requeue_fs markers to have the rq_requeue_fs marker
* enabled.
*/
trace_mark(block, rq_requeue_fs,
"hard_sector %llu "
"rw %d errors %d", (unsigned long long)blk_rq_pos(rq),
rw, rq->errors);
}
}
void probe_block_unplug_io(void *data, struct request_queue *q)
{
unsigned int pdu = q->rq.count[READ] + q->rq.count[WRITE];
trace_mark_tp(block, unplug_io, block_unplug_io, probe_block_unplug_io,
"pdu %u", pdu);
}
void probe_kernel_vprintk(void *_data, unsigned long retaddr, char *buf, int len)
{
if (len > 0) {
unsigned int loglevel;
int mark_len;
char *mark_buf;
char saved_char;
if (buf[0] == '<' && buf[1] >= '0' &&
buf[1] <= '7' && buf[2] == '>') {
loglevel = buf[1] - '0';
mark_buf = &buf[3];
mark_len = len - 3;
} else {
loglevel = default_message_loglevel;
mark_buf = buf;
mark_len = len;
}
if (mark_buf[mark_len - 1] == '\n')
mark_len--;
saved_char = mark_buf[mark_len];
mark_buf[mark_len] = '\0';
trace_mark_tp(kernel, vprintk, kernel_vprintk,
probe_kernel_vprintk,
"loglevel #1u%u string %s ip 0x%lX",
loglevel, mark_buf, retaddr);
mark_buf[mark_len] = saved_char;
}
}
void probe_add_to_page_cache(void *_data, struct address_space *mapping, pgoff_t offset)
{
trace_mark_tp(mm, add_to_page_cache, add_to_page_cache,
probe_add_to_page_cache,
"inode %lu sdev %u",
mapping->host->i_ino, mapping->host->i_sb->s_dev);
}
void probe_kernel_panic(void *_data, const char *fmt, va_list args)
{
char info[64];
vsnprintf(info, sizeof(info), fmt, args);
trace_mark_tp(kernel, panic, kernel_panic, probe_kernel_panic,
"info %s", info);
}
void probe_remove_from_page_cache(void *_data, struct address_space *mapping)
{
trace_mark_tp(mm, remove_from_page_cache, remove_from_page_cache,
probe_remove_from_page_cache,
"inode %lu sdev %u",
mapping->host->i_ino, mapping->host->i_sb->s_dev);
}
void probe_socket_create(void *_data, int family, int type, int protocol,
struct socket *sock, int ret)
{
trace_mark_tp(net, socket_create, socket_create, probe_socket_create,
"family %d type %d protocol %d sock %p ret %d",
family, type, protocol, sock, ret);
}
void probe_socket_accept(void *_data, int fd, struct sockaddr __user *upeer_sockaddr,
int __user *upeer_addrlen, int flags, int ret)
{
trace_mark_tp(net, socket_accept, socket_accept, probe_socket_accept,
"fd %d upeer_sockaddr %p upeer_addrlen %p flags %d ret %d",
fd, upeer_sockaddr, upeer_addrlen, flags, ret);
}
void probe_socket_shutdown(void *_data, int fd, int how, int ret)
{
trace_mark_tp(net, socket_shutdown, socket_shutdown,
probe_socket_shutdown,
"fd %d how %d ret %d",
fd, how, ret);
}
void probe_socket_connect(void *_data, int fd, struct sockaddr __user *uservaddr,
int addrlen, int ret)
{
trace_mark_tp(net, socket_connect, socket_connect, probe_socket_connect,
"fd %d uservaddr %p addrlen %d ret %d",
fd, uservaddr, addrlen, ret);
}
void probe_socket_bind(void *_data, int fd, struct sockaddr __user *umyaddr, int addrlen,
int ret)
{
trace_mark_tp(net, socket_bind, socket_bind, probe_socket_bind,
"fd %d umyaddr %p addrlen %d ret %d",
fd, umyaddr, addrlen, ret);
}
void probe_socket_getsockopt(void *_data, int fd, int level, int optname,
char __user *optval, int __user *optlen, int ret)
{
trace_mark_tp(net, socket_getsockopt, socket_getsockopt,
probe_socket_getsockopt,
"fd %d level %d optname %d optval %p optlen %p ret %d",
fd, level, optname, optval, optlen, ret);
}
void probe_socket_socketpair(void *_data, int family, int type, int protocol,
int __user *usockvec, int ret)
{
trace_mark_tp(net, socket_socketpair, socket_socketpair,
probe_socket_socketpair,
"family %d type %d protocol %d usockvec %p ret %d",
family, type, protocol, usockvec, ret);
}
void probe_socket_getpeername(void *_data, int fd, struct sockaddr __user *usockaddr,
int __user *usockaddr_len, int ret)
{
trace_mark_tp(net, socket_getpeername, socket_getpeername,
probe_socket_getpeername,
"fd %d usockaddr %p usockaddr_len %p ret %d",
fd, usockaddr, usockaddr_len, ret);
}
void probe_swap_in(void *_data, struct page *page, swp_entry_t entry)
{
trace_mark_tp(mm, swap_in, swap_in, probe_swap_in,
"pfn %lu filp %p offset %lu",
page_to_pfn(page),
get_swap_info_struct(swp_type(entry))->swap_file,
swp_offset(entry));
}
void probe_sched_process_fork(void *_data, struct task_struct *parent,
struct task_struct *child)
{
trace_mark_tp(kernel, process_fork, sched_process_fork,
probe_sched_process_fork,
"parent_pid %d child_pid %d child_tgid %d",
parent->pid, child->pid, child->tgid);
}
void probe_swap_out(struct page *page)
{
trace_mark_tp(mm, swap_out, swap_out, probe_swap_out,
"pfn %lu filp %p offset %lu",
page_to_pfn(page),
get_swap_info_struct(swp_type(
page_swp_entry(page)))->swap_file,
swp_offset(page_swp_entry(page)));
}
void probe_block_bio_queue(void *data, struct request_queue *q, struct bio *bio)
{
trace_mark_tp(block, bio_queue, block_bio_queue,
probe_block_bio_queue,
"sector %llu size %u rw(FAILFAST_DRIVER,FAILFAST_TRANSPORT,"
"FAILFAST_DEV,DISCARD,META,SYNC,BARRIER,AHEAD,RW) %lX "
"not_uptodate #1u%d",
(unsigned long long)bio->bi_sector, bio->bi_size,
bio->bi_rw, !bio_flagged(bio, BIO_UPTODATE));
}
void probe_timer_update_time(void *_data, struct timespec *_xtime,
struct timespec *_wall_to_monotonic)
{
trace_mark_tp(kernel, timer_update_time, timer_update_time,
probe_timer_update_time,
"jiffies #8u%llu xtime_sec %ld xtime_nsec %ld "
"walltomonotonic_sec %ld walltomonotonic_nsec %ld",
(unsigned long long)jiffies_64, _xtime->tv_sec, _xtime->tv_nsec,
_wall_to_monotonic->tv_sec, _wall_to_monotonic->tv_nsec);
}
void probe_timer_itimer_set(void *_data, int which, struct itimerval *value)
{
trace_mark_tp(kernel, timer_itimer_set,
timer_itimer_set, probe_timer_itimer_set,
"which %d interval_sec %ld interval_usec %ld "
"value_sec %ld value_usec %ld",
which,
value->it_interval.tv_sec,
value->it_interval.tv_usec,
value->it_value.tv_sec,
value->it_value.tv_usec);
}
void probe_block_remap(void *data, struct request_queue *q, struct bio *bio,
dev_t dev, sector_t from)
{
trace_mark_tp(block, remap, block_remap,
probe_block_remap,
"device_from %lu sector_from %llu device_to %lu "
"size %u rw(FAILFAST_DRIVER,FAILFAST_TRANSPORT,"
"FAILFAST_DEV,DISCARD,META,SYNC,BARRIER,AHEAD,RW) %lX "
"not_uptodate #1u%d",
(unsigned long)bio->bi_bdev->bd_dev,
(unsigned long long)from,
(unsigned long)dev,
bio->bi_size, bio->bi_rw,
!bio_flagged(bio, BIO_UPTODATE));
}
void probe_ipv6_addr_del(void *_data, struct inet6_ifaddr *ifa)
{
__u8 *addr = ifa->addr.s6_addr;
trace_mark_tp(netif_state, insert_ifa_ipv6, ipv6_addr_del,
probe_ipv6_addr_del,
"label %s "
"a15 #1x%c a14 #1x%c a13 #1x%c a12 #1x%c "
"a11 #1x%c a10 #1x%c a9 #1x%c a8 #1x%c "
"a7 #1x%c a6 #1x%c a5 #1x%c a4 #1x%c "
"a3 #1x%c a2 #1x%c a1 #1x%c a0 #1x%c",
ifa->idev->dev->name,
addr[15], addr[14], addr[13], addr[12],
addr[11], addr[10], addr[9], addr[8],
addr[7], addr[6], addr[5], addr[4],
addr[3], addr[2], addr[1], addr[0]);
}
void probe_block_sleeprq(void *data, struct request_queue *q, struct bio *bio, int rw)
{
if (bio) {
trace_mark_tp(block, sleeprq_bio, block_sleeprq,
probe_block_sleeprq,
"sector %llu size %u "
"rw(FAILFAST_DRIVER,FAILFAST_TRANSPORT,"
"FAILFAST_DEV,DISCARD,META,SYNC,BARRIER,AHEAD,RW) %lX "
"not_uptodate #1u%d",
(unsigned long long)bio->bi_sector, bio->bi_size,
bio->bi_rw, !bio_flagged(bio, BIO_UPTODATE));
} else {
/*
* FIXME Using a simple trace_mark for the second event
* possibility because tracepoints do not support multiple
* connections to the same probe yet. They should have some
* refcounting. Need to enable both sleeprq_bio and sleeprq
* markers to have the sleeprq marker enabled.
*/
trace_mark(block, sleeprq, "rw %d", rw);
}
}
void probe_hugetlb_page_alloc(void *_data, struct page *page)
{
if (page)
trace_mark_tp(mm, huge_page_alloc, hugetlb_page_alloc,
probe_hugetlb_page_alloc, "pfn %lu", page_to_pfn(page));
}
void probe_hugetlb_page_free(void *_data, struct page *page)
{
trace_mark_tp(mm, huge_page_free, hugetlb_page_free,
probe_hugetlb_page_free, "pfn %lu", page_to_pfn(page));
}
void probe_wait_on_page_end(void *_data, struct page *page, int bit_nr)
{
trace_mark_tp(mm, wait_on_page_end, wait_on_page_end,
probe_wait_on_page_end, "pfn %lu bit_nr %d",
page_to_pfn(page), bit_nr);
}
void probe_swap_file_open(void *_data, struct file *file, char *filename)
{
trace_mark_tp(mm, swap_file_open, swap_file_open,
probe_swap_file_open, "filp %p filename %s",
file, filename);
}
void probe_swap_file_close(void *_data, struct file *file)
{
trace_mark_tp(mm, swap_file_close, swap_file_close,
probe_swap_file_close, "filp %p", file);
}
void probe_kernel_crash_kexec(void *_data, struct kimage *image, struct pt_regs *regs)
{
trace_mark_tp(kernel, crash_kexec, kernel_crash_kexec,
probe_kernel_crash_kexec, "image %p ip %p", image,
regs ? (void *)instruction_pointer(regs) : NULL);
}
void probe_kernel_kernel_kexec(void *_data, struct kimage *image)
{
trace_mark_tp(kernel, kernel_kexec, kernel_kernel_kexec,
probe_kernel_kernel_kexec, "image %p", image);
}
