kprobe/kprobes.c

   1 // src_kprobes.c
   2
   3
   4 #include <linux/version.h>
   5 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)
   6 #include <linux/config.h>
   7 #endif
   8
   9 #include <asm/types.h>
  10
  11 #include <linux/hash.h>
  12 #include <linux/init.h>
  13 #include <linux/slab.h>
  14 #include <linux/module.h>
  15 #include <linux/moduleloader.h>
  16 #include <linux/kallsyms.h>
  17 //#include <linux/freezer.h>
  18 #include <linux/seq_file.h>
  19 #ifdef CONFIG_DEBUG_FS
  20 #include <linux/debugfs.h>
  21 #endif
  22 #include <asm-generic/sections.h>
  23 #include <asm/cacheflush.h>
  24 #include <asm/errno.h>
  25 #include <linux/spinlock.h>
  26 #include <linux/version.h>
  27 #include <linux/highmem.h>      // kmap_atomic, kunmap_atomic, copy_from_user_page, copy_to_user_page
  28 #include <linux/pagemap.h>      // page_cache_release
  29 #include <linux/vmalloc.h>      // vmalloc, vfree
  30 #if defined(CONFIG_X86)
  31 #include <linux/kdebug.h>       // register_die_notifier, unregister_die_notifier
  32 #endif
  33 #include <linux/hugetlb.h>      // follow_hugetlb_page, is_vm_hugetlb_page
  34
  35 #include "kprobes.h"
  36
  37 //#define arch_remove_kprobe(p) do { } while (0)
  38
  39 #ifdef _DEBUG
  40 extern int nCount;
  41 #endif
  42
  43 /*
  44 static spinlock_t die_notifier_lock = SPIN_LOCK_UNLOCKED;
  45
  46 int src_register_die_notifier(struct notifier_block *nb)
  47 {
  48         int err = 0;
  49         unsigned long flags;
  50
  51         spin_lock_irqsave(&die_notifier_lock, flags);
  52 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,17)
  53         err = atomic_notifier_chain_register(&panic_notifier_list, nb);
  54 #else
  55         err = notifier_chain_register(&panic_notifier_list, nb);
  56 #endif
  57         spin_unlock_irqrestore(&die_notifier_lock, flags);
  58
  59         return err;
  60 }
  61 */
  62 /**
  63  * hlist_replace_rcu - replace old entry by new one
  64  * @old : the element to be replaced
  65  * @new : the new element to insert
  66  *
  67  * The @old entry will be replaced with the @new entry atomically.
  68  */
  69 static inline void
  70 src_hlist_replace_rcu (struct hlist_node *old, struct hlist_node *new)
  71 {
  72         struct hlist_node *next = old->next;
  73
  74         new->next = next;
  75         new->pprev = old->pprev;
  76         smp_wmb ();
  77         if (next)
  78                 new->next->pprev = &new->next;
  79         if (new->pprev)
  80                 *new->pprev = new;
  81         old->pprev = LIST_POISON2;
  82 }
  83
  84 #define KPROBE_HASH_BITS 6
  85 #define KPROBE_TABLE_SIZE (1 << KPROBE_HASH_BITS)
  86
  87
  88 /*
  89  * Some oddball architectures like 64bit powerpc have function descriptors
  90  * so this must be overridable.
  91  */
  92 #ifndef kprobe_lookup_name
  93 #define kprobe_lookup_name(name, addr) \
  94         addr = ((kprobe_opcode_t *)(kallsyms_lookup_name(name)))
  95 #endif
  96
  97 static struct hlist_head kprobe_table[KPROBE_TABLE_SIZE];
  98 static struct hlist_head kretprobe_inst_table[KPROBE_TABLE_SIZE];
  99 static struct hlist_head uprobe_insn_slot_table[KPROBE_TABLE_SIZE];
 100 static atomic_t kprobe_count;
 101
 102 //DEFINE_MUTEX(kprobe_mutex);           /* Protects kprobe_table */
 103 DEFINE_SPINLOCK (kretprobe_lock);       /* Protects kretprobe_inst_table */
 104 static DEFINE_PER_CPU (struct kprobe *, kprobe_instance) = NULL;
 105 unsigned long handled_exceptions;
 106
 107 /* We have preemption disabled.. so it is safe to use __ versions */
 108 static inline void
 109 set_kprobe_instance (struct kprobe *kp)
 110 {
 111         __get_cpu_var (kprobe_instance) = kp;
 112 }
 113
 114 static inline void
 115 reset_kprobe_instance (void)
 116 {
 117         __get_cpu_var (kprobe_instance) = NULL;
 118 }
 119
 120 /*
 121  * This routine is called either:
 122  *      - under the kprobe_mutex - during kprobe_[un]register()
 123  *                              OR
 124  *      - with preemption disabled - from arch/xxx/kernel/kprobes.c
 125  */
 126 struct kprobe __kprobes *
 127 get_kprobe (void *addr, int tgid, struct task_struct *ctask)
 128 {
 129         struct hlist_head *head;
 130         struct hlist_node *node;
 131         struct kprobe *p, *retVal = NULL;
 132         int ret = 0, uprobe_found;
 133         struct page *page = 0, *tpage = 0;
 134         struct vm_area_struct *vma = 0;
 135         struct task_struct *task = 0;
 136         void *paddr = 0;
 137
 138
 139         if (ctask && ctask->active_mm)
 140         {
 141                 ret = get_user_pages_atomic (ctask, ctask->active_mm, (unsigned long) addr, 1, 0, 0, &tpage, NULL);
 142                 if (ret <= 0)
 143                         DBPRINTF ("get_user_pages for task %d at %p failed!", current->pid, addr);
 144                 else
 145                 {
 146                         paddr = page_address (tpage);
 147                         page_cache_release (tpage);
 148                 }
 149         }
 150         //else
 151         //      DBPRINTF("task %d has no mm!", ctask->pid);
 152
 153         //TODO: test - two processes invokes instrumented function
 154         head = &kprobe_table[hash_ptr (addr, KPROBE_HASH_BITS)];
 155         hlist_for_each_entry_rcu (p, node, head, hlist)
 156         {
 157                 //if looking for kernel probe and this is kernel probe with the same addr OR
 158                 //if looking for the user space probe and this is user space probe probe with the same addr and pid
 159                 DBPRINTF ("get_kprobe[%d]: check probe at %p/%p, task %d/%d", nCount, addr, p->addr, tgid, p->tgid);
 160                 if (p->addr == addr)
 161                 {
 162                         uprobe_found = 0;
 163                         if (tgid == p->tgid)
 164                                 uprobe_found = 1;
 165                         if (!tgid || uprobe_found)
 166                         {
 167                                 retVal = p;
 168                                 if (tgid)
 169                                         DBPRINTF ("get_kprobe[%d]: found user space probe at %p for task %d", nCount, p->addr, p->tgid);
 170                                 else
 171                                         DBPRINTF ("get_kprobe[%d]: found kernel probe at %p", nCount, p->addr);
 172                                 break;
 173                         }
 174                 }
 175                 else if (tgid != p->tgid)
 176                 {
 177                         // if looking for the user space probe and this is user space probe
 178                         // with another addr and pid but with the same offset whithin the page
 179                         // it could be that it is the same probe (with address from other user space)
 180                         // we should handle it as usual probe but without notification to user
 181                         if (paddr && tgid && (((unsigned long) addr & ~PAGE_MASK) == ((unsigned long) p->addr & ~PAGE_MASK))
 182                             && p->tgid)
 183                         {
 184                                 DBPRINTF ("get_kprobe[%d]: found user space probe at %p in task %d. possibly for addr %p in task %d", nCount, p->addr, p->tgid, addr, tgid);
 185                                 // this probe has the same offset in the page
 186                                 // look in the probes for the other pids
 187                                 // get page for user space probe addr
 188                                 rcu_read_lock ();
 189 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 26)
 190                                 task = find_task_by_pid (p->tgid);
 191 #else //lif LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 31)
 192                                 task = pid_task(find_pid_ns(p->tgid, &init_pid_ns), PIDTYPE_PID);
 193 #endif
 194                                 if (task)
 195                                         get_task_struct (task);
 196                                 rcu_read_unlock ();
 197                                 if (!task)
 198                                 {
 199                                         DBPRINTF ("task for pid %d not found! Dead probe?", p->tgid);
 200                                         continue;
 201                                 }
 202                                 if (task->active_mm)
 203                                 {
 204                                         if (page_present (task->active_mm, (unsigned long) p->addr))
 205                                         {
 206                                                 ret = get_user_pages_atomic (task, task->active_mm, (unsigned long) p->addr, 1, 0, 0, &page, &vma);
 207                                                 if (ret <= 0)
 208                                                         DBPRINTF ("get_user_pages for task %d at %p failed!", p->tgid, p->addr);
 209                                         }
 210                                         else
 211                                                 ret = -1;
 212                                 }
 213                                 else
 214                                 {
 215                                         DBPRINTF ("task %d has no mm!", task->pid);
 216                                         ret = -1;
 217                                 }
 218                                 put_task_struct (task);
 219                                 if (ret <= 0)
 220                                         continue;
 221                                 if (paddr == page_address (page))
 222                                 {
 223                                         retVal = p;     // we found the probe in other process address space
 224                                         DBPRINTF ("get_kprobe[%d]: found user space probe at %p in task %d for addr %p in task %d", nCount, p->addr, p->tgid, addr, tgid);
 225                                         panic ("user space probe from another process");
 226                                 }
 227                                 page_cache_release (page);
 228                                 if (retVal)
 229                                         break;
 230                         }
 231                 }
 232         }
 233
 234         DBPRINTF ("get_kprobe[%d]: probe %p", nCount, retVal);
 235         return retVal;
 236 }
 237
 238 struct kprobe __kprobes *
 239 get_kprobe_by_insn_slot (void *addr, int tgid, struct task_struct *ctask)
 240 {
 241         struct hlist_head *head;
 242         struct hlist_node *node;
 243         struct kprobe *p, *retVal = NULL;
 244         int uprobe_found;
 245
 246         //TODO: test - two processes invokes instrumented function
 247         head = &uprobe_insn_slot_table[hash_ptr (addr, KPROBE_HASH_BITS)];
 248         hlist_for_each_entry_rcu (p, node, head, is_hlist)
 249         {
 250                 //if looking for kernel probe and this is kernel probe with the same addr OR
 251                 //if looking for the user space probe and this is user space probe probe with the same addr and pid
 252                 DBPRINTF ("get_kprobe[%d]: check probe at %p/%p, task %d/%d", nCount, addr, p->ainsn.insn, tgid, p->tgid);
 253                 if (p->ainsn.insn == addr)
 254                 {
 255                         uprobe_found = 0;
 256                         if (tgid == p->tgid)
 257                                 uprobe_found = 1;
 258                         if (!tgid || uprobe_found)
 259                         {
 260                                 retVal = p;
 261                                 if (tgid)
 262                                         DBPRINTF ("get_kprobe[%d]: found user space probe at %p for task %d", nCount, p->addr, p->tgid);
 263                                 else
 264                                         DBPRINTF ("get_kprobe[%d]: found kernel probe at %p", nCount, p->addr);
 265                                 break;
 266                         }
 267                 }
 268         }
 269
 270         DBPRINTF ("get_kprobe[%d]: probe %p", nCount, retVal);
 271         return retVal;
 272 }
 273
 274 /*
 275  * Aggregate handlers for multiple kprobes support - these handlers
 276  * take care of invoking the individual kprobe handlers on p->list
 277  */
 278 static int __kprobes
 279 aggr_pre_handler (struct kprobe *p, struct pt_regs *regs        /*,
 280                                                                    struct vm_area_struct **vma,
 281                                                                    struct page **page, unsigned long **kaddr */ )
 282 {
 283         struct kprobe *kp;
 284         int ret;
 285
 286         list_for_each_entry_rcu (kp, &p->list, list)
 287         {
 288                 if (kp->pre_handler)
 289                 {
 290                         set_kprobe_instance (kp);
 291                         ret = kp->pre_handler (kp, regs);
 292                         if (ret)
 293                                 return ret;
 294                 }
 295                 reset_kprobe_instance ();
 296         }
 297         return 0;
 298 }
 299
 300 static void __kprobes
 301 aggr_post_handler (struct kprobe *p, struct pt_regs *regs, unsigned long flags)
 302 {
 303         struct kprobe *kp;
 304
 305         list_for_each_entry_rcu (kp, &p->list, list)
 306         {
 307                 if (kp->post_handler)
 308                 {
 309                         set_kprobe_instance (kp);
 310                         kp->post_handler (kp, regs, flags);
 311                         reset_kprobe_instance ();
 312                 }
 313         }
 314         return;
 315 }
 316
 317 #if 1
 318 static int __kprobes
 319 aggr_fault_handler (struct kprobe *p, struct pt_regs *regs, int trapnr)
 320 {
 321         struct kprobe *cur = __get_cpu_var (kprobe_instance);
 322
 323         /*
 324          * if we faulted "during" the execution of a user specified
 325          * probe handler, invoke just that probe's fault handler
 326          */
 327         if (cur && cur->fault_handler)
 328         {
 329                 if (cur->fault_handler (cur, regs, trapnr))
 330                         return 1;
 331         }
 332         return 0;
 333 }
 334 #endif
 335
 336 static int __kprobes
 337 aggr_break_handler (struct kprobe *p, struct pt_regs *regs      /*,
 338                                                                    struct vm_area_struct **vma,
 339                                                                    struct page **page, unsigned long **kaddr */ )
 340 {
 341         struct kprobe *cur = __get_cpu_var (kprobe_instance);
 342         int ret = 0;
 343         DBPRINTF ("cur = 0x%p\n", cur);
 344         if (cur)
 345                 DBPRINTF ("cur = 0x%p cur->break_handler = 0x%p\n", cur, cur->break_handler);
 346
 347         if (cur && cur->break_handler)
 348         {
 349                 if (cur->break_handler (cur, regs /*, vma, page, kaddr */ ))
 350                         ret = 1;
 351         }
 352         reset_kprobe_instance ();
 353         return ret;
 354 }
 355
 356 /* Walks the list and increments nmissed count for multiprobe case */
 357 void __kprobes
 358 kprobes_inc_nmissed_count (struct kprobe *p)
 359 {
 360         struct kprobe *kp;
 361         if (p->pre_handler != aggr_pre_handler)
 362         {
 363                 p->nmissed++;
 364         }
 365         else
 366         {
 367                 list_for_each_entry_rcu (kp, &p->list, list) kp->nmissed++;
 368         }
 369         return;
 370 }
 371
 372 /* Called with kretprobe_lock held */
 373 struct kretprobe_instance __kprobes *
 374 get_free_rp_inst (struct kretprobe *rp)
 375 {
 376         struct hlist_node *node;
 377         struct kretprobe_instance *ri;
 378         hlist_for_each_entry (ri, node, &rp->free_instances, uflist)
 379                 return ri;
 380         return NULL;
 381 }
 382
 383 /* Called with kretprobe_lock held */
 384 static struct kretprobe_instance __kprobes *
 385 get_used_rp_inst (struct kretprobe *rp)
 386 {
 387         struct hlist_node *node;
 388         struct kretprobe_instance *ri;
 389         hlist_for_each_entry (ri, node, &rp->used_instances, uflist) return ri;
 390         return NULL;
 391 }
 392
 393 /* Called with kretprobe_lock held */
 394 void __kprobes
 395 add_rp_inst (struct kretprobe_instance *ri)
 396 {
 397         /*
 398          * Remove rp inst off the free list -
 399          * Add it back when probed function returns
 400          */
 401         hlist_del (&ri->uflist);
 402
 403         /* Add rp inst onto table */
 404         INIT_HLIST_NODE (&ri->hlist);
 405         hlist_add_head (&ri->hlist, &kretprobe_inst_table[hash_ptr (ri->task, KPROBE_HASH_BITS)]);
 406
 407         /* Also add this rp inst to the used list. */
 408         INIT_HLIST_NODE (&ri->uflist);
 409         hlist_add_head (&ri->uflist, &ri->rp->used_instances);
 410 }
 411
 412 /* Called with kretprobe_lock held */
 413 void __kprobes
 414 recycle_rp_inst (struct kretprobe_instance *ri, struct hlist_head *head)
 415 {
 416         /* remove rp inst off the rprobe_inst_table */
 417         hlist_del (&ri->hlist);
 418         if (ri->rp)
 419         {
 420                 /* remove rp inst off the used list */
 421                 hlist_del (&ri->uflist);
 422                 /* put rp inst back onto the free list */
 423                 INIT_HLIST_NODE (&ri->uflist);
 424                 hlist_add_head (&ri->uflist, &ri->rp->free_instances);
 425         }
 426         else
 427                 /* Unregistering */
 428                 hlist_add_head (&ri->hlist, head);
 429 }
 430
 431 struct hlist_head __kprobes *
 432 kretprobe_inst_table_head (struct task_struct *tsk)
 433 {
 434         return &kretprobe_inst_table[hash_ptr (tsk, KPROBE_HASH_BITS)];
 435 }
 436
 437 /*
 438  * This function is called from finish_task_switch when task tk becomes dead,
 439  * so that we can recycle any function-return probe instances associated
 440  * with this task. These left over instances represent probed functions
 441  * that have been called but will never return.
 442  */
 443 /*void __kprobes kprobe_flush_task(struct task_struct *tk)
 444 {
 445         struct kretprobe_instance *ri;
 446         struct hlist_head *head, empty_rp;
 447         struct hlist_node *node, *tmp;
 448         unsigned long flags = 0;
 449
 450         INIT_HLIST_HEAD(&empty_rp);
 451         spin_lock_irqsave(&kretprobe_lock, flags);
 452         head = kretprobe_inst_table_head(tk);
 453         hlist_for_each_entry_safe(ri, node, tmp, head, hlist) {
 454                 if (ri->task == tk)
 455                         recycle_rp_inst(ri, &empty_rp);
 456         }
 457         spin_unlock_irqrestore(&kretprobe_lock, flags);
 458
 459         hlist_for_each_entry_safe(ri, node, tmp, &empty_rp, hlist) {
 460                 hlist_del(&ri->hlist);
 461                 kfree(ri);
 462         }
 463 }*/
 464
 465 static inline void
 466 free_rp_inst (struct kretprobe *rp)
 467 {
 468         struct kretprobe_instance *ri;
 469         while ((ri = get_free_rp_inst (rp)) != NULL)
 470         {
 471                 hlist_del (&ri->uflist);
 472                 kfree (ri);
 473         }
 474 }
 475
 476 /*
 477  * Keep all fields in the kprobe consistent
 478  */
 479 static inline void
 480 copy_kprobe (struct kprobe *old_p, struct kprobe *p)
 481 {
 482         memcpy (&p->opcode, &old_p->opcode, sizeof (kprobe_opcode_t));
 483         memcpy (&p->ainsn, &old_p->ainsn, sizeof (struct arch_specific_insn));
 484         p->tgid = old_p->tgid;
 485         p->ss_addr = old_p->ss_addr;
 486         //p->spid = old_p->spid;
 487 }
 488
 489 /*
 490 * Add the new probe to old_p->list. Fail if this is the
 491 * second jprobe at the address - two jprobes can't coexist
 492 */
 493 static int __kprobes
 494 add_new_kprobe (struct kprobe *old_p, struct kprobe *p)
 495 {
 496         if (p->break_handler)
 497         {
 498                 if (old_p->break_handler)
 499                         return -EEXIST;
 500                 list_add_tail_rcu (&p->list, &old_p->list);
 501                 old_p->break_handler = aggr_break_handler;
 502         }
 503         else
 504                 list_add_rcu (&p->list, &old_p->list);
 505         if (p->post_handler && !old_p->post_handler)
 506                 old_p->post_handler = aggr_post_handler;
 507         return 0;
 508 }
 509
 510 /*
 511  * Fill in the required fields of the "manager kprobe". Replace the
 512  * earlier kprobe in the hlist with the manager kprobe
 513  */
 514 static inline void
 515 add_aggr_kprobe (struct kprobe *ap, struct kprobe *p)
 516 {
 517         copy_kprobe (p, ap);
 518         flush_insn_slot (ap);
 519         ap->addr = p->addr;
 520         ap->pre_handler = aggr_pre_handler;
 521         ap->fault_handler = aggr_fault_handler;
 522         if (p->post_handler)
 523                 ap->post_handler = aggr_post_handler;
 524         if (p->break_handler)
 525                 ap->break_handler = aggr_break_handler;
 526
 527         INIT_LIST_HEAD (&ap->list);
 528         list_add_rcu (&p->list, &ap->list);
 529
 530         src_hlist_replace_rcu (&p->hlist, &ap->hlist);
 531 }
 532
 533 /*
 534  * This is the second or subsequent kprobe at the address - handle
 535  * the intricacies
 536  */
 537 static int __kprobes
 538 register_aggr_kprobe (struct kprobe *old_p, struct kprobe *p)
 539 {
 540         int ret = 0;
 541         struct kprobe *ap;
 542         DBPRINTF ("start\n");
 543
 544         DBPRINTF ("p = %p old_p = %p \n", p, old_p);
 545         if (old_p->pre_handler == aggr_pre_handler)
 546         {
 547                 DBPRINTF ("aggr_pre_handler \n");
 548
 549                 copy_kprobe (old_p, p);
 550                 ret = add_new_kprobe (old_p, p);
 551         }
 552         else
 553         {
 554                 DBPRINTF ("kzalloc\n");
 555
 556 #ifdef kzalloc
 557                 ap = kzalloc (sizeof (struct kprobe), GFP_KERNEL);
 558 #else
 559                 ap = kmalloc (sizeof (struct kprobe), GFP_KERNEL);
 560                 if (ap)
 561                         memset (ap, 0, sizeof (struct kprobe));
 562 #endif
 563                 if (!ap)
 564                         return -ENOMEM;
 565                 add_aggr_kprobe (ap, old_p);
 566                 copy_kprobe (ap, p);
 567                 DBPRINTF ("ap = %p p = %p old_p = %p \n", ap, p, old_p);
 568                 ret = add_new_kprobe (ap, p);
 569         }
 570         return ret;
 571 }
 572
 573 static int __kprobes
 574 __register_kprobe (struct kprobe *p, unsigned long called_from, int atomic)
 575 {
 576         struct kprobe *old_p;
 577 //      struct module *probed_mod;
 578         int ret = 0;
 579         /*
 580          * If we have a symbol_name argument look it up,
 581          * and add it to the address.  That way the addr
 582          * field can either be global or relative to a symbol.
 583          */
 584         if (p->symbol_name)
 585         {
 586                 if (p->addr)
 587                         return -EINVAL;
 588                 kprobe_lookup_name (p->symbol_name, p->addr);
 589         }
 590
 591         if (!p->addr)
 592                 return -EINVAL;
 593         DBPRINTF ("p->addr = 0x%p\n", p->addr);
 594         p->addr = (kprobe_opcode_t *) (((char *) p->addr) + p->offset);
 595         DBPRINTF ("p->addr = 0x%p p = 0x%p\n", p->addr, p);
 596
 597 /*      if ((!kernel_text_address((unsigned long) p->addr)) ||
 598                 in_kprobes_functions((unsigned long) p->addr))
 599                 return -EINVAL;*/
 600
 601 #ifdef KPROBES_PROFILE
 602         p->start_tm.tv_sec = p->start_tm.tv_usec = 0;
 603         p->hnd_tm_sum.tv_sec = p->hnd_tm_sum.tv_usec = 0;
 604         p->count = 0;
 605 #endif
 606         p->mod_refcounted = 0;
 607         //p->proc_prio = 0;
 608         //p->proc_sched = 0;
 609         //p->spid = -1;
 610         //p->irq = 0;
 611         //p->task_flags = 0;
 612 /*
 613         // Check are we probing a module
 614         if ((probed_mod = module_text_address((unsigned long) p->addr))) {
 615                 struct module *calling_mod = module_text_address(called_from);
 616                 // We must allow modules to probe themself and
 617                 // in this case avoid incrementing the module refcount,
 618                 // so as to allow unloading of self probing modules.
 619                 //
 620                 if (calling_mod && (calling_mod != probed_mod)) {
 621                         if (unlikely(!try_module_get(probed_mod)))
 622                                 return -EINVAL;
 623                         p->mod_refcounted = 1;
 624                 } else
 625                         probed_mod = NULL;
 626         }
 627 */
 628         p->nmissed = 0;
 629 //      mutex_lock(&kprobe_mutex);
 630         old_p = get_kprobe (p->addr, 0, NULL);
 631         if (old_p)
 632         {
 633                 ret = register_aggr_kprobe (old_p, p);
 634                 if (!ret)
 635                         atomic_inc (&kprobe_count);
 636                 goto out;
 637         }
 638
 639         if ((ret = arch_prepare_kprobe (p)) != 0)
 640                 goto out;
 641
 642         DBPRINTF ("before out ret = 0x%x\n", ret);
 643
 644         INIT_HLIST_NODE (&p->hlist);
 645         hlist_add_head_rcu (&p->hlist, &kprobe_table[hash_ptr (p->addr, KPROBE_HASH_BITS)]);
 646
 647 /*      if (atomic_add_return(1, &kprobe_count) == \
 648                                 (ARCH_INACTIVE_KPROBE_COUNT + 1))
 649                 register_page_fault_notifier(&kprobe_page_fault_nb);*/
 650
 651         arch_arm_kprobe (p);
 652
 653       out:
 654 //      mutex_unlock(&kprobe_mutex);
 655 /*
 656         if (ret && probed_mod)
 657                 module_put(probed_mod);
 658 */
 659         DBPRINTF ("out ret = 0x%x\n", ret);
 660
 661         return ret;
 662 }
 663
 664 static int __kprobes
 665 __register_uprobe (struct kprobe *p, struct task_struct *task, int atomic, unsigned long called_from)
 666 {
 667         int ret = 0;
 668         struct kprobe *old_p;
 669
 670         if (!p->addr)
 671                 return -EINVAL;
 672
 673         DBPRINTF ("p->addr = 0x%p p = 0x%p\n", p->addr, p);
 674
 675         p->mod_refcounted = 0;
 676         p->nmissed = 0;
 677 #ifdef KPROBES_PROFILE
 678         p->start_tm.tv_sec = p->start_tm.tv_usec = 0;
 679         p->hnd_tm_sum.tv_sec = p->hnd_tm_sum.tv_usec = 0;
 680         p->count = 0;
 681 #endif
 682
 683         // get the first item
 684         old_p = get_kprobe (p->addr, p->tgid, NULL);
 685         if (old_p)
 686         {
 687                 ret = register_aggr_kprobe (old_p, p);
 688                 if (!ret)
 689                         atomic_inc (&kprobe_count);
 690                 goto out;
 691         }
 692         if ((ret = arch_prepare_uprobe (p, task, atomic)) != 0)
 693         {
 694                 goto out;
 695         }
 696
 697         DBPRINTF ("before out ret = 0x%x\n", ret);
 698
 699         INIT_HLIST_NODE (&p->hlist);
 700         hlist_add_head_rcu (&p->hlist, &kprobe_table[hash_ptr (p->addr, KPROBE_HASH_BITS)]);
 701
 702         INIT_HLIST_NODE (&p->is_hlist);
 703         hlist_add_head_rcu (&p->is_hlist, &uprobe_insn_slot_table[hash_ptr (p->ainsn.insn, KPROBE_HASH_BITS)]);
 704
 705         arch_arm_uprobe (p, task);
 706 out:
 707         DBPRINTF ("out ret = 0x%x\n", ret);
 708
 709         return ret;
 710 }
 711
 712 void __kprobes
 713 unregister_uprobe (struct kprobe *p, struct task_struct *task, int atomic)
 714 {
 715         unregister_kprobe (p, task, atomic);
 716 }
 717
 718 int __kprobes
 719 register_kprobe (struct kprobe *p, int atomic)
 720 {
 721         return __register_kprobe (p, (unsigned long) __builtin_return_address (0), atomic);
 722 }
 723
 724 void __kprobes
 725 unregister_kprobe (struct kprobe *p, struct task_struct *task, int atomic)
 726 {
 727 //      struct module *mod;
 728         struct kprobe *old_p, *list_p;
 729         int cleanup_p, pid = 0;
 730
 731 //      mutex_lock(&kprobe_mutex);
 732
 733         pid = p->tgid;
 734
 735         old_p = get_kprobe (p->addr, pid, NULL);
 736         DBPRINTF ("unregister_kprobe p=%p old_p=%p", p, old_p);
 737         if (unlikely (!old_p))
 738         {
 739 //              mutex_unlock(&kprobe_mutex);
 740                 return;
 741         }
 742         if (p != old_p)
 743         {
 744                 list_for_each_entry_rcu (list_p, &old_p->list, list)
 745                         if (list_p == p)
 746                                 /* kprobe p is a valid probe */
 747                                 goto valid_p;
 748 //              mutex_unlock(&kprobe_mutex);
 749                 return;
 750         }
 751 valid_p:
 752         DBPRINTF ("unregister_kprobe valid_p");
 753         if ((old_p == p) || ((old_p->pre_handler == aggr_pre_handler) &&
 754                 (p->list.next == &old_p->list) && (p->list.prev == &old_p->list)))
 755         {
 756                 /* Only probe on the hash list */
 757                 DBPRINTF ("unregister_kprobe disarm pid=%d", pid);
 758                 if (pid)
 759                         arch_disarm_uprobe (p, task);//vma, page, kaddr);
 760                 else
 761                         arch_disarm_kprobe (p);
 762                 hlist_del_rcu (&old_p->hlist);
 763                 cleanup_p = 1;
 764         }
 765         else
 766         {
 767                 list_del_rcu (&p->list);
 768                 cleanup_p = 0;
 769         }
 770         DBPRINTF ("unregister_kprobe cleanup_p=%d", cleanup_p);
 771 //      mutex_unlock(&kprobe_mutex);
 772
 773 //      synchronize_sched();
 774 /*
 775         if (p->mod_refcounted &&
 776             (mod = module_text_address((unsigned long)p->addr)))
 777                 module_put(mod);
 778 */
 779         if (cleanup_p)
 780         {
 781                 if (p != old_p)
 782                 {
 783                         list_del_rcu (&p->list);
 784                         kfree (old_p);
 785                 }
 786                 arch_remove_kprobe (p, task);
 787         }
 788         else
 789         {
 790 ///             mutex_lock(&kprobe_mutex);
 791                 if (p->break_handler)
 792                         old_p->break_handler = NULL;
 793                 if (p->post_handler)
 794                 {
 795                         list_for_each_entry_rcu (list_p, &old_p->list, list)
 796                         {
 797                                 if (list_p->post_handler)
 798                                 {
 799                                         cleanup_p = 2;
 800                                         break;
 801                                 }
 802                         }
 803                         if (cleanup_p == 0)
 804                                 old_p->post_handler = NULL;
 805                 }
 806 //              mutex_unlock(&kprobe_mutex);
 807         }
 808
 809         /* Call unregister_page_fault_notifier()
 810          * if no probes are active
 811          */
 812 //      mutex_lock(&kprobe_mutex);
 813 /*      if (atomic_add_return(-1, &kprobe_count) == \
 814                                 ARCH_INACTIVE_KPROBE_COUNT)
 815                 unregister_page_fault_notifier(&kprobe_page_fault_nb);*/
 816 //      mutex_unlock(&kprobe_mutex);
 817         return;
 818 }
 819
 820 int __kprobes
 821 register_ujprobe (struct task_struct *task, struct mm_struct *mm, struct jprobe *jp, int atomic)
 822 {
 823 #ifdef _DEBUG
 824         gSilent = 0;
 825 #endif
 826         /* Todo: Verify probepoint is a function entry point */
 827         jp->kp.pre_handler = setjmp_pre_handler;
 828         jp->kp.break_handler = longjmp_break_handler;
 829
 830         int ret = __register_uprobe (&jp->kp, task, atomic,
 831                                     (unsigned long) __builtin_return_address (0));
 832
 833 #ifdef _DEBUG
 834         gSilent = 1;
 835 #endif
 836         return ret;
 837 }
 838
 839 void __kprobes
 840 unregister_ujprobe (struct task_struct *task, struct jprobe *jp, int atomic)
 841 {
 842         unregister_uprobe (&jp->kp, task, atomic);
 843 }
 844
 845 int __kprobes
 846 register_jprobe (struct jprobe *jp, int atomic)
 847 {
 848         /* Todo: Verify probepoint is a function entry point */
 849         jp->kp.pre_handler = setjmp_pre_handler;
 850         jp->kp.break_handler = longjmp_break_handler;
 851
 852         return __register_kprobe (&jp->kp, (unsigned long) __builtin_return_address (0), atomic);
 853 }
 854
 855 void __kprobes
 856 unregister_jprobe (struct jprobe *jp, int atomic)
 857 {
 858         unregister_kprobe (&jp->kp, 0, atomic);
 859 }
 860
 861 /*
 862  * This kprobe pre_handler is registered with every kretprobe. When probe
 863  * hits it will set up the return probe.
 864  */
 865 static int __kprobes
 866 pre_handler_kretprobe (struct kprobe *p, struct pt_regs *regs   /*, struct vm_area_struct **vma,
 867                                                                    struct page **page, unsigned long **kaddr */ )
 868 {
 869         struct kretprobe *rp = container_of (p, struct kretprobe, kp);
 870         unsigned long flags = 0;
 871         DBPRINTF ("START\n");
 872
 873         /*TODO: consider to only swap the RA after the last pre_handler fired */
 874         spin_lock_irqsave (&kretprobe_lock, flags);
 875         if (!rp->disarm)
 876                 __arch_prepare_kretprobe (rp, regs);
 877         spin_unlock_irqrestore (&kretprobe_lock, flags);
 878         DBPRINTF ("END\n");
 879         return 0;
 880 }
 881
 882 struct kretprobe *sched_rp;
 883
 884 int __kprobes
 885 register_kretprobe (struct kretprobe *rp, int atomic)
 886 {
 887         int ret = 0;
 888         struct kretprobe_instance *inst;
 889         int i;
 890         DBPRINTF ("START");
 891
 892         rp->kp.pre_handler = pre_handler_kretprobe;
 893         rp->kp.post_handler = NULL;
 894         rp->kp.fault_handler = NULL;
 895         rp->kp.break_handler = NULL;
 896
 897         rp->disarm = 0;
 898
 899         /* Pre-allocate memory for max kretprobe instances */
 900         if(rp->kp.addr == sched_addr)
 901                 rp->maxactive = 1000;//max (100, 2 * NR_CPUS);
 902         else if (rp->maxactive <= 0)
 903         {
 904 #if 1//def CONFIG_PREEMPT
 905                 rp->maxactive = max (10, 2 * NR_CPUS);
 906 #else
 907                 rp->maxactive = NR_CPUS;
 908 #endif
 909         }
 910         INIT_HLIST_HEAD (&rp->used_instances);
 911         INIT_HLIST_HEAD (&rp->free_instances);
 912         for (i = 0; i < rp->maxactive; i++)
 913         {
 914                 inst = kmalloc (sizeof (struct kretprobe_instance), GFP_KERNEL);
 915                 if (inst == NULL)
 916                 {
 917                         free_rp_inst (rp);
 918                         return -ENOMEM;
 919                 }
 920                 INIT_HLIST_NODE (&inst->uflist);
 921                 hlist_add_head (&inst->uflist, &rp->free_instances);
 922         }
 923
 924         DBPRINTF ("addr=%p, *addr=[%lx %lx %lx]", rp->kp.addr, (unsigned long) (*(rp->kp.addr)), (unsigned long) (*(rp->kp.addr + 1)), (unsigned long) (*(rp->kp.addr + 2)));
 925         rp->nmissed = 0;
 926         /* Establish function entry probe point */
 927         if ((ret = __register_kprobe (&rp->kp, (unsigned long) __builtin_return_address (0), atomic)) != 0)
 928                 free_rp_inst (rp);
 929
 930         DBPRINTF ("addr=%p, *addr=[%lx %lx %lx]", rp->kp.addr, (unsigned long) (*(rp->kp.addr)), (unsigned long) (*(rp->kp.addr + 1)), (unsigned long) (*(rp->kp.addr + 2)));
 931         if(rp->kp.addr == sched_addr)
 932                 sched_rp = rp;
 933
 934         return ret;
 935 }
 936
 937 void __kprobes
 938 unregister_kretprobe (struct kretprobe *rp, int atomic)
 939 {
 940         unsigned long flags;
 941         struct kretprobe_instance *ri;
 942
 943         //printk("addr=%p, *addr=[%lx %lx %lx]\n", rp->kp.addr,
 944         //               *(rp->kp.addr), *(rp->kp.addr+1), *(rp->kp.addr+2));
 945         unregister_kprobe (&rp->kp, 0, atomic);
 946
 947         if(rp->kp.addr == sched_addr)
 948                 sched_rp = NULL;
 949
 950         //printk("addr=%p, *addr=[%lx %lx %lx]\n", rp->kp.addr,
 951         //               *(rp->kp.addr), *(rp->kp.addr+1), *(rp->kp.addr+2));
 952         /* No race here */
 953         spin_lock_irqsave (&kretprobe_lock, flags);
 954         while ((ri = get_used_rp_inst (rp)) != NULL)
 955         {
 956                 ri->rp = NULL;
 957                 hlist_del (&ri->uflist);
 958         }
 959         spin_unlock_irqrestore (&kretprobe_lock, flags);
 960         free_rp_inst (rp);
 961 }
 962
 963 int __kprobes
 964 register_uretprobe (struct task_struct *task, struct mm_struct *mm, struct kretprobe *rp, int atomic)
 965 {
 966         int ret = 0;
 967         struct kretprobe_instance *inst;
 968         /*struct page *pages[2] = {0, 0};
 969            struct vm_area_struct *vmas[2] = {0, 0};
 970            unsigned long *kaddrs[2] = {0, 0}; */
 971         int i;
 972 #ifdef _DEBUG
 973         gSilent = 0;
 974 #endif
 975
 976         DBPRINTF ("START\n");
 977
 978         rp->kp.pre_handler = pre_handler_kretprobe;
 979         rp->kp.post_handler = NULL;
 980         rp->kp.fault_handler = NULL;
 981         rp->kp.break_handler = NULL;
 982
 983         rp->disarm = 0;
 984
 985         /* Pre-allocate memory for max kretprobe instances */
 986         if (rp->maxactive <= 0)
 987         {
 988 #if 1//def CONFIG_PREEMPT
 989                 rp->maxactive = max (10, 2 * NR_CPUS);
 990 #else
 991                 rp->maxactive = NR_CPUS;
 992 #endif
 993         }
 994         INIT_HLIST_HEAD (&rp->used_instances);
 995         INIT_HLIST_HEAD (&rp->free_instances);
 996         for (i = 0; i < rp->maxactive; i++)
 997         {
 998                 inst = kmalloc (sizeof (struct kretprobe_instance), GFP_KERNEL);
 999                 if (inst == NULL)
1000                 {
1001                         free_rp_inst (rp);
1002                         ret = -ENOMEM;
1003                         goto out;
1004                 }
1005                 INIT_HLIST_NODE (&inst->uflist);
1006                 hlist_add_head (&inst->uflist, &rp->free_instances);
1007         }
1008
1009         rp->nmissed = 0;
1010 #if 0
1011         if (atomic)
1012                 ret = get_user_pages_atomic (task, mm, (unsigned long) rp->kp.addr, 1, 1, 1, &pages[0], &vmas[0]);
1013         else
1014                 ret = get_user_pages (task, mm, (unsigned long) rp->kp.addr, 1, 1, 1, &pages[0], &vmas[0]);
1015         if (ret <= 0)
1016         {
1017                 DBPRINTF ("get_user_pages for %p failed!", rp->kp.addr);
1018                 ret = -EFAULT;
1019                 goto out;
1020         }
1021         if (atomic)
1022                 kaddrs[0] = kmap_atomic (pages[0], KM_USER0) + ((unsigned long) rp->kp.addr & ~PAGE_MASK);
1023         else
1024                 kaddrs[0] = kmap (pages[0]) + ((unsigned long) rp->kp.addr & ~PAGE_MASK);
1025         // if 2nd instruction is on the 2nd page
1026         if ((((unsigned long) (rp->kp.addr + 1)) & ~PAGE_MASK) == 0)
1027         {
1028                 if (atomic)
1029                         ret = get_user_pages_atomic (task, mm, (unsigned long) (rp->kp.addr + 1), 1, 1, 1, &pages[1], &vmas[1]);
1030                 else
1031                         ret = get_user_pages (task, mm, (unsigned long) (rp->kp.addr + 1), 1, 1, 1, &pages[1], &vmas[1]);
1032                 if (ret <= 0)
1033                 {
1034                         DBPRINTF ("get_user_pages for %p failed!", rp->kp.addr + 1);
1035                         ret = -EFAULT;
1036                         goto out;
1037                 }
1038                 if (atomic)
1039                         kaddrs[1] = kmap_atomic (pages[1], KM_USER1) + ((unsigned long) (rp->kp.addr + 1) & ~PAGE_MASK);
1040                 else
1041                         kaddrs[1] = kmap (pages[1]) + ((unsigned long) (rp->kp.addr + 1) & ~PAGE_MASK);
1042         }
1043         else
1044         {
1045                 // 2nd instruction is on the 1st page too
1046                 vmas[1] = vmas[0];
1047                 pages[1] = pages[0];
1048                 kaddrs[1] = kaddrs[0] + 1;
1049         }
1050 #endif
1051         /* Establish function exit probe point */
1052         if ((ret = arch_prepare_uretprobe (rp, task/*vmas, pages, kaddrs */ )) != 0)
1053                 goto out;
1054         /* Establish function entry probe point */
1055         if ((ret = __register_uprobe (&rp->kp, task, atomic,
1056                                          (unsigned long) __builtin_return_address (0))) != 0)
1057         {
1058                 free_rp_inst (rp);
1059                 goto out;
1060         }
1061
1062         arch_arm_uretprobe (rp, task);//vmas[1], pages[1], kaddrs[1]);
1063 #if 0
1064         if (atomic)
1065                 set_page_dirty (pages[1]);
1066         else
1067                 set_page_dirty_lock (pages[1]);
1068 #endif
1069       out:
1070 #if 0
1071         if (pages[0])
1072         {
1073                 if (kaddrs[0])
1074                 {
1075                         if (atomic)
1076                                 kunmap_atomic (kaddrs[0] - ((unsigned long) rp->kp.addr & ~PAGE_MASK), KM_USER0);
1077                         else
1078                                 kunmap (pages[0]);
1079                 }
1080                 page_cache_release (pages[0]);
1081         }
1082         if ((pages[0] != pages[1]))
1083         {
1084                 if (pages[1])
1085                 {
1086                         if (kaddrs[1])
1087                         {
1088                                 if (atomic)
1089                                         kunmap_atomic (kaddrs[1] - ((unsigned long) (rp->kp.addr + 1) & ~PAGE_MASK), KM_USER1);
1090                                 else
1091                                         kunmap (pages[1]);
1092                         }
1093                         page_cache_release (pages[1]);
1094                 }
1095         }
1096         /*else if( (pages[0] != pages[2]) ){
1097            if(pages[2]){
1098            if(kaddrs[2]) {
1099            if (atomic) kunmap_atomic(kaddrs[2], KM_USER1);
1100            else        kunmap(pages[2]);
1101            }
1102            page_cache_release(pages[2]);
1103            }
1104            } */
1105 #endif
1106
1107 #ifdef _DEBUG
1108         gSilent = 1;
1109 #endif
1110         return ret;
1111 }
1112
1113 static struct kretprobe *__kprobes
1114 clone_kretprobe (struct kretprobe *rp)
1115 {
1116         struct kprobe *old_p;
1117         struct kretprobe *clone = NULL;
1118         int ret;
1119
1120         clone = kmalloc (sizeof (struct kretprobe), GFP_KERNEL);
1121         if (!clone)
1122         {
1123                 DBPRINTF ("failed to alloc memory for clone probe %p!", rp->kp.addr);
1124                 return NULL;
1125         }
1126         memcpy (clone, rp, sizeof (struct kretprobe));
1127         clone->kp.pre_handler = pre_handler_kretprobe;
1128         clone->kp.post_handler = NULL;
1129         clone->kp.fault_handler = NULL;
1130         clone->kp.break_handler = NULL;
1131         old_p = get_kprobe (rp->kp.addr, rp->kp.tgid, NULL);
1132         if (old_p)
1133         {
1134                 ret = register_aggr_kprobe (old_p, &clone->kp);
1135                 if (ret)
1136                 {
1137                         kfree (clone);
1138                         return NULL;
1139                 }
1140                 atomic_inc (&kprobe_count);
1141         }
1142
1143         return clone;
1144 }
1145
1146 void __kprobes
1147 unregister_uretprobe (struct task_struct *task, struct kretprobe *rp, int atomic)
1148 {
1149         //int ret = 0;
1150         unsigned long flags;
1151         struct kretprobe_instance *ri;
1152         struct kretprobe *rp2 = NULL;
1153         /*struct mm_struct *mm;
1154            struct page *pages[2] = {0, 0};
1155            struct vm_area_struct *vmas[2] = {0, 0};
1156            unsigned long *kaddrs[2] = {0, 0}; */
1157
1158 #ifdef _DEBUG
1159         gSilent = 0;
1160 #endif
1161 #if 0
1162         mm = atomic ? task->active_mm : get_task_mm (task);
1163         if (!mm)
1164         {
1165                 DBPRINTF ("task %u has no mm!", task->pid);
1166 #ifdef _DEBUG
1167                 gSilent = 1;
1168 #endif
1169                 return;
1170         }
1171         if (atomic)
1172                 ret = get_user_pages_atomic (task, mm, (unsigned long) rp->kp.addr, 1, 1, 1, &pages[0], &vmas[0]);
1173         else
1174         {
1175                 down_read (&mm->mmap_sem);
1176                 ret = get_user_pages (task, mm, (unsigned long) rp->kp.addr, 1, 1, 1, &pages[0], &vmas[0]);
1177         }
1178         if (ret <= 0)
1179         {
1180                 DBPRINTF ("get_user_pages for %p failed!", rp->kp.addr);
1181                 goto out;
1182         }
1183         if (atomic)
1184                 kaddrs[0] = kmap_atomic (pages[0], KM_USER0) + ((unsigned long) rp->kp.addr & ~PAGE_MASK);
1185         else
1186                 kaddrs[0] = kmap (pages[0]) + ((unsigned long) rp->kp.addr & ~PAGE_MASK);
1187         if ((((unsigned long) (rp->kp.addr + 1)) & ~PAGE_MASK) == 0)
1188         {
1189                 if (atomic)
1190                         ret = get_user_pages_atomic (task, mm, (unsigned long) (rp->kp.addr + 1), 1, 1, 1, &pages[1], &vmas[1]);
1191                 else
1192                         ret = get_user_pages (task, mm, (unsigned long) (rp->kp.addr + 1), 1, 1, 1, &pages[1], &vmas[1]);
1193                 if (ret <= 0)
1194                 {
1195                         DBPRINTF ("get_user_pages for %p failed!", rp->kp.addr + 1);
1196                         goto out;
1197                 }
1198                 if (atomic)
1199                         kaddrs[1] = kmap_atomic (pages[1], KM_USER1) + ((unsigned long) (rp->kp.addr + 1) & ~PAGE_MASK);
1200                 else
1201                         kaddrs[1] = kmap (pages[1]) + ((unsigned long) (rp->kp.addr + 1) & ~PAGE_MASK);
1202         }
1203         else
1204         {
1205                 vmas[1] = vmas[0];
1206                 pages[1] = pages[0];
1207                 kaddrs[1] = kaddrs[0] + 1;
1208         }
1209
1210         /* No race here */
1211         DBPRINTF ("unregister_uretprobe1 addr %p [%lx %lx]", rp->kp.addr, *kaddrs[0], *kaddrs[1]);
1212 #endif
1213         spin_lock_irqsave (&kretprobe_lock, flags);
1214         if (hlist_empty (&rp->used_instances))
1215         {
1216                 // if there are no used retprobe instances (i.e. function is not entered) - disarm retprobe
1217                 arch_disarm_uretprobe (rp, task);//vmas[1], pages[1], kaddrs[1]);
1218 #if 0
1219                 if (atomic)
1220                         set_page_dirty (pages[1]);
1221                 else
1222                         set_page_dirty_lock (pages[1]);
1223 #endif
1224         }
1225         else
1226         {
1227                 rp2 = clone_kretprobe (rp);
1228                 if (!rp2)
1229                         DBPRINTF ("unregister_uretprobe addr %p: failed to clone retprobe!", rp->kp.addr);
1230                 else
1231                 {
1232                         DBPRINTF ("initiating deferred retprobe deletion addr %p", rp->kp.addr);
1233                         printk ("initiating deferred retprobe deletion addr %p\n", rp->kp.addr);
1234                         rp2->disarm = 1;
1235                 }
1236         }
1237
1238         while ((ri = get_used_rp_inst (rp)) != NULL)
1239         {
1240                 ri->rp = NULL;
1241                 ri->rp2 = rp2;
1242                 hlist_del (&ri->uflist);
1243         }
1244         spin_unlock_irqrestore (&kretprobe_lock, flags);
1245         free_rp_inst (rp);
1246
1247         unregister_uprobe (&rp->kp, task, atomic);
1248         //DBPRINTF("unregister_uretprobe3 addr %p [%lx %lx]",
1249         //              rp->kp.addr, *kaddrs[0], *kaddrs[1]);
1250 #if 0
1251       out:
1252         if (pages[0])
1253         {
1254                 if (kaddrs[0])
1255                 {
1256                         if (atomic)
1257                                 kunmap_atomic (kaddrs[0] - ((unsigned long) rp->kp.addr & ~PAGE_MASK), KM_USER0);
1258                         else
1259                                 kunmap (pages[0]);
1260                 }
1261                 page_cache_release (pages[0]);
1262         }
1263         if (pages[1] && (pages[0] != pages[1]))
1264         {
1265                 if (kaddrs[1])
1266                 {
1267                         if (atomic)
1268                                 kunmap_atomic (kaddrs[1] - ((unsigned long) (rp->kp.addr + 1) & ~PAGE_MASK), KM_USER1);
1269                         else
1270                                 kunmap (pages[1]);
1271                 }
1272                 page_cache_release (pages[1]);
1273         }
1274         if (!atomic)
1275         {
1276                 up_read (&mm->mmap_sem);
1277                 mmput (mm);
1278         }
1279 #endif
1280 #ifdef _DEBUG
1281         gSilent = 1;
1282 #endif
1283 }
1284
1285 void __kprobes
1286 unregister_all_uprobes (struct task_struct *task, int atomic)
1287 {
1288         struct hlist_head *head;
1289         struct hlist_node *node, *tnode;
1290         struct kprobe *p;
1291         int i;
1292
1293         for(i = 0; i < KPROBE_TABLE_SIZE; i++){
1294                 head = &kprobe_table[i];
1295                 hlist_for_each_entry_safe (p, node, tnode, head, hlist){
1296                         if(p->tgid == task->tgid){
1297                                 printk("unregister_all_uprobes: delete uprobe at %pf for %s/%d\n", p->addr, task->comm, task->pid);
1298                                 unregister_uprobe (p, task, atomic);
1299                         }
1300                 }
1301         }
1302         purge_garbage_uslots(task, atomic);
1303 }
1304
1305 #if 0
1306 int
1307 access_process_vm (struct task_struct *tsk, unsigned long addr, void *buf, int len, int write)
1308 {
1309         struct mm_struct *mm;
1310         struct vm_area_struct *vma;
1311         struct page *page;
1312         void *old_buf = buf;
1313
1314         mm = get_task_mm (tsk);
1315         if (!mm)
1316                 return 0;
1317
1318         down_read (&mm->mmap_sem);
1319         /* ignore errors, just check how much was sucessfully transfered */
1320         while (len)
1321         {
1322                 int bytes, ret, offset;
1323                 void *maddr;
1324
1325                 ret = get_user_pages (tsk, mm, addr, 1, write, 1, &page, &vma);
1326                 if (ret <= 0)
1327                         break;
1328
1329                 bytes = len;
1330                 offset = addr & (PAGE_SIZE - 1);
1331                 if (bytes > PAGE_SIZE - offset)
1332                         bytes = PAGE_SIZE - offset;
1333
1334                 maddr = kmap (page);    //, KM_USER0);
1335                 if (write)
1336                 {
1337                         copy_to_user_page (vma, page, addr, maddr + offset, buf, bytes);
1338                         set_page_dirty_lock (page);
1339                 }
1340                 else
1341                 {
1342                         copy_from_user_page (vma, page, addr, buf, maddr + offset, bytes);
1343                 }
1344                 kunmap (page);  //, KM_USER0);
1345                 page_cache_release (page);
1346                 len -= bytes;
1347                 buf += bytes;
1348                 addr += bytes;
1349         }
1350         up_read (&mm->mmap_sem);
1351         mmput (mm);
1352
1353         return buf - old_buf;
1354 }
1355 #endif
1356
1357 #ifdef CONFIG_DEBUG_FS
1358 const char *(*__real_kallsyms_lookup) (unsigned long addr, unsigned long *symbolsize, unsigned long *offset, char **modname, char *namebuf);
1359 const char *
1360 kallsyms_lookup (unsigned long addr, unsigned long *symbolsize, unsigned long *offset, char **modname, char *namebuf)
1361 {
1362         return __real_kallsyms_lookup (addr, symbolsize, offset, modname, namebuf);
1363 }
1364
1365 static void __kprobes
1366 report_probe (struct seq_file *pi, struct kprobe *p, const char *sym, int offset, char *modname)
1367 {
1368         char *kprobe_type;
1369
1370         if (p->pre_handler == pre_handler_kretprobe)
1371                 if (p->tgid)
1372                         kprobe_type = "ur";
1373                 else
1374                         kprobe_type = "r";
1375         else if (p->pre_handler == setjmp_pre_handler)
1376                 if (p->tgid)
1377                         kprobe_type = "uj";
1378                 else
1379                         kprobe_type = "j";
1380         else if (p->tgid)
1381                 kprobe_type = "u";
1382         else
1383                 kprobe_type = "k";
1384         if (sym)
1385                 seq_printf (pi, "%p  %s  %s+0x%x  %s\n", p->addr, kprobe_type, sym, offset, (modname ? modname : " "));
1386         else
1387                 seq_printf (pi, "%p  %s  %p\n", p->addr, kprobe_type, p->addr);
1388 }
1389
1390 static void __kprobes *
1391 kprobe_seq_start (struct seq_file *f, loff_t * pos)
1392 {
1393         return (*pos < KPROBE_TABLE_SIZE) ? pos : NULL;
1394 }
1395
1396 static void __kprobes *
1397 kprobe_seq_next (struct seq_file *f, void *v, loff_t * pos)
1398 {
1399         (*pos)++;
1400         if (*pos >= KPROBE_TABLE_SIZE)
1401                 return NULL;
1402         return pos;
1403 }
1404
1405 static void __kprobes
1406 kprobe_seq_stop (struct seq_file *f, void *v)
1407 {
1408         /* Nothing to do */
1409 }
1410
1411 struct us_proc_ip
1412 {
1413         char *name;
1414         int installed;
1415         struct jprobe jprobe;
1416         struct kretprobe retprobe;
1417         unsigned long offset;
1418 };
1419
1420 static int __kprobes
1421 show_kprobe_addr (struct seq_file *pi, void *v)
1422 {
1423         struct hlist_head *head;
1424         struct hlist_node *node;
1425         struct kprobe *p, *kp;
1426         const char *sym = NULL;
1427         unsigned int i = *(loff_t *) v;
1428         unsigned long size, offset = 0;
1429         char *modname, namebuf[128];
1430
1431         head = &kprobe_table[i];
1432         preempt_disable ();
1433         hlist_for_each_entry_rcu (p, node, head, hlist)
1434         {
1435                 /*if(p->pid){
1436                    struct us_proc_ip *up = NULL;
1437                    if (p->pre_handler == pre_handler_kretprobe){
1438                    struct kretprobe *rp = container_of(p, struct kretprobe, kp);
1439                    up = container_of(rp, struct us_proc_ip, retprobe);
1440                    }
1441                    else {//if (p->pre_handler == setjmp_pre_handler){
1442                    struct jprobe *jp = container_of(p, struct jprobe, kp);
1443                    up = container_of(jp, struct us_proc_ip, jprobe);
1444                    }
1445                    if(up){
1446                    sym = up->name;
1447                    printk("show_kprobe_addr: %s\n", sym);
1448                    }
1449                    }
1450                    else */
1451                 sym = kallsyms_lookup ((unsigned long) p->addr, &size, &offset, &modname, namebuf);
1452                 if (p->pre_handler == aggr_pre_handler)
1453                 {
1454                         list_for_each_entry_rcu (kp, &p->list, list) report_probe (pi, kp, sym, offset, modname);
1455                 }
1456                 else
1457                         report_probe (pi, p, sym, offset, modname);
1458         }
1459         //seq_printf (pi, "handled exceptions %lu\n", handled_exceptions);
1460         preempt_enable ();
1461         return 0;
1462 }
1463
1464 static struct seq_operations kprobes_seq_ops = {
1465         .start = kprobe_seq_start,
1466         .next = kprobe_seq_next,
1467         .stop = kprobe_seq_stop,
1468         .show = show_kprobe_addr
1469 };
1470
1471 static int __kprobes
1472 kprobes_open (struct inode *inode, struct file *filp)
1473 {
1474         return seq_open (filp, &kprobes_seq_ops);
1475 }
1476
1477 static struct file_operations debugfs_kprobes_operations = {
1478         .open = kprobes_open,
1479         .read = seq_read,
1480         .llseek = seq_lseek,
1481         .release = seq_release,
1482 };
1483
1484 #ifdef KPROBES_PROFILE
1485 extern unsigned long nCount;
1486 extern struct timeval probe_enter_diff_sum;
1487 static void __kprobes *
1488 kprobe_prof_seq_start (struct seq_file *f, loff_t * pos)
1489 {
1490         return (*pos < KPROBE_TABLE_SIZE) ? pos : NULL;
1491 }
1492
1493 static void __kprobes *
1494 kprobe_prof_seq_next (struct seq_file *f, void *v, loff_t * pos)
1495 {
1496         (*pos)++;
1497         if (*pos >= KPROBE_TABLE_SIZE)
1498                 return NULL;
1499         return pos;
1500 }
1501
1502 static void __kprobes
1503 kprobe_prof_seq_stop (struct seq_file *f, void *v)
1504 {
1505 }
1506
1507 static void __kprobes
1508 report_probe_prof (struct seq_file *pi, struct kprobe *p, const char *sym, int offset, char *modname)
1509 {
1510         char *kprobe_type;
1511
1512         if (p->pre_handler == pre_handler_kretprobe)
1513                 if (p->pid)
1514                         kprobe_type = "ur";
1515                 else
1516                         kprobe_type = "r";
1517         else if (p->pre_handler == setjmp_pre_handler)
1518                 if (p->pid)
1519                         kprobe_type = "uj";
1520                 else
1521                         kprobe_type = "j";
1522         else if (p->pid)
1523                 kprobe_type = "u";
1524         else
1525                 kprobe_type = "k";
1526
1527         if (sym)
1528                 seq_printf (pi, "%p  %s  %s+0x%x  %s %lu.%06ld\n", p->addr, kprobe_type,
1529                             sym, offset, (modname ? modname : " "), p->count ? p->hnd_tm_sum.tv_sec / p->count : 0, p->count ? p->hnd_tm_sum.tv_usec / p->count : 0);
1530         else
1531
1532                 seq_printf (pi, "%p  %s  %p %lu.%06ld\n", p->addr, kprobe_type, p->addr, p->count ? p->hnd_tm_sum.tv_sec / p->count : 0, p->count ? p->hnd_tm_sum.tv_usec / p->count : 0);
1533 }
1534
1535 static int __kprobes
1536 show_kprobe_prof (struct seq_file *pi, void *v)
1537 {
1538         struct hlist_head *head;
1539         struct hlist_node *node;
1540         struct kprobe *p;       //, *kp;
1541         const char *sym = NULL;
1542         unsigned int i = *(loff_t *) v;
1543         unsigned long size, offset = 0;
1544         char *modname, namebuf[128];
1545         static struct timeval utv, ktv;
1546         static unsigned long ucount, kcount;
1547
1548         head = &kprobe_table[i];
1549         preempt_disable ();
1550         hlist_for_each_entry_rcu (p, node, head, hlist)
1551         {
1552                 sym = kallsyms_lookup ((unsigned long) p->addr, &size, &offset, &modname, namebuf);
1553                 /*if (p->pre_handler == aggr_pre_handler) {
1554                    list_for_each_entry_rcu(kp, &p->list, list)
1555                    report_probe_prof(pi, kp, sym, offset, modname);
1556                    } else */
1557                 report_probe_prof (pi, p, sym, offset, modname);
1558                 if (p->count)
1559                 {
1560                         if (p->pid)
1561                         {
1562                                 set_normalized_timeval (&utv, utv.tv_sec + p->hnd_tm_sum.tv_sec, utv.tv_usec + p->hnd_tm_sum.tv_usec);
1563                                 ucount += p->count;
1564                         }
1565                         else
1566                         {
1567                                 //seq_printf(pi, "kernel probe handling %lu %lu.%06ld\n",
1568                                 //              p->count, p->hnd_tm_sum.tv_sec, p->hnd_tm_sum.tv_usec);
1569                                 //seq_printf(pi, "kernel probe handling2 %lu %lu.%06ld\n",
1570                                 //              kcount, ktv.tv_sec, ktv.tv_usec);
1571                                 set_normalized_timeval (&ktv, ktv.tv_sec + p->hnd_tm_sum.tv_sec, ktv.tv_usec + p->hnd_tm_sum.tv_usec);
1572                                 kcount += p->count;
1573                                 //seq_printf(pi, "kernel probe handling3 %lu %lu.%06ld\n",
1574                                 //              kcount, ktv.tv_sec, ktv.tv_usec);
1575                         }
1576                 }
1577         }
1578         if (i == (KPROBE_TABLE_SIZE - 1))
1579         {
1580                 seq_printf (pi, "Average kernel probe handling %lu.%06ld\n", kcount ? ktv.tv_sec / kcount : 0, kcount ? ktv.tv_usec / kcount : 0);
1581                 seq_printf (pi, "Average user probe handling %lu.%06ld\n", ucount ? utv.tv_sec / ucount : 0, ucount ? utv.tv_usec / ucount : 0);
1582                 seq_printf (pi, "Average probe period %lu.%06ld\n", nCount ? probe_enter_diff_sum.tv_sec / nCount : 0, nCount ? probe_enter_diff_sum.tv_usec / nCount : 0);
1583                 utv.tv_sec = utv.tv_usec = ktv.tv_sec = ktv.tv_usec = 0;
1584                 ucount = kcount = 0;
1585         }
1586         preempt_enable ();
1587         return 0;
1588 }
1589
1590 static struct seq_operations kprobes_prof_seq_ops = {
1591         .start = kprobe_prof_seq_start,
1592         .next = kprobe_prof_seq_next,
1593         .stop = kprobe_prof_seq_stop,
1594         .show = show_kprobe_prof
1595 };
1596
1597 static int __kprobes
1598 kprobes_prof_open (struct inode *inode, struct file *filp)
1599 {
1600         return seq_open (filp, &kprobes_prof_seq_ops);
1601 }
1602
1603 static struct file_operations debugfs_kprobes_prof_operations = {
1604         .open = kprobes_prof_open,
1605         .read = seq_read,
1606         .llseek = seq_lseek,
1607         .release = seq_release,
1608 };
1609 #endif
1610
1611 int __kprobes debugfs_kprobe_init (void);
1612 static struct dentry *dbg_dir, *dbg_file;
1613 #ifdef KPROBES_PROFILE
1614 static struct dentry *dbg_file_prof;
1615 #endif
1616
1617 int __kprobes
1618 debugfs_kprobe_init (void)
1619 {
1620         //struct dentry *dir, *file;
1621
1622         dbg_dir = debugfs_create_dir ("kprobes", NULL);
1623         if (!dbg_dir)
1624                 return -ENOMEM;
1625
1626         dbg_file = debugfs_create_file ("list", 0444, dbg_dir, 0, &debugfs_kprobes_operations);
1627         if (!dbg_file)
1628         {
1629                 debugfs_remove (dbg_dir);
1630                 dbg_dir = NULL;
1631                 return -ENOMEM;
1632         }
1633
1634 #ifdef KPROBES_PROFILE
1635         dbg_file_prof = debugfs_create_file ("prof", 0444, dbg_dir, 0, &debugfs_kprobes_prof_operations);
1636         if (!dbg_file_prof)
1637         {
1638                 debugfs_remove (dbg_file);
1639                 debugfs_remove (dbg_dir);
1640                 dbg_dir = NULL;
1641                 return -ENOMEM;
1642         }
1643 #endif
1644         return 0;
1645 }
1646
1647 //late_initcall(debugfs_kprobe_init);
1648 extern unsigned long (*kallsyms_search) (const char *name);
1649 #endif /* CONFIG_DEBUG_FS */
1650
1651 #if defined(CONFIG_X86)
1652 static struct notifier_block kprobe_exceptions_nb = {
1653         .notifier_call = kprobe_exceptions_notify,
1654         .priority = INT_MAX
1655 };
1656 #endif
1657
1658 static int __init
1659 init_kprobes (void)
1660 {
1661         int i, err = 0;
1662
1663         /* FIXME allocate the probe table, currently defined statically */
1664         /* initialize all list heads */
1665         for (i = 0; i < KPROBE_TABLE_SIZE; i++)
1666         {
1667                 INIT_HLIST_HEAD (&kprobe_table[i]);
1668                 INIT_HLIST_HEAD (&kretprobe_inst_table[i]);
1669                 INIT_HLIST_HEAD (&uprobe_insn_slot_table[i]);
1670         }
1671         atomic_set (&kprobe_count, 0);
1672
1673         err = arch_init_kprobes ();
1674
1675         DBPRINTF ("init_kprobes: arch_init_kprobes - %d", err);
1676 #if defined(CONFIG_X86)
1677         if (!err)
1678                 err = register_die_notifier (&kprobe_exceptions_nb);
1679         DBPRINTF ("init_kprobes: register_die_notifier - %d", err);
1680 #endif // CONFIG_X86
1681
1682 #ifdef CONFIG_DEBUG_FS
1683         if (!err)
1684         {
1685                 __real_kallsyms_lookup = (void *) kallsyms_search ("kallsyms_lookup");
1686                 if (!__real_kallsyms_lookup)
1687                 {
1688                         DBPRINTF ("kallsyms_lookup is not found! Oops. Where is the kernel?");
1689                         return -ESRCH;
1690                 }
1691                 err = debugfs_kprobe_init ();
1692                 DBPRINTF ("init_kprobes: debugfs_kprobe_init - %d", err);
1693         }
1694 #endif /* CONFIG_DEBUG_FS */
1695
1696         return err;
1697 }
1698
1699 static void __exit
1700 exit_kprobes (void)
1701 {
1702 #ifdef CONFIG_DEBUG_FS
1703 #ifdef KPROBES_PROFILE
1704         if (dbg_file_prof)
1705                 debugfs_remove (dbg_file_prof);
1706 #endif
1707         if (dbg_file)
1708                 debugfs_remove (dbg_file);
1709         if (dbg_dir)
1710                 debugfs_remove (dbg_dir);
1711 #endif /* CONFIG_DEBUG_FS */
1712
1713 #if defined(CONFIG_X86)
1714         unregister_die_notifier (&kprobe_exceptions_nb);
1715 #endif // CONFIG_X86
1716         arch_exit_kprobes ();
1717 }
1718
1719 module_init (init_kprobes);
1720 module_exit (exit_kprobes);
1721
1722 EXPORT_SYMBOL_GPL (register_kprobe);
1723 EXPORT_SYMBOL_GPL (unregister_kprobe);
1724 EXPORT_SYMBOL_GPL (register_jprobe);
1725 EXPORT_SYMBOL_GPL (unregister_jprobe);
1726 EXPORT_SYMBOL_GPL (register_ujprobe);
1727 EXPORT_SYMBOL_GPL (unregister_ujprobe);
1728 EXPORT_SYMBOL_GPL (jprobe_return);
1729 EXPORT_SYMBOL_GPL (uprobe_return);
1730 EXPORT_SYMBOL_GPL (register_kretprobe);
1731 EXPORT_SYMBOL_GPL (unregister_kretprobe);
1732 EXPORT_SYMBOL_GPL (register_uretprobe);
1733 EXPORT_SYMBOL_GPL (unregister_uretprobe);
1734 EXPORT_SYMBOL_GPL (unregister_all_uprobes);
1735 //EXPORT_SYMBOL_GPL (access_process_vm_atomic);
1736 #if LINUX_VERSION_CODE != KERNEL_VERSION(2,6,23)
1737 EXPORT_SYMBOL_GPL (access_process_vm);
1738 #endif
1739 #ifdef KERNEL_HAS_ISPAGEPRESENT
1740 EXPORT_SYMBOL_GPL (is_page_present);
1741 #else
1742 EXPORT_SYMBOL_GPL (page_present);
1743 #endif
1744 //EXPORT_SYMBOL_GPL(get_user_pages_atomic);