One Level Up Top Level

runtime/lib_kdebug.c - ktap

Global variables defined

Functions defined

Source code

  1. /*
  2. * lib_kdebug.c - kdebug library support for ktap
  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/module.h>
  23. #include <linux/ctype.h>
  24. #include <linux/slab.h>
  25. #include <linux/version.h>
  26. #include <linux/ftrace_event.h>
  27. #include "../include/ktap_types.h"
  28. #include "ktap.h"
  29. #include "kp_obj.h"
  30. #include "kp_str.h"
  31. #include "kp_transport.h"
  32. #include "kp_vm.h"
  33. #include "kp_events.h"

  35. /**
  36. * function kdebug.trace_by_id
  37. *
  38. * @uaddr: userspace address refer to ktap_eventdesc_t
  39. * @closure
  40. */
  41. ‌static int kplib_kdebug_trace_by_id(ktap_state_t *ks)
  42. {
  43.     unsigned long uaddr = kp_arg_checknumber(ks, 1);
  44.     ktap_func_t *fn = kp_arg_checkfunction(ks, 2);
  45.     struct task_struct *task = G(ks)->trace_task;
  46.     ktap_eventdesc_t eventsdesc;
  47.     char *filter = NULL;
  48.     int *id_arr;
  49.     int ret, i;

  51.     if (G(ks)->mainthread != ks) {
  52.         kp_error(ks,
  53.             "kdebug.trace_by_id only can be called in mainthread\n");
  54.         return -1;
  55.     }

  57.     /* kdebug.trace_by_id cannot be called in trace_end state */
  58.     if (G(ks)->state != KTAP_RUNNING) {
  59.         kp_error(ks,
  60.             "kdebug.trace_by_id only can be called in RUNNING state\n");
  61.         return -1;
  62.     }

  64.     /* copy ktap_eventdesc_t from userspace */
  65.     ret = copy_from_user(&eventsdesc, (void *)uaddr,
  66.                  sizeof(ktap_eventdesc_t));
  67.     if (ret < 0)
  68.         return -1;

  70.     if (eventsdesc.filter) {
  71.         int len;

  73.         len = strlen_user(eventsdesc.filter);
  74.         if (len > 0x1000)
  75.             return -1;

  77.         filter = kmalloc(len + 1, GFP_KERNEL);
  78.         if (!filter)
  79.             return -1;

  81.         /* copy filter string from userspace */
  82.         if (strncpy_from_user(filter, eventsdesc.filter, len) < 0) {
  83.             kfree(filter);
  84.             return -1;
  85.         }
  86.     }

  88.     id_arr = kmalloc(eventsdesc.nr * sizeof(int), GFP_KERNEL);
  89.     if (!id_arr) {
  90.         kfree(filter);
  91.         return -1;
  92.     }

  94.     /* copy all event id from userspace */
  95.     ret = copy_from_user(id_arr, eventsdesc.id_arr,
  96.                  eventsdesc.nr * sizeof(int));
  97.     if (ret < 0) {
  98.         kfree(filter);
  99.         kfree(id_arr);
  100.         return -1;
  101.     }

  103.     fn = clvalue(kp_arg(ks, 2));

  105.     for (i = 0; i < eventsdesc.nr; i++) {
  106.         struct perf_event_attr attr;

  108.         cond_resched();

  110.         if (signal_pending(current)) {
  111.             flush_signals(current);
  112.             kfree(filter);
  113.             kfree(id_arr);
  114.             return -1;
  115.         }

  117.         memset(&attr, 0, sizeof(attr));
  118.         attr.type = PERF_TYPE_TRACEPOINT;
  119.         attr.config = id_arr[i];
  120.         attr.sample_type = PERF_SAMPLE_RAW | PERF_SAMPLE_TIME |
  121.                    PERF_SAMPLE_CPU | PERF_SAMPLE_PERIOD;
  122.         attr.sample_period = 1;
  123.         attr.size = sizeof(attr);
  124.         attr.disabled = 0;

  126.         /* register event one by one */
  127.         ret = kp_event_create(ks, &attr, task, filter, fn);
  128.         if (ret < 0)
  129.             break;
  130.     }

  132.     kfree(filter);
  133.     kfree(id_arr);
  134.     return 0;
  135. }

  137. ‌static int kplib_kdebug_trace_end(ktap_state_t *ks)
  138. {
  139.     /* trace_end_closure will be called when ktap main thread exit */
  140.     G(ks)->trace_end_closure = kp_arg_checkfunction(ks, 1);
  141.     return 0;
  142. }

  144. #if 0
  145. static int kplib_kdebug_tracepoint(ktap_state_t *ks)
  146. {
  147.     const char *event_name = kp_arg_checkstring(ks, 1);
  148.     ktap_func_t *fn = kp_arg_checkfunction(ks, 2);

  150.     if (G(ks)->mainthread != ks) {
  151.         kp_error(ks,
  152.             "kdebug.tracepoint only can be called in mainthread\n");
  153.         return -1;
  154.     }

  156.     /* kdebug.tracepoint cannot be called in trace_end state */
  157.     if (G(ks)->state != KTAP_RUNNING) {
  158.         kp_error(ks,
  159.             "kdebug.tracepoint only can be called in RUNNING state\n");
  160.         return -1;
  161.     }

  163.     return kp_event_create_tracepoint(ks, event_name, fn);
  164. }
  165. #endif

  167. ‌static int kplib_kdebug_kprobe(ktap_state_t *ks)
  168. {
  169.     const char *event_name = kp_arg_checkstring(ks, 1);
  170.     ktap_func_t *fn = kp_arg_checkfunction(ks, 2);

  172.     if (G(ks)->mainthread != ks) {
  173.         kp_error(ks,
  174.             "kdebug.kprobe only can be called in mainthread\n");
  175.         return -1;
  176.     }

  178.     /* kdebug.kprobe cannot be called in trace_end state */
  179.     if (G(ks)->state != KTAP_RUNNING) {
  180.         kp_error(ks,
  181.             "kdebug.kprobe only can be called in RUNNING state\n");
  182.         return -1;
  183.     }

  185.     return kp_event_create_kprobe(ks, event_name, fn);
  186. }
  187. ‌static const ktap_libfunc_t kdebug_lib_funcs[] = {
  188.     {"trace_by_id", kplib_kdebug_trace_by_id},
  189.     {"trace_end", kplib_kdebug_trace_end},

  191. #if 0
  192.     {"tracepoint", kplib_kdebug_tracepoint},
  193. #endif
  194.     {"kprobe", kplib_kdebug_kprobe},
  195.     {NULL}
  196. };

  198. ‌int kp_lib_init_kdebug(ktap_state_t *ks)
  199. {
  200.     return kp_vm_register_lib(ks, "kdebug", kdebug_lib_funcs);
  201. }

One Level Up Top Level