ks_features/ks_features.c

   1 #include <linux/module.h>
   2 #include <asm/errno.h>
   3 #include <ksyms.h>
   4 #include <dbi_kprobes.h>
   5 #include "ks_features.h"
   6 #include "syscall_list.h"
   7 #include "features_data.c"
   8
   9
  10 struct ks_probe {
  11         struct kretprobe rp;
  12         int counter;
  13         char *args;
  14 };
  15
  16 #define CREATE_RP(name)                                         \
  17 {                                                               \
  18         .entry_handler = NULL,                                  \
  19         .handler = NULL                                         \
  20 }
  21
  22 #define X(name, args) #name
  23 static const char *const syscall_name[] = {
  24         SYSCALL_LIST
  25 };
  26 #undef X
  27
  28 enum {
  29         syscall_name_cnt = sizeof(syscall_name) / sizeof(char *)
  30 };
  31
  32
  33 #define X(name, args__)                                         \
  34 {                                                               \
  35         .rp = CREATE_RP(name),                                  \
  36         .counter = 0,                                           \
  37         .args = #args__                                         \
  38 }
  39
  40 static struct ks_probe ksp[] = {
  41         SYSCALL_LIST
  42 };
  43 #undef X
  44
  45
  46 static char *get_sys_name(size_t id)
  47 {
  48         return syscall_name[id];
  49 }
  50
  51 static int get_counter(size_t id)
  52 {
  53         return ksp[id].counter;
  54 }
  55
  56 static void inc_counter(size_t id)
  57 {
  58         ++ksp[id].counter;
  59 }
  60
  61 static void dec_counter(size_t id)
  62 {
  63         --ksp[id].counter;
  64 }
  65
  66 /* ========================= HEANDLERS ========================= */
  67 /* FIXME: */
  68 #include <ec_probe.h>
  69 #include <picl.h>
  70 #include <storage.h>
  71
  72 static int entry_handler(struct kretprobe_instance *ri, struct pt_regs *regs, void *priv_arg)
  73 {
  74         struct ks_probe *ksp = (struct ks_probe *)priv_arg;
  75
  76         pack_event_info(KS_PROBE_ID, RECORD_ENTRY, "ps", ksp->rp.kp.addr, ksp->args);
  77
  78         return 0;
  79 }
  80
  81 static int ret_handler(struct kretprobe_instance *ri, struct pt_regs *regs, void *priv_arg)
  82 {
  83         int ret_val;
  84         struct ks_probe *ksp = (struct ks_probe *)priv_arg;
  85
  86         ret_val = regs_return_value(regs);
  87         pack_event_info(KS_PROBE_ID, RECORD_RET, "pd", ksp->rp.kp.addr, ret_val);
  88
  89         return 0;
  90 }
  91 /* ========================= HEANDLERS ========================= */
  92
  93
  94
  95 static int register_syscall(size_t id)
  96 {
  97         int ret;
  98         printk("register_syscall: %s\n", get_sys_name(id));
  99
 100         if (ksp[id].rp.kp.addr == NULL)
 101                 return 0;
 102
 103         ksp[id].rp.entry_handler = entry_handler;
 104         ksp[id].rp.handler = ret_handler;
 105         ksp[id].rp.priv_arg = &ksp[id];
 106
 107         ret = dbi_register_kretprobe(&ksp[id].rp);
 108
 109         return ret;
 110 }
 111
 112 static int unregister_syscall(size_t id)
 113 {
 114         printk("unregister_syscall: %s\n", get_sys_name(id));
 115
 116         if (ksp[id].rp.kp.addr == NULL)
 117                 return 0;
 118
 119         dbi_unregister_kretprobe(&ksp[id].rp);
 120
 121         return 0;
 122 }
 123
 124 static int install_features(struct feature *f)
 125 {
 126         size_t i, id;
 127
 128         for (i = 0; i < f->cnt; ++i) {
 129                 id = f->feature_list[i];
 130
 131                 if (get_counter(id) == 0) {
 132                         int ret = register_syscall(id);
 133                         if (ret) {
 134                                 /* TODO: error */
 135                                 return ret;
 136                         }
 137                 }
 138
 139                 inc_counter(id);
 140         }
 141
 142         return 0;
 143 }
 144
 145 static int uninstall_features(struct feature *f)
 146 {
 147         size_t i, id;
 148
 149         for (i = 0; i < f->cnt; ++i) {
 150                 id = f->feature_list[i];
 151
 152                 if (get_counter(id) == 0) {
 153                         /* TODO: error */
 154                         return -EINVAL;
 155                 }
 156
 157                 dec_counter(id);
 158
 159                 if (get_counter(id) == 0) {
 160                         int ret = unregister_syscall(id);
 161                         if (ret) {
 162                                 /* TODO: error */
 163                                 return ret;
 164                         }
 165                 }
 166         }
 167
 168         return 0;
 169 }
 170
 171 static struct feature *get_feature(enum feature_id id)
 172 {
 173         if (id < 0 || id >= (int)feature_cnt)
 174                 return NULL;
 175
 176         return &features[id];
 177 }
 178
 179 int set_feature(enum feature_id id)
 180 {
 181         struct feature *f = get_feature(id);
 182
 183         if (f == NULL)
 184                 return -EINVAL;
 185
 186         return install_features(f);
 187 }
 188 EXPORT_SYMBOL_GPL(set_feature);
 189
 190 int unset_feature(enum feature_id id)
 191 {
 192         struct feature *f = get_feature(id);
 193
 194         if (f == NULL)
 195                 return -EINVAL;
 196
 197         return uninstall_features(f);
 198 }
 199 EXPORT_SYMBOL_GPL(unset_feature);
 200
 201 static int __init init_ks_feature(void)
 202 {
 203         int i;
 204         unsigned long addr, ni_syscall;
 205         char *name;
 206
 207         ni_syscall = swap_ksyms("sys_ni_syscall");
 208
 209         for (i = 0; i < syscall_name_cnt; ++i) {
 210                 name = get_sys_name(i);
 211                 addr = swap_ksyms(name);
 212                 if (addr == 0) {
 213                         printk("%s() not found\n", name);
 214                         return -EFAULT;
 215                 }
 216
 217                 if (ni_syscall == addr) {
 218                         printk("INFO: %s is not install\n", get_sys_name(i));
 219                         addr = 0;
 220                 }
 221
 222                 ksp[i].rp.kp.addr = addr;
 223         }
 224
 225         return 0;
 226 }
 227
 228 static void __exit exit_ks_feature(void)
 229 {
 230 }
 231
 232 module_init(init_ks_feature);
 233 module_exit(exit_ks_feature);
 234
 235 MODULE_LICENSE("GPL");
 236
 237 /* debug */
 238 static void print_feature(struct feature *f)
 239 {
 240         size_t i;
 241
 242         for (i = 0; i < f->cnt; ++i) {
 243                 printk("    feature[%3u]: %s\n", i, get_sys_name(f->feature_list[i]));
 244         }
 245 }
 246
 247 void print_features(void)
 248 {
 249         int i;
 250
 251         printk("print_features:\n");
 252         for (i = 0; i < feature_cnt; ++i) {
 253                 printk("feature: %d\n", i);
 254                 print_feature(&features[i]);
 255         }
 256 }
 257
 258 void print_all_syscall(void)
 259 {
 260         int i;
 261
 262         printk("SYSCALL:\n");
 263         for (i = 0; i < syscall_name_cnt; ++i) {
 264                 printk("    [%2d] %s\n", get_counter(i), get_sys_name(i));
 265         }
 266 }
 267 /* debug */