One Level Up Top Level

runtime/lib_timer.c - ktap

Global variables defined

Data types defined

Functions defined

Source code

  1. /*
  2. * lib_timer.c - timer 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/ctype.h>
  23. #include <linux/slab.h>
  24. #include <linux/delay.h>
  25. #include <linux/sched.h>
  26. #include "../include/ktap_types.h"
  27. #include "ktap.h"
  28. #include "kp_obj.h"
  29. #include "kp_vm.h"
  30. #include "kp_events.h"

  32. ‌struct ktap_hrtimer {
  33.     struct hrtimer timer;
  34.     ktap_state_t *ks;
  35.     ktap_func_t *fn;
  36.     u64 ns;
  37.     struct list_head list;
  38. };

  40. /*
  41. * Currently ktap disallow tracing event in timer callback closure,
  42. * that will corrupt ktap_state_t and ktap stack, because timer closure
  43. * and event closure use same irq percpu ktap_state_t and stack.
  44. * We can use a different percpu ktap_state_t and stack for timer purpuse,
  45. * but that's don't bring any big value with cost on memory consuming.
  46. *
  47. * So just simply disable tracing in timer closure,
  48. * get_recursion_context()/put_recursion_context() is used for this purpose.
  49. */
  50. ‌static enum hrtimer_restart hrtimer_ktap_fn(struct hrtimer *timer)
  51. {
  52.     struct ktap_hrtimer *t;
  53.     ktap_state_t *ks;
  54.     int rctx;

  56.     rcu_read_lock_sched_notrace();

  58.     t = container_of(timer, struct ktap_hrtimer, timer);
  59.     rctx = get_recursion_context(t->ks);

  61.     ks = kp_vm_new_thread(t->ks, rctx);
  62.     set_func(ks->top, t->fn);
  63.     incr_top(ks);
  64.     kp_vm_call(ks, ks->top - 1, 0);
  65.     kp_vm_exit_thread(ks);

  67.     hrtimer_add_expires_ns(timer, t->ns);

  69.     put_recursion_context(ks, rctx);
  70.     rcu_read_unlock_sched_notrace();

  72.     return HRTIMER_RESTART;
  73. }

  75. ‌static int set_tick_timer(ktap_state_t *ks, u64 period, ktap_func_t *fn)
  76. {
  77.     struct ktap_hrtimer *t;

  79.     t = kp_malloc(ks, sizeof(*t));
  80.     if (unlikely(!t))
  81.         return -ENOMEM;
  82.     t->ks = ks;
  83.     t->fn = fn;
  84.     t->ns = period;

  86.     INIT_LIST_HEAD(&t->list);
  87.     list_add(&t->list, &(G(ks)->timers));

  89.     hrtimer_init(&t->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
  90.     t->timer.function = hrtimer_ktap_fn;
  91.     hrtimer_start(&t->timer, ns_to_ktime(period), HRTIMER_MODE_REL);

  93.     return 0;
  94. }

  96. ‌static int set_profile_timer(ktap_state_t *ks, u64 period, ktap_func_t *fn)
  97. {
  98.     struct perf_event_attr attr;

  100.     memset(&attr, 0, sizeof(attr));
  101.     attr.type = PERF_TYPE_SOFTWARE;
  102.     attr.config = PERF_COUNT_SW_CPU_CLOCK;
  103.     attr.sample_type = PERF_SAMPLE_RAW | PERF_SAMPLE_TIME |
  104.                PERF_SAMPLE_CPU | PERF_SAMPLE_PERIOD;
  105.     attr.sample_period = period;
  106.     attr.size = sizeof(attr);
  107.     attr.disabled = 0;

  109.     return kp_event_create(ks, &attr, NULL, NULL, fn);
  110. }

  112. ‌static int do_tick_profile(ktap_state_t *ks, int is_tick)
  113. {
  114.     const char *str = kp_arg_checkstring(ks, 1);
  115.     ktap_func_t *fn = kp_arg_checkfunction(ks, 2);
  116.     const char *tmp;
  117.     char interval_str[32] = {0};
  118.     char suffix[10] = {0};
  119.     int i = 0, ret, n;
  120.     int factor;

  122.     tmp = str;
  123.     while (isdigit(*tmp))
  124.         tmp++;

  126.     strncpy(interval_str, str, tmp - str);
  127.     if (kstrtoint(interval_str, 10, &n))
  128.         goto error;

  130.     strncpy(suffix, tmp, 9);
  131.     while (suffix[i] != ' ' && suffix[i] != '\0')
  132.         i++;

  134.     suffix[i] = '\0';

  136.     if (!strcmp(suffix, "s") || !strcmp(suffix, "sec"))
  137.         factor = NSEC_PER_SEC;
  138.     else if (!strcmp(suffix, "ms") || !strcmp(suffix, "msec"))
  139.         factor = NSEC_PER_MSEC;
  140.     else if (!strcmp(suffix, "us") || !strcmp(suffix, "usec"))
  141.         factor = NSEC_PER_USEC;
  142.     else
  143.         goto error;

  145.     if (is_tick)
  146.         ret = set_tick_timer(ks, (u64)factor * n, fn);
  147.     else
  148.         ret = set_profile_timer(ks, (u64)factor * n, fn);

  150.     return ret;

  152. error:
  153.     kp_error(ks, "cannot parse timer interval: %s\n", str);
  154.     return -1;
  155. }

  157. /*
  158. * tick-n probes fire on only one CPU per interval.
  159. * valid time suffixes: sec/s, msec/ms, usec/us
  160. */
  161. ‌static int kplib_timer_tick(ktap_state_t *ks)
  162. {
  163.     /* timer.tick cannot be called in trace_end state */
  164.     if (G(ks)->state != KTAP_RUNNING) {
  165.         kp_error(ks,
  166.              "timer.tick only can be called in RUNNING state\n");
  167.         return -1;
  168.     }

  170.     return do_tick_profile(ks, 1);
  171. }

  173. /*
  174. * A profile-n probe fires every fixed interval on every CPU
  175. * valid time suffixes: sec/s, msec/ms, usec/us
  176. */
  177. ‌static int kplib_timer_profile(ktap_state_t *ks)
  178. {
  179.     /* timer.profile cannot be called in trace_end state */
  180.     if (G(ks)->state != KTAP_RUNNING) {
  181.         kp_error(ks,
  182.              "timer.profile only can be called in RUNNING state\n");
  183.         return -1;
  184.     }

  186.     return do_tick_profile(ks, 0);
  187. }

  189. ‌void kp_exit_timers(ktap_state_t *ks)
  190. {
  191.     struct ktap_hrtimer *t, *tmp;
  192.     struct list_head *timers_list = &(G(ks)->timers);

  194.     list_for_each_entry_safe(t, tmp, timers_list, list) {
  195.         hrtimer_cancel(&t->timer);
  196.         kp_free(ks, t);
  197.     }
  198. }

  200. ‌static const ktap_libfunc_t timer_lib_funcs[] = {
  201.     {"profile",    kplib_timer_profile},
  202.     {"tick",    kplib_timer_tick},
  203.     {NULL}
  204. };

  206. ‌int kp_lib_init_timer(ktap_state_t *ks)
  207. {
  208.     return kp_vm_register_lib(ks, "timer", timer_lib_funcs);
  209. }

One Level Up Top Level