One Level Up Top Level

runtime/ktap.c - ktap

Global variables defined

Functions defined

Source code

  1. /*
  2. * ktap.c - ktapvm kernel module main entry
  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. /*
  23. * this file is the first file to be compile, add CONFIG_ checking in here.
  24. * See Requirements in doc/tutorial.md
  25. */

  27. #include <linux/version.h>
  28. #if LINUX_VERSION_CODE < KERNEL_VERSION(3, 1, 0)
  29. #error "Currently ktap don't support kernel older than 3.1"
  30. #endif

  32. #if !CONFIG_EVENT_TRACING
  33. #error "Please enable CONFIG_EVENT_TRACING before compile ktap"
  34. #endif

  36. #if !CONFIG_PERF_EVENTS
  37. #error "Please enable CONFIG_PERF_EVENTS before compile ktap"
  38. #endif

  40. #include <linux/module.h>
  41. #include <linux/errno.h>
  42. #include <linux/file.h>
  43. #include <linux/slab.h>
  44. #include <linux/fcntl.h>
  45. #include <linux/sched.h>
  46. #include <linux/poll.h>
  47. #include <linux/anon_inodes.h>
  48. #include <linux/debugfs.h>
  49. #include <linux/vmalloc.h>
  50. #include "../include/ktap_types.h"
  51. #include "ktap.h"
  52. #include "kp_bcread.h"
  53. #include "kp_vm.h"

  55. /* common helper function */
  56. ‌long gettimeofday_ns(void)
  57. {
  58.     struct timespec now;

  60.     getnstimeofday(&now);
  61.     return now.tv_sec * NSEC_PER_SEC + now.tv_nsec;
  62. }

  64. ‌static int load_trunk(ktap_option_t *parm, unsigned long **buff)
  65. {
  66.     int ret;
  67.     unsigned long *vmstart;

  69.     vmstart = vmalloc(parm->trunk_len);
  70.     if (!vmstart)
  71.         return -ENOMEM;

  73.     ret = copy_from_user(vmstart, (void __user *)parm->trunk,
  74.                  parm->trunk_len);
  75.     if (ret < 0) {
  76.         vfree(vmstart);
  77.         return -EFAULT;
  78.     }

  80.     *buff = vmstart;
  81.     return 0;
  82. }

  84. ‌static struct dentry *kp_dir_dentry;

  86. /* Ktap Main Entry */
  87. ‌static int ktap_main(struct file *file, ktap_option_t *parm)
  88. {
  89.     unsigned long *buff = NULL;
  90.     ktap_state_t *ks;
  91.     ktap_proto_t *pt;
  92.     long start_time, delta_time;
  93.     int ret;

  95.     start_time = gettimeofday_ns();

  97.     ks = kp_vm_new_state(parm, kp_dir_dentry);
  98.     if (unlikely(!ks))
  99.         return -ENOEXEC;

  101.     file->private_data = ks;

  103.     ret = load_trunk(parm, &buff);
  104.     if (ret) {
  105.         kp_error(ks, "cannot load file\n");
  106.         goto out;
  107.     }

  109.     pt = kp_bcread(ks, (unsigned char *)buff, parm->trunk_len);

  111.     vfree(buff);

  113.     if (pt) {
  114.         /* validate byte code */
  115.         if (kp_vm_validate_code(ks, pt, ks->stack))
  116.             goto out;

  118.         delta_time = (gettimeofday_ns() - start_time) / NSEC_PER_USEC;
  119.         kp_verbose_printf(ks, "booting time: %d (us)\n", delta_time);

  121.         /* enter vm */
  122.         kp_vm_call_proto(ks, pt);
  123.     }

  125. out:
  126.     kp_vm_exit(ks);
  127.     return ret;
  128. }


  131. ‌static void print_version(void)
  132. {
  133. }

  135. ‌static long ktap_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
  136. {
  137.     ktap_option_t parm;
  138.     int ret;

  140.     switch (cmd) {
  141.     case KTAP_CMD_IOC_VERSION:
  142.         print_version();
  143.         return 0;
  144.     case KTAP_CMD_IOC_RUN:
  145.         /*
  146.          * must be root to run ktap script (at least for now)
  147.          *
  148.          * TODO: check perf_paranoid sysctl and allow non-root user
  149.          * to use ktap for tracing process(like uprobe) ?
  150.          */
  151.         if (!capable(CAP_SYS_ADMIN))
  152.             return -EACCES;

  154.         ret = copy_from_user(&parm, (void __user *)arg,
  155.                      sizeof(ktap_option_t));
  156.         if (ret < 0)
  157.             return -EFAULT;

  159.         return ktap_main(file, &parm);
  160.     default:
  161.         return -EINVAL;
  162.     };

  164.         return 0;
  165. }

  167. ‌static const struct file_operations ktap_fops = {
  168.     .llseek                 = no_llseek,
  169.     .unlocked_ioctl         = ktap_ioctl,
  170. };

  172. ‌static long ktapvm_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
  173. {
  174.     int new_fd, err;
  175.     struct file *new_file;

  177.     new_fd = get_unused_fd();
  178.     if (new_fd < 0)
  179.         return new_fd;

  181.     new_file = anon_inode_getfile("[ktap]", &ktap_fops, NULL, O_RDWR);
  182.     if (IS_ERR(new_file)) {
  183.         err = PTR_ERR(new_file);
  184.         put_unused_fd(new_fd);
  185.         return err;
  186.     }

  188.     file->private_data = NULL;
  189.     fd_install(new_fd, new_file);
  190.     return new_fd;
  191. }

  193. ‌static const struct file_operations ktapvm_fops = {
  194.     .owner  = THIS_MODULE,
  195.     .unlocked_ioctl         = ktapvm_ioctl,
  196. };

  198. ‌int (*kp_ftrace_profile_set_filter)(struct perf_event *event, int event_id,
  199.                     const char *filter_str);

  201. ‌struct syscall_metadata **syscalls_metadata;

  203. /*TODO: kill this function in future */
  204. ‌static int __init init_dummy_kernel_functions(void)
  205. {
  206.     unsigned long *addr;

  208.     /*
  209.      * ktap need symbol ftrace_profile_set_filter to set event filter,
  210.      * export it in future.
  211.      */
  212. #ifdef CONFIG_PPC64
  213.     kp_ftrace_profile_set_filter =
  214.         (void *)kallsyms_lookup_name(".ftrace_profile_set_filter");
  215. #else
  216.     kp_ftrace_profile_set_filter =
  217.         (void *)kallsyms_lookup_name("ftrace_profile_set_filter");
  218. #endif
  219.     if (!kp_ftrace_profile_set_filter) {
  220.         pr_err("ktap: cannot lookup ftrace_profile_set_filter "
  221.             "in kallsyms\n");
  222.         return -1;
  223.     }

  225.     /* use syscalls_metadata for syscall event handling */
  226.     addr = (void *)kallsyms_lookup_name("syscalls_metadata");
  227.     if (!addr) {
  228.         pr_err("ktap: cannot lookup syscalls_metadata in kallsyms\n");
  229.         return -1;
  230.     }

  232.     syscalls_metadata = (struct syscall_metadata **)*addr;
  233.     return 0;
  234. }

  236. ‌static int __init init_ktap(void)
  237. {
  238.     struct dentry *ktapvm_dentry;

  240.     if (init_dummy_kernel_functions())
  241.         return -1;

  243.     kp_dir_dentry = debugfs_create_dir("ktap", NULL);
  244.     if (!kp_dir_dentry) {
  245.         pr_err("ktap: debugfs_create_dir failed\n");
  246.         return -1;
  247.     }

  249.     ktapvm_dentry = debugfs_create_file("ktapvm", 0444, kp_dir_dentry, NULL,
  250.                         &ktapvm_fops);

  252.     if (!ktapvm_dentry) {
  253.         pr_err("ktapvm: cannot create ktapvm file\n");
  254.         debugfs_remove_recursive(kp_dir_dentry);
  255.         return -1;
  256.     }

  258.     return 0;
  259. }

  261. ‌static void __exit exit_ktap(void)
  262. {
  263.     debugfs_remove_recursive(kp_dir_dentry);
  264. }

  266. ‌module_init(init_ktap);
  267. ‌module_exit(exit_ktap);

  269. MODULE_AUTHOR("Jovi Zhangwei <jovi.zhangwei@gmail.com>");
  270. MODULE_DESCRIPTION("ktap");
  271. MODULE_LICENSE("GPL");

  273. ‌int kp_max_loop_count = 100000;
  274. module_param_named(max_loop_count, kp_max_loop_count, int, S_IRUGO | S_IWUSR);
  275. MODULE_PARM_DESC(max_loop_count, "max loop execution count");

One Level Up Top Level