One Level Up Top Level

runtime/kp_transport.c - ktap

Global variables defined

Data types defined

Functions defined

Macros defined

Source code

  1. /*
  2. * kp_transport.c - ktap transport functionality
  3. *
  4. * This file is part of ktap by Jovi Zhangwei.
  5. *
  6. * Copyright (C) 2012-2013 Jovi Zhangwei <jovi.zhangwei@gmail.com>.
  7. *
  8. * ktap is free software; you can redistribute it and/or modify it
  9. * under the terms and conditions of the GNU General Public License,
  10. * version 2, as published by the Free Software Foundation.
  11. *
  12. * ktap is distributed in the hope it will be useful, but WITHOUT
  13. * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14. * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  15. * more details.
  16. *
  17. * You should have received a copy of the GNU General Public License along with
  18. * this program; if not, write to the Free Software Foundation, Inc.,
  19. * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  20. */

  22. #include <linux/debugfs.h>
  23. #include <linux/ftrace_event.h>
  24. #include <linux/stacktrace.h>
  25. #include <linux/clocksource.h>
  26. #include <asm/uaccess.h>
  27. #include <linux/slab.h>
  28. #include <linux/module.h>
  29. #include <linux/kallsyms.h>
  30. #include "../include/ktap_types.h"
  31. #include "ktap.h"
  32. #include "kp_events.h"
  33. #include "kp_transport.h"

  35. ‌struct ktap_trace_iterator {
  36.     struct ring_buffer    *buffer;
  37.     int            print_timestamp;
  38.     void            *private;

  40.     struct trace_iterator    iter;
  41. };

  43. ‌enum ktap_trace_type {
  44.     __TRACE_FIRST_TYPE = 0,

  46.     TRACE_FN = 1, /* must be same as ftrace definition in kernel */
  47.     TRACE_PRINT,
  48.     TRACE_BPUTS,
  49.     TRACE_STACK,
  50.     TRACE_USER_STACK,

  52.     __TRACE_LAST_TYPE,
  53. };

  55. ‌#define KTAP_TRACE_ITER(iter)    \
  56.     container_of(iter, struct ktap_trace_iterator, iter)

  58. static
  59. ‌ssize_t _trace_seq_to_user(struct trace_seq *s, char __user *ubuf, size_t cnt)
  60. {
  61.     int len;
  62.     int ret;

  64.     if (!cnt)
  65.         return 0;

  67.     if (s->len <= s->readpos)
  68.         return -EBUSY;

  70.     len = s->len - s->readpos;
  71.     if (cnt > len)
  72.         cnt = len;
  73.     ret = copy_to_user(ubuf, s->buffer + s->readpos, cnt);
  74.     if (ret == cnt)
  75.         return -EFAULT;

  77.     cnt -= ret;

  79.     s->readpos += cnt;
  80.     return cnt;
  81. }

  83. ‌int _trace_seq_puts(struct trace_seq *s, const char *str)
  84. {
  85.     int len = strlen(str);

  87.     if (s->full)
  88.         return 0;

  90.     if (len > ((PAGE_SIZE - 1) - s->len)) {
  91.         s->full = 1;
  92.         return 0;
  93.     }

  95.     memcpy(s->buffer + s->len, str, len);
  96.     s->len += len;

  98.     return len;
  99. }

  101. ‌static int trace_empty(struct trace_iterator *iter)
  102. {
  103.     struct ktap_trace_iterator *ktap_iter = KTAP_TRACE_ITER(iter);
  104.     int cpu;

  106.     for_each_online_cpu(cpu) {
  107.         if (!ring_buffer_empty_cpu(ktap_iter->buffer, cpu))
  108.             return 0;
  109.     }

  111.     return 1;
  112. }

  114. ‌static void trace_consume(struct trace_iterator *iter)
  115. {
  116.     struct ktap_trace_iterator *ktap_iter = KTAP_TRACE_ITER(iter);

  118.     ring_buffer_consume(ktap_iter->buffer, iter->cpu, &iter->ts,
  119.                 &iter->lost_events);
  120. }

  122. ‌unsigned long long ns2usecs(cycle_t nsec)
  123. {
  124.     nsec += 500;
  125.     do_div(nsec, 1000);
  126.     return nsec;
  127. }

  129. ‌static int trace_print_timestamp(struct trace_iterator *iter)
  130. {
  131.     struct trace_seq *s = &iter->seq;
  132.     unsigned long long t;
  133.     unsigned long secs, usec_rem;

  135.     t = ns2usecs(iter->ts);
  136.     usec_rem = do_div(t, USEC_PER_SEC);
  137.     secs = (unsigned long)t;

  139.     return trace_seq_printf(s, "%5lu.%06lu: ", secs, usec_rem);
  140. }

  142. /* todo: export kernel function ftrace_find_event in future, and make faster */
  143. ‌static struct trace_event *(*ftrace_find_event)(int type);

  145. ‌static enum print_line_t print_trace_fmt(struct trace_iterator *iter)
  146. {
  147.     struct ktap_trace_iterator *ktap_iter = KTAP_TRACE_ITER(iter);
  148.     struct trace_entry *entry = iter->ent;
  149.     struct trace_event *ev;

  151.     ev = ftrace_find_event(entry->type);

  153.     if (ktap_iter->print_timestamp && !trace_print_timestamp(iter))
  154.         return TRACE_TYPE_PARTIAL_LINE;

  156.     if (ev) {
  157.         int ret = ev->funcs->trace(iter, 0, ev);

  159.         /* overwrite '\n' at the ending */
  160.         iter->seq.buffer[iter->seq.len - 1] = '\0';
  161.         iter->seq.len--;
  162.         return ret;
  163.     }

  165.     return TRACE_TYPE_PARTIAL_LINE;
  166. }

  168. ‌static enum print_line_t print_trace_stack(struct trace_iterator *iter)
  169. {
  170.     struct trace_entry *entry = iter->ent;
  171.     struct stack_trace trace;
  172.     char str[KSYM_SYMBOL_LEN];
  173.     int i;

  175.     trace.entries = (unsigned long *)(entry + 1);
  176.     trace.nr_entries = (iter->ent_size - sizeof(*entry)) /
  177.                sizeof(unsigned long);

  179.     if (!_trace_seq_puts(&iter->seq, "<stack trace>\n"))
  180.         return TRACE_TYPE_PARTIAL_LINE;

  182.     for (i = 0; i < trace.nr_entries; i++) {
  183.         unsigned long p = trace.entries[i];

  185.         if (p == ULONG_MAX)
  186.             break;

  188.         sprint_symbol(str, p);
  189.         if (!trace_seq_printf(&iter->seq, " => %s\n", str))
  190.             return TRACE_TYPE_PARTIAL_LINE;
  191.     }

  193.     return TRACE_TYPE_HANDLED;
  194. }

  196. ‌struct ktap_ftrace_entry {
  197.     struct trace_entry entry;
  198.     unsigned long ip;
  199.     unsigned long parent_ip;
  200. };

  202. ‌static enum print_line_t print_trace_fn(struct trace_iterator *iter)
  203. {
  204.     struct ktap_trace_iterator *ktap_iter = KTAP_TRACE_ITER(iter);
  205.     struct ktap_ftrace_entry *field = (struct ktap_ftrace_entry *)iter->ent;
  206.     char str[KSYM_SYMBOL_LEN];

  208.     if (ktap_iter->print_timestamp && !trace_print_timestamp(iter))
  209.         return TRACE_TYPE_PARTIAL_LINE;

  211.     sprint_symbol(str, field->ip);
  212.     if (!_trace_seq_puts(&iter->seq, str))
  213.         return TRACE_TYPE_PARTIAL_LINE;

  215.     if (!_trace_seq_puts(&iter->seq, " <- "))
  216.         return TRACE_TYPE_PARTIAL_LINE;

  218.     sprint_symbol(str, field->parent_ip);
  219.     if (!_trace_seq_puts(&iter->seq, str))
  220.         return TRACE_TYPE_PARTIAL_LINE;

  222.     return TRACE_TYPE_HANDLED;
  223. }

  225. ‌static enum print_line_t print_trace_bputs(struct trace_iterator *iter)
  226. {
  227.     if (!_trace_seq_puts(&iter->seq,
  228.                 (const char *)(*(unsigned long *)(iter->ent + 1))))
  229.         return TRACE_TYPE_PARTIAL_LINE;

  231.     return TRACE_TYPE_HANDLED;
  232. }

  234. ‌static enum print_line_t print_trace_line(struct trace_iterator *iter)
  235. {
  236.     struct trace_entry *entry = iter->ent;
  237.     char *str = (char *)(entry + 1);

  239.     if (entry->type == TRACE_PRINT) {
  240.         if (!trace_seq_printf(&iter->seq, "%s", str))
  241.             return TRACE_TYPE_PARTIAL_LINE;

  243.         return TRACE_TYPE_HANDLED;
  244.     }

  246.     if (entry->type == TRACE_BPUTS)
  247.         return print_trace_bputs(iter);

  249.     if (entry->type == TRACE_STACK)
  250.         return print_trace_stack(iter);

  252.     if (entry->type == TRACE_FN)
  253.         return print_trace_fn(iter);

  255.     return print_trace_fmt(iter);
  256. }

  258. static struct trace_entry *
  259. ‌peek_next_entry(struct trace_iterator *iter, int cpu, u64 *ts,
  260.         unsigned long *lost_events)
  261. {
  262.     struct ktap_trace_iterator *ktap_iter = KTAP_TRACE_ITER(iter);
  263.     struct ring_buffer_event *event;

  265.     event = ring_buffer_peek(ktap_iter->buffer, cpu, ts, lost_events);
  266.     if (event) {
  267.         iter->ent_size = ring_buffer_event_length(event);
  268.         return ring_buffer_event_data(event);
  269.     }

  271.     return NULL;
  272. }

  274. static struct trace_entry *
  275. ‌__find_next_entry(struct trace_iterator *iter, int *ent_cpu,
  276.           unsigned long *missing_events, u64 *ent_ts)
  277. {
  278.     struct ktap_trace_iterator *ktap_iter = KTAP_TRACE_ITER(iter);
  279.     struct ring_buffer *buffer = ktap_iter->buffer;
  280.     struct trace_entry *ent, *next = NULL;
  281.     unsigned long lost_events = 0, next_lost = 0;
  282.     u64 next_ts = 0, ts;
  283.     int next_cpu = -1;
  284.     int next_size = 0;
  285.     int cpu;

  287.     for_each_online_cpu(cpu) {
  288.         if (ring_buffer_empty_cpu(buffer, cpu))
  289.             continue;

  291.         ent = peek_next_entry(iter, cpu, &ts, &lost_events);
  292.         /*
  293.          * Pick the entry with the smallest timestamp:
  294.          */
  295.         if (ent && (!next || ts < next_ts)) {
  296.             next = ent;
  297.             next_cpu = cpu;
  298.             next_ts = ts;
  299.             next_lost = lost_events;
  300.             next_size = iter->ent_size;
  301.         }
  302.     }

  304.     iter->ent_size = next_size;

  306.     if (ent_cpu)
  307.         *ent_cpu = next_cpu;

  309.     if (ent_ts)
  310.         *ent_ts = next_ts;

  312.     if (missing_events)
  313.         *missing_events = next_lost;

  315.     return next;
  316. }

  318. /* Find the next real entry, and increment the iterator to the next entry */
  319. ‌static void *trace_find_next_entry_inc(struct trace_iterator *iter)
  320. {
  321.     iter->ent = __find_next_entry(iter, &iter->cpu,
  322.                       &iter->lost_events, &iter->ts);
  323.     if (iter->ent)
  324.         iter->idx++;

  326.     return iter->ent ? iter : NULL;
  327. }

  329. ‌static void poll_wait_pipe(void)
  330. {
  331.     set_current_state(TASK_INTERRUPTIBLE);
  332.     /* sleep for 100 msecs, and try again. */
  333.     schedule_timeout(HZ / 10);
  334. }

  336. ‌static int tracing_wait_pipe(struct file *filp)
  337. {
  338.     struct trace_iterator *iter = filp->private_data;
  339.     struct ktap_trace_iterator *ktap_iter = KTAP_TRACE_ITER(iter);
  340.     ktap_state_t *ks = ktap_iter->private;

  342.     while (trace_empty(iter)) {

  344.         if ((filp->f_flags & O_NONBLOCK)) {
  345.             return -EAGAIN;
  346.         }

  348.         mutex_unlock(&iter->mutex);

  350.         poll_wait_pipe();

  352.         mutex_lock(&iter->mutex);

  354.         if (G(ks)->wait_user && trace_empty(iter))
  355.             return -EINTR;
  356.     }

  358.     return 1;
  359. }

  361. static ssize_t
  362. ‌tracing_read_pipe(struct file *filp, char __user *ubuf, size_t cnt,
  363.           loff_t *ppos)
  364. {
  365.     struct trace_iterator *iter = filp->private_data;
  366.     ssize_t sret;

  368.     /* return any leftover data */
  369.     sret = _trace_seq_to_user(&iter->seq, ubuf, cnt);
  370.     if (sret != -EBUSY)
  371.         return sret;
  372.     /*
  373.      * Avoid more than one consumer on a single file descriptor
  374.      * This is just a matter of traces coherency, the ring buffer itself
  375.      * is protected.
  376.      */
  377.     mutex_lock(&iter->mutex);

  379. waitagain:
  380.     sret = tracing_wait_pipe(filp);
  381.     if (sret <= 0)
  382.         goto out;

  384.     /* stop when tracing is finished */
  385.     if (trace_empty(iter)) {
  386.         sret = 0;
  387.         goto out;
  388.     }

  390.     if (cnt >= PAGE_SIZE)
  391.         cnt = PAGE_SIZE - 1;

  393.     /* reset all but tr, trace, and overruns */
  394.     memset(&iter->seq, 0,
  395.            sizeof(struct trace_iterator) -
  396.            offsetof(struct trace_iterator, seq));
  397.     iter->pos = -1;

  399.     while (trace_find_next_entry_inc(iter) != NULL) {
  400.         enum print_line_t ret;
  401.         int len = iter->seq.len;

  403.         ret = print_trace_line(iter);
  404.         if (ret == TRACE_TYPE_PARTIAL_LINE) {
  405.             /* don't print partial lines */
  406.             iter->seq.len = len;
  407.             break;
  408.         }
  409.         if (ret != TRACE_TYPE_NO_CONSUME)
  410.             trace_consume(iter);

  412.         if (iter->seq.len >= cnt)
  413.             break;

  415.         /*
  416.          * Setting the full flag means we reached the trace_seq buffer
  417.          * size and we should leave by partial output condition above.
  418.          * One of the trace_seq_* functions is not used properly.
  419.          */
  420.         WARN_ONCE(iter->seq.full, "full flag set for trace type %d",
  421.               iter->ent->type);
  422.     }

  424.     /* Now copy what we have to the user */
  425.     sret = _trace_seq_to_user(&iter->seq, ubuf, cnt);
  426.     if (iter->seq.readpos >= iter->seq.len)
  427.         trace_seq_init(&iter->seq);

  429.     /*
  430.      * If there was nothing to send to user, in spite of consuming trace
  431.      * entries, go back to wait for more entries.
  432.      */
  433.     if (sret == -EBUSY)
  434.         goto waitagain;

  436. out:
  437.     mutex_unlock(&iter->mutex);

  439.     return sret;
  440. }

  442. ‌static int tracing_open_pipe(struct inode *inode, struct file *filp)
  443. {
  444.     struct ktap_trace_iterator *ktap_iter;
  445.     ktap_state_t *ks = inode->i_private;

  447.     /* create a buffer to store the information to pass to userspace */
  448.     ktap_iter = kzalloc(sizeof(*ktap_iter), GFP_KERNEL);
  449.     if (!ktap_iter)
  450.         return -ENOMEM;

  452.     ktap_iter->private = ks;
  453.     ktap_iter->buffer = G(ks)->buffer;
  454.     ktap_iter->print_timestamp = G(ks)->parm->print_timestamp;
  455.     mutex_init(&ktap_iter->iter.mutex);
  456.     filp->private_data = &ktap_iter->iter;

  458.     nonseekable_open(inode, filp);

  460.     return 0;
  461. }

  463. ‌static int tracing_release_pipe(struct inode *inode, struct file *file)
  464. {
  465.     struct trace_iterator *iter = file->private_data;
  466.     struct ktap_trace_iterator *ktap_iter = KTAP_TRACE_ITER(iter);

  468.     mutex_destroy(&iter->mutex);
  469.     kfree(ktap_iter);
  470.     return 0;
  471. }

  473. ‌static const struct file_operations tracing_pipe_fops = {
  474.     .open        = tracing_open_pipe,
  475.     .read        = tracing_read_pipe,
  476.     .splice_read    = NULL,
  477.     .release    = tracing_release_pipe,
  478.     .llseek        = no_llseek,
  479. };

  481. /*
  482. * preempt disabled in ring_buffer_lock_reserve
  483. *
  484. * The implementation is similar with funtion __ftrace_trace_stack.
  485. */
  486. ‌void kp_transport_print_kstack(ktap_state_t *ks, uint16_t depth, uint16_t skip)
  487. {
  488.     struct ring_buffer *buffer = G(ks)->buffer;
  489.     struct ring_buffer_event *event;
  490.     struct trace_entry *entry;
  491.     int size;

  493.     size = depth * sizeof(unsigned long);
  494.     event = ring_buffer_lock_reserve(buffer, sizeof(*entry) + size);
  495.     if (!event) {
  496.         KTAP_STATS(ks)->events_missed += 1;
  497.         return;
  498.     } else {
  499.         struct stack_trace trace;

  501.         entry = ring_buffer_event_data(event);
  502.         tracing_generic_entry_update(entry, 0, 0);
  503.         entry->type = TRACE_STACK;

  505.         trace.nr_entries = 0;
  506.         trace.skip = skip;
  507.         trace.max_entries = depth;
  508.         trace.entries = (unsigned long *)(entry + 1);
  509.         save_stack_trace(&trace);

  511.         ring_buffer_unlock_commit(buffer, event);
  512.     }
  513. }

  515. ‌void kp_transport_event_write(ktap_state_t *ks, struct ktap_event_data *e)
  516. {
  517.     struct ring_buffer *buffer = G(ks)->buffer;
  518.     struct ring_buffer_event *event;
  519.     struct trace_entry *ev_entry = e->data->raw->data;
  520.     struct trace_entry *entry;
  521.     int entry_size = e->data->raw->size;

  523.     event = ring_buffer_lock_reserve(buffer, entry_size +
  524.                      sizeof(struct ftrace_event_call *));
  525.     if (!event) {
  526.         KTAP_STATS(ks)->events_missed += 1;
  527.         return;
  528.     } else {
  529.         entry = ring_buffer_event_data(event);

  531.         memcpy(entry, ev_entry, entry_size);

  533.         ring_buffer_unlock_commit(buffer, event);
  534.     }
  535. }

  537. ‌void kp_transport_write(ktap_state_t *ks, const void *data, size_t length)
  538. {
  539.     struct ring_buffer *buffer = G(ks)->buffer;
  540.     struct ring_buffer_event *event;
  541.     struct trace_entry *entry;
  542.     int size;

  544.     size = sizeof(struct trace_entry) + length;

  546.     event = ring_buffer_lock_reserve(buffer, size);
  547.     if (!event) {
  548.         KTAP_STATS(ks)->events_missed += 1;
  549.         return;
  550.     } else {
  551.         entry = ring_buffer_event_data(event);

  553.         tracing_generic_entry_update(entry, 0, 0);
  554.         entry->type = TRACE_PRINT;
  555.         memcpy(entry + 1, data, length);

  557.         ring_buffer_unlock_commit(buffer, event);
  558.     }
  559. }

  561. /* general print function */
  562. ‌void kp_printf(ktap_state_t *ks, const char *fmt, ...)
  563. {
  564.     char buff[1024];
  565.     va_list args;
  566.     int len;

  568.     va_start(args, fmt);
  569.     len = vscnprintf(buff, 1024, fmt, args);
  570.     va_end(args);

  572.     buff[len] = '\0';
  573.     kp_transport_write(ks, buff, len + 1);
  574. }

  576. ‌void __kp_puts(ktap_state_t *ks, const char *str)
  577. {
  578.     kp_transport_write(ks, str, strlen(str) + 1);
  579. }

  581. ‌void __kp_bputs(ktap_state_t *ks, const char *str)
  582. {
  583.     struct ring_buffer *buffer = G(ks)->buffer;
  584.     struct ring_buffer_event *event;
  585.     struct trace_entry *entry;
  586.     int size;

  588.     size = sizeof(struct trace_entry) + sizeof(unsigned long *);

  590.     event = ring_buffer_lock_reserve(buffer, size);
  591.     if (!event) {
  592.         KTAP_STATS(ks)->events_missed += 1;
  593.         return;
  594.     } else {
  595.         entry = ring_buffer_event_data(event);

  597.         tracing_generic_entry_update(entry, 0, 0);
  598.         entry->type = TRACE_BPUTS;
  599.         *(unsigned long *)(entry + 1) = (unsigned long)str;

  601.         ring_buffer_unlock_commit(buffer, event);
  602.     }
  603. }

  605. ‌void kp_transport_exit(ktap_state_t *ks)
  606. {
  607.     if (G(ks)->buffer)
  608.         ring_buffer_free(G(ks)->buffer);
  609.     debugfs_remove(G(ks)->trace_pipe_dentry);
  610. }

  612. ‌#define TRACE_BUF_SIZE_DEFAULT    1441792UL /* 16384 * 88 (sizeof(entry)) */

  614. ‌int kp_transport_init(ktap_state_t *ks, struct dentry *dir)
  615. {
  616.     struct ring_buffer *buffer;
  617.     struct dentry *dentry;
  618.     char filename[32] = {0};

  620. #ifdef CONFIG_PPC64
  621.     ftrace_find_event = (void *)kallsyms_lookup_name(".ftrace_find_event");
  622. #else
  623.     ftrace_find_event = (void *)kallsyms_lookup_name("ftrace_find_event");
  624. #endif
  625.     if (!ftrace_find_event) {
  626.         printk("ktap: cannot lookup ftrace_find_event in kallsyms\n");
  627.         return -EINVAL;
  628.     }

  630.     buffer = ring_buffer_alloc(TRACE_BUF_SIZE_DEFAULT, RB_FL_OVERWRITE);
  631.     if (!buffer)
  632.         return -ENOMEM;

  634.     sprintf(filename, "trace_pipe_%d", (int)task_tgid_vnr(current));

  636.     dentry = debugfs_create_file(filename, 0444, dir,
  637.                      ks, &tracing_pipe_fops);
  638.     if (!dentry) {
  639.         pr_err("ktapvm: cannot create trace_pipe file in debugfs\n");
  640.         ring_buffer_free(buffer);
  641.         return -1;
  642.     }

  644.     G(ks)->buffer = buffer;
  645.     G(ks)->trace_pipe_dentry = dentry;

  647.     return 0;
  648. }

One Level Up Top Level