driver/device_driver.c

   1 ////////////////////////////////////////////////////////////////////////////////////
   2 //
   3 //      FILE:           device_driver.c
   4 //
   5 //      DESCRIPTION:
   6 //      This file is C source for SWAP driver.
   7 //
   8 //      SEE ALSO:       device_driver.h
   9 //      AUTHOR:         L.Komkov, S.Dianov, S.Grekhov, A.Gerenkov
  10 //      COMPANY NAME:   Samsung Research Center in Moscow
  11 //      DEPT NAME:      Advanced Software Group
  12 //      CREATED:        2008.02.15
  13 //      VERSION:        1.0
  14 //      REVISION DATE:  2008.12.03
  15 //
  16 ////////////////////////////////////////////////////////////////////////////////////
  17
  18 #include "module.h"
  19 #include "device_driver.h"      // device driver
  20 #include "handlers_core.h"
  21 #include <linux/notifier.h>
  22 #include "sspt/sspt_procs.h"
  23
  24 #ifdef OVERHEAD_DEBUG
  25 extern unsigned long swap_sum_time;
  26 extern unsigned long swap_sum_hit;
  27 #endif
  28
  29
  30 extern unsigned long imi_sum_time;
  31 extern unsigned long imi_sum_hit;
  32
  33
  34 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 17)
  35 static BLOCKING_NOTIFIER_HEAD(swap_notifier_list);
  36 #endif
  37 pid_t gl_nNotifyTgid;
  38 EXPORT_SYMBOL_GPL(gl_nNotifyTgid);
  39
  40 DECLARE_WAIT_QUEUE_HEAD (notification_waiters_queue);
  41 volatile unsigned notification_count;
  42
  43 static int device_mmap (struct file *filp, struct vm_area_struct *vma);
  44 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 36)
  45 static int device_ioctl (struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg);
  46 #else
  47 static long device_ioctl (struct file *file, unsigned int cmd, unsigned long arg);
  48 #endif
  49 static int device_open(struct inode *, struct file *);
  50 static int device_release(struct inode *, struct file *);
  51 static ssize_t device_read(struct file *, char *, size_t, loff_t *);
  52 static ssize_t device_write(struct file *, const char *, size_t, loff_t *);
  53
  54 static int gl_nDeviceOpened = 0;
  55 static struct file_operations device_fops = {
  56         .owner = THIS_MODULE,
  57         .mmap = device_mmap,
  58 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 36)
  59         .ioctl = device_ioctl,
  60 #else
  61         .unlocked_ioctl = device_ioctl,
  62 #endif
  63         .read = device_read,
  64         .write = device_write,
  65         .open = device_open,
  66         .release = device_release
  67 };
  68
  69 typedef void (* dbi_module_callback)();
  70
  71 int device_init (void)
  72 {
  73         int nReserved = 0;
  74         nReserved = register_chrdev(0, device_name, &device_fops);
  75         if(nReserved < 0)
  76         {
  77                 unregister_chrdev(nReserved, device_name);
  78                 EPRINTF("Cannot register character device!");
  79                 return -1;
  80         }
  81         EPRINTF("New device node with major number [%d], was created\n", nReserved);
  82         device_major = nReserved;
  83         return 0;
  84 }
  85
  86 void device_down (void)
  87 {
  88         unregister_chrdev(device_major, device_name);
  89 }
  90
  91 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 17)
  92 void swap_register_notify (struct notifier_block *nb)
  93 {
  94         blocking_notifier_chain_register(&swap_notifier_list, nb);
  95 }
  96 EXPORT_SYMBOL_GPL(swap_register_notify);
  97
  98 void swap_unregister_notify (struct notifier_block *nb)
  99 {
 100         blocking_notifier_chain_unregister(&swap_notifier_list, nb);
 101 }
 102 EXPORT_SYMBOL_GPL(swap_unregister_notify);
 103 #endif
 104
 105 void notify_user (event_id_t event_id)
 106 {
 107         ec_info.events_counters[event_id] += 1;
 108
 109         if (EVENT_EC_PROBE_RECORD == event_id)
 110         {
 111                 // EC_PROBE_RECORD events happen to often. To reduce overhead user
 112                 // space will be notified only once per each EVENTS_AGGREGATION_USEC
 113                 static uint64_t timestamp_usec = 0;
 114
 115                 uint64_t current_usec;
 116                 uint64_t delta_usec;
 117
 118                 struct timeval tv;
 119
 120                 do_gettimeofday (&tv);
 121                 current_usec = 1000000ULL * (unsigned) tv.tv_sec + (unsigned) tv.tv_usec;
 122
 123                 if (current_usec < timestamp_usec)
 124                 {
 125                         // Note: time from do_gettimeofday() may go backward
 126                         EPRINTF ("current_usec=%llu timestamp_usec=%llu", current_usec, timestamp_usec);
 127                 }
 128                 else
 129                 {
 130                         delta_usec = current_usec - timestamp_usec;
 131                         if (EVENTS_AGGREGATION_USEC > delta_usec)
 132                         {
 133                                 // wait the time left
 134 #if defined(__DEBUG)
 135                                 unsigned UNUSED left_usec = EVENTS_AGGREGATION_USEC - delta_usec;
 136 #endif /* defined(__DEBUG) */
 137                                 return; // supress notification
 138                         }
 139                 }
 140                 timestamp_usec = current_usec;  // remember new time for the future use
 141         } else if (EVENT_EC_START_CONDITION_SEEN == event_id) {
 142                 return;         // supress notification
 143         } else if (EVENT_EC_STOP_CONDITION_SEEN == event_id) {
 144                 return;         // supress notification
 145         }
 146
 147         ++notification_count;
 148         wake_up_interruptible (&notification_waiters_queue);
 149 }
 150
 151 static int device_mmap (struct file *filp UNUSED, struct vm_area_struct *vma)
 152 {
 153         if(!p_buffer) {
 154                 EPRINTF("Null pointer to buffer!");
 155                 return -1;
 156         }
 157         return remap_vmalloc_range (vma, p_buffer, 0);
 158 }
 159
 160 static int device_open(struct inode *inode, struct file *file)
 161 {
 162         /*if (gl_nDeviceOpened)
 163                 return -EBUSY;*/
 164         gl_nDeviceOpened++;
 165         // TODO
 166         try_module_get(THIS_MODULE);
 167         return 0;
 168 }
 169
 170 static int device_release(struct inode *inode, struct file *file)
 171 {
 172         gl_nDeviceOpened--;
 173         module_put(THIS_MODULE);
 174         return 0;
 175 }
 176
 177 static ssize_t device_read(struct file *filp, char *buffer, size_t length, loff_t * offset)
 178 {
 179         EPRINTF("Operation <<read>> not supported!");
 180         return -1;
 181 }
 182
 183 static ssize_t device_write(struct file *filp, const char *buff, size_t len, loff_t * off)
 184 {
 185         EPRINTF("Operation <<write>> not supported!");
 186         return -1;
 187 }
 188
 189 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 36)
 190 static int device_ioctl (struct inode *inode UNUSED, struct file *file UNUSED, unsigned int cmd, unsigned long arg)
 191 #else
 192 static long device_ioctl (struct file *file UNUSED, unsigned int cmd, unsigned long arg)
 193 #endif
 194 {
 195         unsigned long spinlock_flags = 0L;
 196         int result = -1;
 197 //      DPRINTF("Command=%d", cmd);
 198         printk("#1# Command=%d\n", cmd);
 199         printk("#2# Command=%d\n", cmd);
 200
 201         switch (cmd)
 202         {
 203         case EC_IOCTL_SET_EC_MODE:
 204                 {
 205                         ioctl_general_t param;
 206                         unsigned long nIgnoredBytes = 0;
 207                         memset(&param, '0', sizeof(ioctl_general_t));
 208                         nIgnoredBytes = copy_from_user (&param, (void*)arg, sizeof(ioctl_general_t));
 209                         if (nIgnoredBytes > 0) {
 210                                 result = -1;
 211                                 break;
 212                         }
 213                         if(SetECMode(param.m_unsignedLong) == -1) {
 214                                 result = -1;
 215                                 break;
 216                         }
 217                         result = 0;
 218                         DPRINTF("Set EC Mode = %lu", param.m_unsignedLong);
 219                         break;
 220                 }
 221         case EC_IOCTL_GET_EC_MODE:
 222                 {
 223                         ioctl_general_t param;
 224                         unsigned long nIgnoredBytes = 0;
 225                         memset(&param, '0', sizeof(ioctl_general_t));
 226                         param.m_unsignedLong = GetECMode();
 227                         nIgnoredBytes = copy_to_user ((void*)arg, &param, sizeof (ioctl_general_t));
 228                         if (nIgnoredBytes > 0) {
 229                                 result = -1;
 230                                 break;
 231                         }
 232                         result = 0;
 233 //                      DPRINTF("Get EC Mode = %lu", param.m_unsignedLong);  // Frequent call
 234                         break;
 235                 }
 236         case EC_IOCTL_SET_BUFFER_SIZE:
 237                 {
 238                         ioctl_general_t param;
 239                         unsigned long nIgnoredBytes = 0;
 240                         memset(&param, '0', sizeof(ioctl_general_t));
 241                         nIgnoredBytes = copy_from_user (&param, (void*)arg, sizeof(ioctl_general_t));
 242                         if (nIgnoredBytes > 0) {
 243                                 result = -1;
 244                                 break;
 245                         }
 246                         if (SetBufferSize(param.m_unsignedLong) == -1) {
 247                                 result = -1;
 248                                 break;
 249                         }
 250                         result = 0;
 251                         DPRINTF("Set Buffer Size = %lu", param.m_unsignedLong);
 252                         break;
 253                 }
 254         case EC_IOCTL_GET_BUFFER_SIZE:
 255                 {
 256                         ioctl_general_t param;
 257                         unsigned long nIgnoredBytes = 0;
 258                         memset(&param, '0', sizeof(ioctl_general_t));
 259                         param.m_unsignedLong = GetBufferSize();
 260                         nIgnoredBytes = copy_to_user ((void*)arg, &param, sizeof (ioctl_general_t));
 261                         if (nIgnoredBytes > 0) {
 262                                 result = -1;
 263                                 break;
 264                         }
 265                         result = 0;
 266                         DPRINTF("Get Buffer Size = %lu", param.m_unsignedLong);
 267                         break;
 268                 }
 269         case EC_IOCTL_RESET_BUFFER:
 270                 {
 271                         if (ResetBuffer() == -1) {
 272                                 result = -1;
 273                                 break;
 274                         }
 275                         result = 0;
 276                         DPRINTF("Reset Buffer");
 277                         break;
 278                 }
 279         case EC_IOCTL_GET_EC_INFO:
 280                 {
 281                         if (copy_ec_info_to_user_space ((ec_info_t *) arg) != 0) {
 282                                 result = -1;
 283                                 break;
 284                         }
 285                         result = 0;
 286 //                      DPRINTF("Get Buffer Status"); // Frequent call
 287                         break;
 288                 }
 289         case EC_IOCTL_CONSUME_BUFFER:
 290                 {
 291                         static ec_info_t ec_info_copy;
 292                         int nIgnoredBytes = 0;
 293
 294                         nIgnoredBytes = copy_from_user (&ec_info_copy, (ec_info_t *) arg, sizeof (ec_info_t));
 295                         if(nIgnoredBytes > 0)
 296                         {
 297                                 EPRINTF ("copy_from_user(%08X,%08X)=%d", (unsigned) arg, (unsigned) &ec_info_copy, nIgnoredBytes);
 298                                 result = -1;
 299                                 break;
 300                         }
 301
 302                         spin_lock_irqsave (&ec_spinlock, spinlock_flags);
 303
 304                         // Original buffer
 305                         if(ec_info.after_last > ec_info.first) {
 306                                 ec_info.buffer_effect = ec_info.buffer_size;
 307                         }
 308                         if (ec_info.after_last == ec_info.buffer_effect) {
 309                                  ec_info.first = 0;
 310                         } else {
 311                                  ec_info.first = ec_info_copy.after_last;
 312                         }
 313                         ec_info.trace_size = ec_info.trace_size - ec_info_copy.trace_size;
 314
 315                         spin_unlock_irqrestore (&ec_spinlock, spinlock_flags);
 316                         result = 0;
 317 //                      DPRINTF("Consume Buffer"); // Frequent call
 318                         break;
 319                 }
 320         case EC_IOCTL_ADD_PROBE:
 321                 {
 322                         unsigned long addr = arg;
 323                         result = add_probe(addr);
 324
 325                         break;
 326                 }
 327         //@AGv: remove_probe expects probe address instead of name
 328         /*case EC_IOCTL_REMOVE_PROBE:
 329                 {
 330                         char *probe_name = (char *) arg;
 331                         result = remove_probe (probe_name);
 332
 333                         break;
 334                 }*/
 335         case EC_IOCTL_SET_APPDEPS:
 336         {
 337                 size_t size;
 338                 result = copy_from_user(&size, (void *)arg, sizeof(size_t));
 339                 if (result) {
 340                         EPRINTF("Cannot copy deps size!");
 341                         result = -1;
 342                         break;
 343                 }
 344                 DPRINTF("Deps size has been copied (%d)", size);
 345
 346                 if (size == 0) {
 347                         DPRINTF("Deps are size of 0");
 348                         break;
 349                 }
 350
 351                 deps = vmalloc(size);
 352                 if (deps == NULL) {
 353                         EPRINTF("Cannot alloc mem for deps!");
 354                         result = -1;
 355                         break;
 356                 }
 357                 DPRINTF("Mem for deps has been allocated");
 358
 359                 result = copy_from_user(deps, (void *)arg, size);
 360                 if (result) {
 361                         EPRINTF("Cannot copy deps!");
 362                         result = -1;
 363                         break;
 364                 }
 365                 DPRINTF("Deps has been copied successfully");
 366
 367                 break;
 368         }
 369         case EC_IOCTL_SET_PID:
 370         {
 371                 unsigned int _pid;
 372
 373                 result = copy_from_user(&_pid, (void *)arg, sizeof(unsigned int));
 374                 if (result) {
 375                         EPRINTF("Cannot copy pid!");
 376                         result = -1;
 377                         break;
 378                 }
 379
 380                 inst_pid = _pid;
 381
 382                 DPRINTF("EC_IOCTL_SET_PID pid:%d", inst_pid);
 383
 384                 break;
 385         }
 386         case EC_IOCTL_SET_PROFILEBUNDLE:
 387         {
 388                 size_t size;
 389
 390                 result = copy_from_user(&size, (void *)arg, sizeof(size_t));
 391                 if (result) {
 392                         EPRINTF("Cannot copy bundle size!");
 393                         result = -1;
 394                         break;
 395                 }
 396                 DPRINTF("Bundle size has been copied");
 397
 398                 bundle = vmalloc(size);
 399                 if (bundle == NULL) {
 400                         EPRINTF("Cannot alloc mem for bundle!");
 401                         result = -1;
 402                         break;
 403                 }
 404                 DPRINTF("Mem for bundle has been alloced");
 405
 406                 result = copy_from_user(bundle, (void *)arg, size);
 407                 if (result) {
 408                         EPRINTF("Cannot copy bundle!");
 409                         result = -1;
 410                         break;
 411                 }
 412                 DPRINTF("Bundle has been copied successfully");
 413
 414                 if (link_bundle() == -1) {
 415                         EPRINTF("Cannot link profile bundle!");
 416                         result = -1;
 417                         break;
 418                 }
 419
 420                 break;
 421         }
 422         case EC_IOCTL_RESET_PROBES:
 423                 {
 424                         result = reset_probes();
 425
 426                         break;
 427                 }
 428         case EC_IOCTL_UPDATE_CONDS:
 429                 {
 430                         int args_cnt, i;
 431                         struct cond *c, *c_tmp, *p_cond;
 432                         unsigned char *p_data;
 433                         int err;
 434                         result = 0;
 435                         err = copy_from_user(&args_cnt, (void *)arg, sizeof(int));
 436                         if (err) {
 437                                 result = -1;
 438                                 break;
 439                         }
 440                         /* first, delete all the conds */
 441                         list_for_each_entry_safe(c, c_tmp, &cond_list.list, list) {
 442                                 list_del(&c->list);
 443                                 kfree(c);
 444                         }
 445                         /* second, add new conds */
 446                         p_data = (unsigned char *)(arg + sizeof(int));
 447                         for (i = 0; i < args_cnt; i++) {
 448                                 p_cond = kmalloc(sizeof(struct cond), GFP_KERNEL);
 449                                 if (!p_cond) {
 450                                         DPRINTF("Cannot alloc cond!");
 451                                         result = -1;
 452                                         break;
 453                                 }
 454                                 err = copy_from_user(&p_cond->tmpl, p_data, sizeof(struct event_tmpl));
 455                                 if (err) {
 456                                         DPRINTF("Cannot copy cond from user!");
 457                                         result = -1;
 458                                         break;
 459                                 }
 460                                 p_cond->applied = 0;
 461                                 list_add(&(p_cond->list), &(cond_list.list));
 462                                 p_data += sizeof(struct event_tmpl);
 463                         }
 464                         break;
 465                 }
 466         case EC_IOCTL_ATTACH:
 467                 {
 468                         unsigned long dbi_flags;
 469                         struct dbi_modules_handlers *local_mh;
 470                         struct dbi_modules_handlers_info *local_mhi;
 471                         int j;
 472                         dbi_module_callback dmc_start;
 473
 474                         // call "start"-callback for all modules according module priority
 475                         local_mh = get_dbi_modules_handlers();
 476                         spin_lock_irqsave(&local_mh->lock, dbi_flags);
 477                         for (j = 0; j <= MAX_PRIORITY; j++) {
 478                                 list_for_each_entry_rcu(local_mhi, &local_mh->modules_handlers, dbi_list_head) {
 479                                         if (local_mhi->dbi_module_priority_start == j) {
 480                                                 if (local_mhi->dbi_module_callback_start != NULL) {
 481                                                         printk("Started module callback (start) %s\n", local_mhi->dbi_module->name);
 482                                                         dmc_start = (dbi_module_callback )local_mhi->dbi_module_callback_start;
 483                                                         dmc_start();
 484                                                 }
 485                                         }
 486                                 }
 487                         }
 488                         spin_unlock_irqrestore(&local_mh->lock, dbi_flags);
 489
 490                         result = ec_user_attach ();
 491 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 17)
 492                         DPRINTF("EC_IOCTL_ATTACH calling notification chain");
 493                         blocking_notifier_call_chain(&swap_notifier_list, EC_IOCTL_ATTACH, (void*)NULL);
 494 #endif
 495                         DPRINTF("Attach Probes");
 496                         break;
 497                 }
 498         case EC_IOCTL_ACTIVATE:
 499                 result = ec_user_activate ();
 500                 DPRINTF("Activate Probes");
 501                 break;
 502         case EC_IOCTL_STOP_AND_DETACH:
 503         {
 504                 unsigned long nIgnoredBytes = 0;
 505                 unsigned long dbi_flags;
 506                 struct dbi_modules_handlers *local_mh;
 507                 struct dbi_modules_handlers_info *local_mhi;
 508                 unsigned int local_module_refcount = 0;
 509                 int j;
 510                 dbi_module_callback dmc_stop;
 511
 512 #ifdef OVERHEAD_DEBUG
 513                 printk("\nswap_sum_time = %ld in kprobe_handler()\n", swap_sum_time);
 514                 printk("swap_sum_hit = %ld in kprobe_handler()\n", swap_sum_hit);
 515                 swap_sum_time = 0;
 516                 swap_sum_hit = 0;
 517 #endif
 518
 519                 printk("\n### imi_sum_time = %ld in install_mapped_ips()\n", imi_sum_time);
 520                 printk("### imi_sum_hit = %ld in install_mapped_ips()\n", imi_sum_hit);
 521
 522                 if (imi_sum_hit != 0) {
 523                         printk("### time = %ld in install_mapped_ips()\n", imi_sum_time/imi_sum_hit);
 524                 }
 525
 526                 imi_sum_time = 0;
 527                 imi_sum_hit = 0;
 528
 529                 local_mh = get_dbi_modules_handlers();
 530                 if(ec_user_stop() != 0) {
 531                         result = -1;
 532                         goto sad_cleanup;
 533                 }
 534                 nIgnoredBytes = copy_ec_info_to_user_space ((ec_info_t*)arg);
 535                 if(nIgnoredBytes > 0) {
 536                         result = -1;
 537                         goto sad_cleanup;
 538                 }
 539
 540                 sspt_procs_free_all();
 541
 542                 vfree(bundle);
 543                 result = 0;
 544                 DPRINTF("Stop and Detach Probes");
 545 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 17)
 546                 DPRINTF("EC_IOCTL_STOP_AND_DETACH calling notification chain");
 547                 blocking_notifier_call_chain(&swap_notifier_list, EC_IOCTL_STOP_AND_DETACH, (void*)&gl_nNotifyTgid);
 548 #endif
 549                 // call "stop"-callback for all modules according module priority
 550                 spin_lock_irqsave(&local_mh->lock, dbi_flags);
 551                 for (j = 0; j <= MAX_PRIORITY; j++) {
 552                         list_for_each_entry_rcu(local_mhi, &local_mh->modules_handlers, dbi_list_head) {
 553                                 if (local_mhi->dbi_module_priority_stop == j) {
 554                                         if (local_mhi->dbi_module_callback_stop != NULL) {
 555                                                 printk("Started module callback (stop) %s\n", local_mhi->dbi_module->name);
 556                                                 dmc_stop = (dbi_module_callback )local_mhi->dbi_module_callback_stop;
 557                                                 dmc_stop();
 558                                         }
 559                                 }
 560                         }
 561                 }
 562                 spin_unlock_irqrestore(&local_mh->lock, dbi_flags);
 563 sad_cleanup:
 564                 spin_lock_irqsave(&local_mh->lock, dbi_flags);
 565                 list_for_each_entry_rcu(local_mhi, &local_mh->modules_handlers, dbi_list_head) {
 566                         local_module_refcount = module_refcount(local_mhi->dbi_module);
 567                         if (local_module_refcount == 1) {
 568                                 module_put(local_mhi->dbi_module);
 569                         }
 570                         else if (local_module_refcount > 1) {
 571                                 printk("local_module_refcount too much - force set refcount to zero\n");
 572                                 while (local_module_refcount--)
 573                                         module_put(local_mhi->dbi_module);
 574                         }
 575                 }
 576                 spin_unlock_irqrestore(&local_mh->lock, dbi_flags);
 577                 break;
 578         }
 579         case EC_IOCTL_WAIT_NOTIFICATION:
 580                 {
 581                         static ec_info_t ec_info_copy;
 582
 583                         ioctl_wait_notification_t ioctl_args;
 584
 585                         result = copy_from_user (&ioctl_args, (void *) arg, sizeof (ioctl_args));
 586                         if (result)
 587                         {
 588                                 result = -1;
 589                                 break;
 590                         }
 591
 592                         result = wait_event_interruptible (notification_waiters_queue, ioctl_args.notification_count != notification_count);
 593                         if (result)
 594                         {
 595                                 result = -EINTR;        // woken by signal (ERESTARTSYS 512)
 596                                 break;
 597                         }
 598
 599                         ioctl_args.notification_count = notification_count;
 600
 601                         result = copy_to_user ((void *) arg, &ioctl_args, sizeof (ioctl_args));
 602                         if (result)
 603                         {
 604                                 result = -1;
 605                                 break;
 606                         }
 607
 608                         // FIXME: synchronization is necessary here (ec_info must be locked).
 609                         // ENTER_CRITICAL_SECTION
 610                         memcpy (&ec_info_copy, &ec_info, sizeof (ec_info_copy));
 611                         // LEAVE_CRITICAL_SECTION
 612
 613                         result = copy_to_user ((void *) ioctl_args.p_ec_info, &ec_info_copy, sizeof (ec_info_t));
 614                         if (result)
 615                         {
 616                                 EPRINTF ("copy_to_user(%08X,%08X)=%d", (unsigned) ioctl_args.p_ec_info, (unsigned) &ec_info_copy, result);
 617                                 result = -1;
 618                                 break;
 619                         }
 620                         DPRINTF("Wake up");
 621                         break;
 622                 }
 623         case EC_IOCTL_US_EVENT:
 624                 {
 625                         ioctl_us_event_t ioctl_args;
 626                         result = copy_from_user (&ioctl_args, (void *) arg, sizeof (ioctl_args));
 627                         if (result)
 628                         {
 629                                 result = -1;
 630                                 EPRINTF ("copy_from_user() failure");
 631                         }
 632                         else
 633                         {
 634                                 if(ioctl_args.len == 0){
 635                                         result = -EINVAL;
 636                                         EPRINTF ("invalid event length!");
 637                                 }
 638                                 else {
 639                                         char *buf = kmalloc(ioctl_args.len, GFP_KERNEL);
 640                                         if(!buf){
 641                                                 result = -ENOMEM;
 642                                                 EPRINTF ("failed to alloc mem for event!");
 643                                         }
 644                                         else {
 645                                                 result = copy_from_user (buf, (void *) ioctl_args.data, ioctl_args.len);
 646                                                 if (result){
 647                                                         result = -1;
 648                                                         EPRINTF ("failed to copy event from user space!");
 649                                                 }
 650                                                 else
 651                                                         result = put_us_event(buf, ioctl_args.len);
 652                                                 kfree(buf);
 653                                         }
 654                                 }
 655                         }
 656 //                      DPRINTF("User Space Event"); // Frequent call
 657                         break;
 658                 }
 659
 660         case EC_IOCTL_SET_EVENT_MASK:
 661                 {
 662                         int mask;
 663                         result = copy_from_user (&mask, (void *) arg, sizeof (mask));
 664                         if (result)
 665                         {
 666                                 result = -EFAULT;
 667                                 break;
 668                         }
 669
 670                         result = set_event_mask (mask);
 671                         if (result)
 672                         {
 673                                 break;
 674                         }
 675                         DPRINTF("Set Event Mask = %d", mask);
 676                         break;
 677                 }
 678
 679         case EC_IOCTL_GET_EVENT_MASK:
 680                 {
 681                         int mask = 0;
 682                         result = get_event_mask(&mask);
 683                         if (result)
 684                         {
 685                                 result = -EFAULT;
 686                         }
 687                         result = copy_to_user ((void *) arg, &mask, sizeof (mask));
 688                         if (result)
 689                         {
 690                                 result = -EFAULT;
 691                         }
 692                         DPRINTF("Get Event Mask = %d", mask);
 693                         break;
 694                 }
 695
 696         case EC_IOCTL_SET_PREDEF_UPROBES:
 697                 {
 698                         result = -1;
 699                         break;
 700
 701                         ioctl_predef_uprobes_info_t data;
 702                         result = copy_from_user (&data, (void *) arg, sizeof (data));
 703                         if (result)
 704                         {
 705                                 result = -EFAULT;
 706                                 break;
 707                         }
 708
 709                         result = set_predef_uprobes (&data);
 710                         if (result)
 711                         {
 712                                 break;
 713                         }
 714                         DPRINTF("Set Predefined User Space Probes");
 715                         break;
 716                 }
 717
 718         case EC_IOCTL_GET_PREDEF_UPROBES:
 719                 {
 720 //                      result = 0;
 721 //                      break;
 722
 723                         result = get_predef_uprobes((ioctl_predef_uprobes_info_t *)arg);
 724                         if (result)
 725                         {
 726                                 result = -EFAULT;
 727                         }
 728                         DPRINTF("Get Predefined User Space Probes");
 729                         break;
 730                 }
 731
 732         case EC_IOCTL_GET_PREDEF_UPROBES_SIZE:
 733                 {
 734                         int size = 0;
 735                         result = get_predef_uprobes_size(&size);
 736                         if (result)
 737                         {
 738                                 result = -EFAULT;
 739                         }
 740                         result = copy_to_user ((void *) arg, &size, sizeof (size));
 741                         if (result)
 742                         {
 743                                 result = -EFAULT;
 744                         }
 745                         DPRINTF("Get Size of Predefined User Space Probes");
 746                         break;
 747                 }
 748
 749         default:
 750                 EPRINTF ("Unknown driver command = %u", cmd);
 751                 result = -EINVAL;
 752                 break;
 753         }
 754
 755         return result;
 756 }