kprobe/dbi_kprobes.c

   1 // src_kprobes.c
   2
   3 /*
   4  *  Kernel Probes (KProbes)
   5  *  kernel/kprobes.c
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  20  *
  21  * Copyright (C) IBM Corporation, 2002, 2004
  22  */
  23
  24 /*
  25  *  Dynamic Binary Instrumentation Module based on KProbes
  26  *  modules/kprobe/dbi_kprobes.h
  27  *
  28  * This program is free software; you can redistribute it and/or modify
  29  * it under the terms of the GNU General Public License as published by
  30  * the Free Software Foundation; either version 2 of the License, or
  31  * (at your option) any later version.
  32  *
  33  * This program is distributed in the hope that it will be useful,
  34  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  35  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  36  * GNU General Public License for more details.
  37  *
  38  * You should have received a copy of the GNU General Public License
  39  * along with this program; if not, write to the Free Software
  40  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  41  *
  42  * Copyright (C) Samsung Electronics, 2006-2010
  43  *
  44  * 2006-2007    Ekaterina Gorelkina <e.gorelkina@samsung.com>: initial implementation for ARM and MIPS
  45  * 2008-2009    Alexey Gerenkov <a.gerenkov@samsung.com> User-Space
  46  *              Probes initial implementation; Support x86/ARM/MIPS for both user and kernel spaces.
  47  * 2010         Ekaterina Gorelkina <e.gorelkina@samsung.com>: redesign module for separating core and arch parts
  48  *
  49  */
  50
  51 #include "dbi_kprobes.h"
  52 #include "arch/dbi_kprobes.h"
  53 #include "arch/asm/dbi_kprobes.h"
  54
  55 #include "dbi_kdebug.h"
  56 #include "dbi_kprobes_deps.h"
  57 #include "dbi_insn_slots.h"
  58 #include <ksyms.h>
  59
  60 #include <linux/version.h>
  61 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)
  62 #include <linux/config.h>
  63 #endif
  64
  65 #include <linux/hash.h>
  66 #include <linux/module.h>
  67 #include <linux/mm.h>
  68 #include <linux/pagemap.h>
  69
  70 extern struct hlist_head kprobe_insn_pages;
  71
  72 DEFINE_PER_CPU (struct kprobe *, current_kprobe) = NULL;
  73 static DEFINE_PER_CPU (struct kprobe_ctlblk, kprobe_ctlblk);
  74
  75 DEFINE_SPINLOCK (kretprobe_lock);       /* Protects kretprobe_inst_table */
  76 EXPORT_SYMBOL_GPL(kretprobe_lock);
  77 static DEFINE_PER_CPU (struct kprobe *, kprobe_instance) = NULL;
  78
  79 struct hlist_head kprobe_table[KPROBE_TABLE_SIZE];
  80 static struct hlist_head kretprobe_inst_table[KPROBE_TABLE_SIZE];
  81
  82 atomic_t kprobe_count;
  83 EXPORT_SYMBOL_GPL(kprobe_count);
  84
  85 void kretprobe_assert (struct kretprobe_instance *ri, unsigned long orig_ret_address, unsigned long trampoline_address)
  86 {
  87         if (!orig_ret_address || (orig_ret_address == trampoline_address)) {
  88                 struct task_struct *task;
  89                 if (ri == NULL) {
  90                         panic ("kretprobe BUG!: ri = NULL\n");
  91                 }
  92
  93                 task = ri->task;
  94
  95                 if (task == NULL) {
  96                         panic ("kretprobe BUG!: task = NULL\n");
  97                 }
  98
  99                 if (ri->rp == NULL) {
 100                         panic ("kretprobe BUG!: ri->rp = NULL\n");
 101                 }
 102
 103                 panic ("kretprobe BUG!: Processing kretprobe %p @ %p (%d/%d - %s)\n",
 104                         ri->rp, ri->rp->kp.addr, ri->task->tgid, ri->task->pid, ri->task->comm);
 105         }
 106 }
 107
 108
 109 /* We have preemption disabled.. so it is safe to use __ versions */
 110 static inline
 111 void set_kprobe_instance (struct kprobe *kp)
 112 {
 113         __get_cpu_var (kprobe_instance) = kp;
 114 }
 115
 116 static inline
 117 void reset_kprobe_instance (void)
 118 {
 119         __get_cpu_var (kprobe_instance) = NULL;
 120 }
 121
 122 /* kprobe_running() will just return the current_kprobe on this CPU */
 123 struct kprobe *kprobe_running (void)
 124 {
 125         return (__get_cpu_var (current_kprobe));
 126 }
 127
 128 void reset_current_kprobe (void)
 129 {
 130         __get_cpu_var (current_kprobe) = NULL;
 131 }
 132 EXPORT_SYMBOL_GPL(reset_current_kprobe);
 133
 134 struct kprobe_ctlblk *get_kprobe_ctlblk (void)
 135 {
 136         return (&__get_cpu_var (kprobe_ctlblk));
 137 }
 138 EXPORT_SYMBOL_GPL(get_kprobe_ctlblk);
 139
 140 /*
 141  * This routine is called either:
 142  *      - under the kprobe_mutex - during kprobe_[un]register()
 143  *                              OR
 144  *      - with preemption disabled - from arch/xxx/kernel/kprobes.c
 145  */
 146 struct kprobe *get_kprobe(kprobe_opcode_t *addr, pid_t tgid)
 147 {
 148         struct hlist_head *head;
 149         struct hlist_node *node;
 150         struct kprobe *p, *retVal = NULL;
 151
 152         head = &kprobe_table[hash_ptr (addr, KPROBE_HASH_BITS)];
 153         hlist_for_each_entry_rcu(p, node, head, hlist) {
 154                 if (p->addr == addr && p->tgid == tgid) {
 155                         retVal = p;
 156                         break;
 157                 }
 158         }
 159
 160         DBPRINTF ("get_kprobe: probe %p", retVal);
 161         return retVal;
 162 }
 163
 164 /*
 165  * Aggregate handlers for multiple kprobes support - these handlers
 166  * take care of invoking the individual kprobe handlers on p->list
 167  */
 168 static
 169 int aggr_pre_handler (struct kprobe *p, struct pt_regs *regs)
 170 {
 171         struct kprobe *kp;
 172         int ret;
 173
 174         list_for_each_entry_rcu (kp, &p->list, list)
 175         {
 176                 if (kp->pre_handler)
 177                 {
 178                         set_kprobe_instance (kp);
 179                         ret = kp->pre_handler (kp, regs);
 180                         if (ret)
 181                                 return ret;
 182                 }
 183                 reset_kprobe_instance ();
 184         }
 185         return 0;
 186 }
 187
 188 static
 189 void aggr_post_handler (struct kprobe *p, struct pt_regs *regs, unsigned long flags)
 190 {
 191         struct kprobe *kp;
 192
 193         list_for_each_entry_rcu (kp, &p->list, list)
 194         {
 195                 if (kp->post_handler)
 196                 {
 197                         set_kprobe_instance (kp);
 198                         kp->post_handler (kp, regs, flags);
 199                         reset_kprobe_instance ();
 200                 }
 201         }
 202 }
 203
 204 static
 205 int aggr_fault_handler (struct kprobe *p, struct pt_regs *regs, int trapnr)
 206 {
 207         struct kprobe *cur = __get_cpu_var (kprobe_instance);
 208
 209         /*
 210          * if we faulted "during" the execution of a user specified
 211          * probe handler, invoke just that probe's fault handler
 212          */
 213         if (cur && cur->fault_handler)
 214         {
 215                 if (cur->fault_handler (cur, regs, trapnr))
 216                         return 1;
 217         }
 218         return 0;
 219 }
 220
 221 static
 222 int aggr_break_handler (struct kprobe *p, struct pt_regs *regs)
 223 {
 224         struct kprobe *cur = __get_cpu_var (kprobe_instance);
 225         int ret = 0;
 226         DBPRINTF ("cur = 0x%p\n", cur);
 227         if (cur)
 228                 DBPRINTF ("cur = 0x%p cur->break_handler = 0x%p\n", cur, cur->break_handler);
 229
 230         if (cur && cur->break_handler)
 231         {
 232                 if (cur->break_handler (cur, regs /*, vma, page, kaddr */ ))
 233                         ret = 1;
 234         }
 235         reset_kprobe_instance ();
 236         return ret;
 237 }
 238
 239 /* Walks the list and increments nmissed count for multiprobe case */
 240 void kprobes_inc_nmissed_count (struct kprobe *p)
 241 {
 242         struct kprobe *kp;
 243         if (p->pre_handler != aggr_pre_handler)
 244         {
 245                 p->nmissed++;
 246         }
 247         else
 248         {
 249                 list_for_each_entry_rcu (kp, &p->list, list) kp->nmissed++;
 250         }
 251         return;
 252 }
 253
 254 /* Called with kretprobe_lock held */
 255 struct kretprobe_instance *get_free_rp_inst (struct kretprobe *rp)
 256 {
 257         struct hlist_node *node;
 258         struct kretprobe_instance *ri;
 259         hlist_for_each_entry (ri, node, &rp->free_instances, uflist)
 260                 return ri;
 261         if(!alloc_nodes_kretprobe(rp)){
 262              hlist_for_each_entry (ri, node, &rp->free_instances, uflist)
 263                   return ri;
 264         }
 265         return NULL;
 266 }
 267
 268 /* Called with kretprobe_lock held */
 269 struct kretprobe_instance *get_free_rp_inst_no_alloc (struct kretprobe *rp)
 270 {
 271         struct hlist_node *node;
 272         struct kretprobe_instance *ri;
 273         hlist_for_each_entry (ri, node, &rp->free_instances, uflist)
 274                 return ri;
 275         return NULL;
 276 }
 277
 278 /* Called with kretprobe_lock held */
 279 struct kretprobe_instance *get_used_rp_inst (struct kretprobe *rp)
 280 {
 281         struct hlist_node *node;
 282         struct kretprobe_instance *ri;
 283         hlist_for_each_entry (ri, node, &rp->used_instances, uflist) return ri;
 284         return NULL;
 285 }
 286 EXPORT_SYMBOL_GPL(get_used_rp_inst);
 287
 288 /* Called with kretprobe_lock held */
 289 void add_rp_inst (struct kretprobe_instance *ri)
 290 {
 291         /*
 292          * Remove rp inst off the free list -
 293          * Add it back when probed function returns
 294          */
 295         hlist_del (&ri->uflist);
 296
 297         /* Add rp inst onto table */
 298         INIT_HLIST_NODE (&ri->hlist);
 299         /*
 300          * We are using different hash keys (task and mm) for finding kernel
 301          * space and user space probes.  Kernel space probes can change mm field in
 302          * task_struct.  User space probes can be shared between threads of one
 303          * process so they have different task but same mm.
 304          */
 305         if (ri->rp->kp.tgid) {
 306                 hlist_add_head (&ri->hlist, &kretprobe_inst_table[hash_ptr (ri->task->mm, KPROBE_HASH_BITS)]);
 307         } else {
 308                 hlist_add_head (&ri->hlist, &kretprobe_inst_table[hash_ptr (ri->task, KPROBE_HASH_BITS)]);
 309         }
 310
 311         /* Also add this rp inst to the used list. */
 312         INIT_HLIST_NODE (&ri->uflist);
 313         hlist_add_head (&ri->uflist, &ri->rp->used_instances);
 314 }
 315
 316 /* Called with kretprobe_lock held */
 317 void recycle_rp_inst (struct kretprobe_instance *ri)
 318 {
 319         if (ri->rp)
 320         {
 321                 hlist_del (&ri->hlist);
 322                 /* remove rp inst off the used list */
 323                 hlist_del (&ri->uflist);
 324                 /* put rp inst back onto the free list */
 325                 INIT_HLIST_NODE (&ri->uflist);
 326                 hlist_add_head (&ri->uflist, &ri->rp->free_instances);
 327         } else if (!ri->rp2) {
 328                 /*
 329                  * This is __switch_to retprobe instance.  It has neither rp nor rp2.
 330                  */
 331                 hlist_del (&ri->hlist);
 332         }
 333 }
 334 EXPORT_SYMBOL_GPL(recycle_rp_inst);
 335
 336 struct hlist_head  * kretprobe_inst_table_head (void *hash_key)
 337 {
 338         return &kretprobe_inst_table[hash_ptr (hash_key, KPROBE_HASH_BITS)];
 339 }
 340 EXPORT_SYMBOL_GPL(kretprobe_inst_table_head);
 341
 342 void free_rp_inst (struct kretprobe *rp)
 343 {
 344         struct kretprobe_instance *ri;
 345         while ((ri = get_free_rp_inst_no_alloc (rp)) != NULL)
 346         {
 347                 hlist_del (&ri->uflist);
 348                 kfree (ri);
 349         }
 350 }
 351 EXPORT_SYMBOL_GPL(free_rp_inst);
 352
 353 /*
 354  * Keep all fields in the kprobe consistent
 355  */
 356 static inline
 357 void copy_kprobe (struct kprobe *old_p, struct kprobe *p)
 358 {
 359         memcpy (&p->opcode, &old_p->opcode, sizeof (kprobe_opcode_t));
 360         memcpy (&p->ainsn, &old_p->ainsn, sizeof (struct arch_specific_insn));
 361         p->tgid = old_p->tgid;
 362         p->ss_addr = old_p->ss_addr;
 363 #ifdef CONFIG_ARM
 364         p->safe_arm = old_p->safe_arm;
 365         p->safe_thumb = old_p->safe_thumb;
 366 #endif
 367         //p->spid = old_p->spid;
 368 }
 369
 370 /*
 371  * Add the new probe to old_p->list. Fail if this is the
 372  * second jprobe at the address - two jprobes can't coexist
 373  */
 374 static int add_new_kprobe (struct kprobe *old_p, struct kprobe *p)
 375 {
 376         if (p->break_handler)
 377         {
 378                 if (old_p->break_handler)
 379                         return -EEXIST;
 380                 list_add_tail_rcu (&p->list, &old_p->list);
 381                 old_p->break_handler = aggr_break_handler;
 382         }
 383         else
 384                 list_add_rcu (&p->list, &old_p->list);
 385         if (p->post_handler && !old_p->post_handler)
 386                 old_p->post_handler = aggr_post_handler;
 387         return 0;
 388 }
 389
 390 /**
 391  * hlist_replace_rcu - replace old entry by new one
 392  * @old : the element to be replaced
 393  * @new : the new element to insert
 394  *
 395  * The @old entry will be replaced with the @new entry atomically.
 396  */
 397 inline void dbi_hlist_replace_rcu (struct hlist_node *old, struct hlist_node *new)
 398 {
 399         struct hlist_node *next = old->next;
 400
 401         new->next = next;
 402         new->pprev = old->pprev;
 403         smp_wmb ();
 404         if (next)
 405                 new->next->pprev = &new->next;
 406         if (new->pprev)
 407                 *new->pprev = new;
 408         old->pprev = LIST_POISON2;
 409 }
 410
 411
 412 /*
 413  * Fill in the required fields of the "manager kprobe". Replace the
 414  * earlier kprobe in the hlist with the manager kprobe
 415  */
 416 static inline
 417 void add_aggr_kprobe (struct kprobe *ap, struct kprobe *p)
 418 {
 419         copy_kprobe (p, ap);
 420         //flush_insn_slot (ap);
 421         ap->addr = p->addr;
 422         ap->pre_handler = aggr_pre_handler;
 423         ap->fault_handler = aggr_fault_handler;
 424         if (p->post_handler)
 425                 ap->post_handler = aggr_post_handler;
 426         if (p->break_handler)
 427                 ap->break_handler = aggr_break_handler;
 428
 429         INIT_LIST_HEAD (&ap->list);
 430         list_add_rcu (&p->list, &ap->list);
 431
 432         dbi_hlist_replace_rcu (&p->hlist, &ap->hlist);
 433 }
 434
 435 /*
 436  * This is the second or subsequent kprobe at the address - handle
 437  * the intricacies
 438  */
 439 int register_aggr_kprobe (struct kprobe *old_p, struct kprobe *p)
 440 {
 441         int ret = 0;
 442         struct kprobe *ap;
 443         DBPRINTF ("start\n");
 444
 445         DBPRINTF ("p = %p old_p = %p \n", p, old_p);
 446         if (old_p->pre_handler == aggr_pre_handler)
 447         {
 448                 DBPRINTF ("aggr_pre_handler \n");
 449
 450                 copy_kprobe (old_p, p);
 451                 ret = add_new_kprobe (old_p, p);
 452         }
 453         else
 454         {
 455                 DBPRINTF ("kzalloc\n");
 456
 457 #ifdef kzalloc
 458                 ap = kzalloc (sizeof (struct kprobe), GFP_KERNEL);
 459 #else
 460                 ap = kmalloc (sizeof (struct kprobe), GFP_KERNEL);
 461                 if (ap)
 462                         memset (ap, 0, sizeof (struct kprobe));
 463 #endif
 464                 if (!ap)
 465                         return -ENOMEM;
 466                 add_aggr_kprobe (ap, old_p);
 467                 copy_kprobe (ap, p);
 468                 DBPRINTF ("ap = %p p = %p old_p = %p \n", ap, p, old_p);
 469                 ret = add_new_kprobe (ap, p);
 470         }
 471         return ret;
 472 }
 473 EXPORT_SYMBOL_GPL(register_aggr_kprobe);
 474
 475 int dbi_register_kprobe (struct kprobe *p)
 476 {
 477     struct kprobe *old_p;
 478     int ret = 0;
 479     /*
 480      * If we have a symbol_name argument look it up,
 481      * and add it to the address.  That way the addr
 482      * field can either be global or relative to a symbol.
 483      */
 484     if (p->symbol_name)
 485     {
 486         if (p->addr)
 487             return -EINVAL;
 488         p->addr = (kprobe_opcode_t *)swap_ksyms(p->symbol_name);
 489     }
 490
 491     if (!p->addr)
 492         return -EINVAL;
 493     DBPRINTF ("p->addr = 0x%p\n", p->addr);
 494     p->addr = (kprobe_opcode_t *) (((char *) p->addr) + p->offset);
 495     DBPRINTF ("p->addr = 0x%p p = 0x%p\n", p->addr, p);
 496
 497 #ifdef KPROBES_PROFILE
 498     p->start_tm.tv_sec = p->start_tm.tv_usec = 0;
 499     p->hnd_tm_sum.tv_sec = p->hnd_tm_sum.tv_usec = 0;
 500     p->count = 0;
 501 #endif
 502     p->mod_refcounted = 0;
 503     p->nmissed = 0;
 504
 505     old_p = get_kprobe(p->addr, 0);
 506     if (old_p)
 507     {
 508         ret = register_aggr_kprobe (old_p, p);
 509         if (!ret)
 510             atomic_inc (&kprobe_count);
 511         goto out;
 512     }
 513
 514     if ((ret = arch_prepare_kprobe (p)) != 0)
 515         goto out;
 516
 517     DBPRINTF ("before out ret = 0x%x\n", ret);
 518     INIT_HLIST_NODE (&p->hlist);
 519     hlist_add_head_rcu (&p->hlist, &kprobe_table[hash_ptr (p->addr, KPROBE_HASH_BITS)]);
 520     arch_arm_kprobe (p);
 521
 522 out:
 523     DBPRINTF ("out ret = 0x%x\n", ret);
 524     return ret;
 525 }
 526
 527 void dbi_unregister_kprobe (struct kprobe *p, struct task_struct *task)
 528 {
 529         struct kprobe *old_p, *list_p;
 530         int cleanup_p, pid = p->tgid;
 531
 532         old_p = get_kprobe(p->addr, pid);
 533         DBPRINTF ("dbi_unregister_kprobe p=%p old_p=%p", p, old_p);
 534         if (unlikely (!old_p))
 535                 return;
 536
 537         if (p != old_p)
 538         {
 539                 list_for_each_entry_rcu (list_p, &old_p->list, list)
 540                         if (list_p == p)
 541                                 /* kprobe p is a valid probe */
 542                                 goto valid_p;
 543                 return;
 544         }
 545
 546 valid_p:
 547         DBPRINTF ("dbi_unregister_kprobe valid_p");
 548         if ((old_p == p) || ((old_p->pre_handler == aggr_pre_handler) &&
 549                                 (p->list.next == &old_p->list) && (p->list.prev == &old_p->list)))
 550         {
 551                 /* Only probe on the hash list */
 552                 DBPRINTF ("dbi_unregister_kprobe disarm pid=%d", pid);
 553                 if (pid)
 554                         arch_disarm_uprobe (p, task);//vma, page, kaddr);
 555                 else
 556                         arch_disarm_kprobe (p);
 557                 hlist_del_rcu (&old_p->hlist);
 558                 cleanup_p = 1;
 559         }
 560         else
 561         {
 562                 list_del_rcu (&p->list);
 563                 cleanup_p = 0;
 564         }
 565         DBPRINTF ("dbi_unregister_kprobe cleanup_p=%d", cleanup_p);
 566
 567         if (cleanup_p)
 568         {
 569                 if (p != old_p)
 570                 {
 571                         list_del_rcu (&p->list);
 572                         kfree (old_p);
 573                 }
 574
 575                 if (!in_atomic()) {
 576                         synchronize_sched();
 577                 }
 578
 579                 if (pid) {
 580                         arch_remove_uprobe(p, task);
 581                 } else {
 582                         arch_remove_kprobe(p);
 583                 }
 584         }
 585         else
 586         {
 587                 if (p->break_handler)
 588                         old_p->break_handler = NULL;
 589                 if (p->post_handler)
 590                 {
 591                         list_for_each_entry_rcu (list_p, &old_p->list, list)
 592                         {
 593                                 if (list_p->post_handler)
 594                                 {
 595                                         cleanup_p = 2;
 596                                         break;
 597                                 }
 598                         }
 599                         if (cleanup_p == 0)
 600                                 old_p->post_handler = NULL;
 601                 }
 602         }
 603 }
 604
 605 int dbi_register_jprobe (struct jprobe *jp)
 606 {
 607         /* Todo: Verify probepoint is a function entry point */
 608         jp->kp.pre_handler = setjmp_pre_handler;
 609         jp->kp.break_handler = longjmp_break_handler;
 610
 611         return dbi_register_kprobe (&jp->kp);
 612 }
 613
 614 void dbi_unregister_jprobe (struct jprobe *jp)
 615 {
 616         dbi_unregister_kprobe (&jp->kp, NULL);
 617 }
 618
 619 /*
 620  * This kprobe pre_handler is registered with every kretprobe. When probe
 621  * hits it will set up the return probe.
 622  */
 623 int pre_handler_kretprobe (struct kprobe *p, struct pt_regs *regs)
 624 {
 625         struct kretprobe *rp = container_of (p, struct kretprobe, kp);
 626         unsigned long flags = 0;
 627         DBPRINTF ("START\n");
 628
 629         /*TODO: consider to only swap the RA after the last pre_handler fired */
 630         spin_lock_irqsave (&kretprobe_lock, flags);
 631         if (!rp->disarm)
 632                 __arch_prepare_kretprobe (rp, regs);
 633         spin_unlock_irqrestore (&kretprobe_lock, flags);
 634         DBPRINTF ("END\n");
 635         return 0;
 636 }
 637 EXPORT_SYMBOL_GPL(pre_handler_kretprobe);
 638
 639 struct kretprobe *sched_rp;
 640
 641 #define SCHED_RP_NR 200
 642 #define COMMON_RP_NR 10
 643
 644 int alloc_nodes_kretprobe(struct kretprobe *rp)
 645 {
 646      int alloc_nodes;
 647      struct kretprobe_instance *inst;
 648      int i;
 649
 650      DBPRINTF("Alloc aditional mem for retprobes");
 651
 652      if ((unsigned long)rp->kp.addr == sched_addr){
 653           rp->maxactive += SCHED_RP_NR;//max (100, 2 * NR_CPUS);
 654           alloc_nodes = SCHED_RP_NR;
 655      }
 656      else
 657      {
 658 #if 1//def CONFIG_PREEMPT
 659           rp->maxactive += max (COMMON_RP_NR, 2 * NR_CPUS);
 660 #else
 661           rp->maxacpptive += NR_CPUS;
 662 #endif
 663           alloc_nodes = COMMON_RP_NR;
 664      }
 665      /* INIT_HLIST_HEAD (&rp->used_instances); */
 666      /* INIT_HLIST_HEAD (&rp->free_instances); */
 667      for (i = 0; i < alloc_nodes; i++)
 668      {
 669           inst = kmalloc (sizeof (struct kretprobe_instance), GFP_ATOMIC);
 670           if (inst == NULL)
 671           {
 672                free_rp_inst (rp);
 673                return -ENOMEM;
 674           }
 675           INIT_HLIST_NODE (&inst->uflist);
 676           hlist_add_head (&inst->uflist, &rp->free_instances);
 677      }
 678
 679      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)));
 680      return 0;
 681 }
 682
 683 int dbi_register_kretprobe (struct kretprobe *rp)
 684 {
 685         int ret = 0;
 686         struct kretprobe_instance *inst;
 687         int i;
 688         DBPRINTF ("START");
 689
 690         rp->kp.pre_handler = pre_handler_kretprobe;
 691         rp->kp.post_handler = NULL;
 692         rp->kp.fault_handler = NULL;
 693         rp->kp.break_handler = NULL;
 694
 695         rp->disarm = 0;
 696
 697         /* Pre-allocate memory for max kretprobe instances */
 698         if ((unsigned long)rp->kp.addr == sched_addr) {
 699                 rp->maxactive = SCHED_RP_NR;//max (100, 2 * NR_CPUS);
 700                 rp->kp.pre_handler = NULL; //not needed for __switch_to
 701         } else if ((unsigned long)rp->kp.addr == exit_addr) {
 702                 rp->kp.pre_handler = NULL; //not needed for do_exit
 703                 rp->maxactive = 0;
 704         } else if (rp->maxactive <= 0) {
 705 #if 1//def CONFIG_PREEMPT
 706                 rp->maxactive = max (COMMON_RP_NR, 2 * NR_CPUS);
 707 #else
 708                 rp->maxactive = NR_CPUS;
 709 #endif
 710         }
 711         INIT_HLIST_HEAD (&rp->used_instances);
 712         INIT_HLIST_HEAD (&rp->free_instances);
 713         for (i = 0; i < rp->maxactive; i++)
 714         {
 715                 inst = kmalloc (sizeof (struct kretprobe_instance), GFP_KERNEL);
 716                 if (inst == NULL)
 717                 {
 718                         free_rp_inst (rp);
 719                         return -ENOMEM;
 720                 }
 721                 INIT_HLIST_NODE (&inst->uflist);
 722                 hlist_add_head (&inst->uflist, &rp->free_instances);
 723         }
 724
 725         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)));
 726         rp->nmissed = 0;
 727         /* Establish function entry probe point */
 728         if ((ret = dbi_register_kprobe (&rp->kp)) != 0)
 729                 free_rp_inst (rp);
 730
 731         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)));
 732         if ((unsigned long)rp->kp.addr == sched_addr) {
 733                 sched_rp = rp;
 734         }
 735
 736         return ret;
 737 }
 738
 739 static int dbi_disarm_krp_inst(struct kretprobe_instance *ri);
 740
 741 void dbi_unregister_kretprobe (struct kretprobe *rp)
 742 {
 743         unsigned long flags;
 744         struct kretprobe_instance *ri;
 745
 746         dbi_unregister_kprobe (&rp->kp, NULL);
 747
 748         /* No race here */
 749         spin_lock_irqsave (&kretprobe_lock, flags);
 750
 751         if ((unsigned long)rp->kp.addr == sched_addr)
 752                 sched_rp = NULL;
 753
 754         while ((ri = get_used_rp_inst (rp)) != NULL) {
 755                 if (dbi_disarm_krp_inst(ri) == 0)
 756                         recycle_rp_inst(ri);
 757                 else
 758                         panic("%s (%d/%d): cannot disarm krp instance (%08lx)",
 759                                         ri->task->comm, ri->task->tgid, ri->task->pid,
 760                                         (unsigned long)rp->kp.addr);
 761         }
 762
 763         spin_unlock_irqrestore (&kretprobe_lock, flags);
 764         free_rp_inst (rp);
 765 }
 766
 767 struct kretprobe * clone_kretprobe (struct kretprobe *rp)
 768 {
 769         struct kprobe *old_p;
 770         struct kretprobe *clone = NULL;
 771         int ret;
 772
 773         clone = kmalloc (sizeof (struct kretprobe), GFP_KERNEL);
 774         if (!clone)
 775         {
 776                 DBPRINTF ("failed to alloc memory for clone probe %p!", rp->kp.addr);
 777                 return NULL;
 778         }
 779         memcpy (clone, rp, sizeof (struct kretprobe));
 780         clone->kp.pre_handler = pre_handler_kretprobe;
 781         clone->kp.post_handler = NULL;
 782         clone->kp.fault_handler = NULL;
 783         clone->kp.break_handler = NULL;
 784         old_p = get_kprobe(rp->kp.addr, rp->kp.tgid);
 785         if (old_p)
 786         {
 787                 ret = register_aggr_kprobe (old_p, &clone->kp);
 788                 if (ret)
 789                 {
 790                         kfree (clone);
 791                         return NULL;
 792                 }
 793                 atomic_inc (&kprobe_count);
 794         }
 795
 796         return clone;
 797 }
 798 EXPORT_SYMBOL_GPL(clone_kretprobe);
 799
 800 static void inline set_task_trampoline(struct task_struct *p, struct kretprobe_instance *ri, unsigned long tramp_addr)
 801 {
 802         unsigned long pc = arch_get_task_pc(p);
 803         if (pc == tramp_addr)
 804                 panic("[%d] %s (%d/%d): pc = %08lx --- [%d] %s (%d/%d)\n",
 805                                 task_cpu(p), p->comm, p->tgid, p->pid, pc,
 806                                 task_cpu(current), current->comm, current->tgid, current->pid);
 807         ri->ret_addr = (kprobe_opcode_t *)pc;
 808         arch_set_task_pc(p, tramp_addr);
 809 }
 810
 811 static void inline rm_task_trampoline(struct task_struct *p, struct kretprobe_instance *ri)
 812 {
 813         arch_set_task_pc(p, (unsigned long)ri->ret_addr);
 814 }
 815
 816 static int dbi_disarm_krp_inst(struct kretprobe_instance *ri)
 817 {
 818         kprobe_opcode_t *tramp = (kprobe_opcode_t *)&kretprobe_trampoline;
 819         kprobe_opcode_t *sp = ri->sp;
 820         kprobe_opcode_t *found = NULL;
 821         int retval = -ENOENT;
 822
 823         if (!sp) {
 824                 unsigned long pc = arch_get_task_pc(ri->task);
 825
 826                 printk("---> [%d] %s (%d/%d): pc = %08lx, ra = %08lx, tramp= %08lx (%08lx)\n",
 827                                 task_cpu(ri->task),
 828                                 ri->task->comm, ri->task->tgid, ri->task->pid,
 829                                 pc, (unsigned long)ri->ret_addr,
 830                                 (unsigned long)tramp,
 831                                 (unsigned long)(ri->rp ? ri->rp->kp.addr: NULL));
 832
 833                 /* __switch_to retprobe handling */
 834                 if (pc == (unsigned long)tramp) {
 835                         rm_task_trampoline(ri->task, ri);
 836                         return 0;
 837                 }
 838
 839                 return -EINVAL;
 840         }
 841
 842         while (sp > ri->sp - RETPROBE_STACK_DEPTH) {
 843                 if ((unsigned long)*sp == (unsigned long)tramp) {
 844                         found = sp;
 845                         break;
 846                 }
 847                 sp--;
 848         }
 849
 850         if (found) {
 851                 printk("---> [%d] %s (%d/%d): tramp (%08lx) found at %08lx (%08lx /%+d) - %p\n",
 852                                 task_cpu(ri->task),
 853                                 ri->task->comm, ri->task->tgid, ri->task->pid,
 854                                 (unsigned long)tramp,
 855                                 (unsigned long)found, (unsigned long)ri->sp, found - ri->sp,
 856                                 ri->rp ? ri->rp->kp.addr: NULL);
 857                 *found = (unsigned long)ri->ret_addr;
 858                 retval = 0;
 859         } else {
 860                 printk("---> [%d] %s (%d/%d): tramp (%08lx) NOT found at sp = %08lx - %p\n",
 861                                 task_cpu(ri->task),
 862                                 ri->task->comm, ri->task->tgid, ri->task->pid,
 863                                 (unsigned long)tramp,
 864                                 (unsigned long)ri->sp, ri->rp ? ri->rp->kp.addr: NULL);
 865         }
 866
 867         return retval;
 868 }
 869
 870 int patch_suspended_task(struct kretprobe *rp, struct task_struct *task)
 871 {
 872         struct kretprobe_instance *ri;
 873         unsigned long flags;
 874         kprobe_opcode_t *tramp = (kprobe_opcode_t *)&kretprobe_trampoline;
 875
 876         spin_lock_irqsave(&kretprobe_lock, flags);
 877
 878         ri = get_free_rp_inst(rp);
 879         if (!ri)
 880                 return -ENOMEM;
 881
 882         ri->rp = rp;
 883         ri->rp2 = NULL;
 884         ri->task = task;
 885         ri->sp = NULL;
 886         set_task_trampoline(task, ri, (unsigned long)tramp);
 887         add_rp_inst(ri);
 888
 889         spin_unlock_irqrestore(&kretprobe_lock, flags);
 890         return 0;
 891 }
 892
 893 static int __init init_kprobes (void)
 894 {
 895         int i, err = 0;
 896
 897         /* FIXME allocate the probe table, currently defined statically */
 898         /* initialize all list heads */
 899         for (i = 0; i < KPROBE_TABLE_SIZE; i++)
 900         {
 901                 INIT_HLIST_HEAD (&kprobe_table[i]);
 902                 INIT_HLIST_HEAD (&kretprobe_inst_table[i]);
 903         }
 904         atomic_set (&kprobe_count, 0);
 905
 906         err = arch_init_kprobes ();
 907
 908         DBPRINTF ("init_kprobes: arch_init_kprobes - %d", err);
 909
 910         return err;
 911 }
 912
 913 static void __exit exit_kprobes (void)
 914 {
 915         dbi_arch_exit_kprobes ();
 916 }
 917
 918 module_init (init_kprobes);
 919 module_exit (exit_kprobes);
 920
 921 EXPORT_SYMBOL_GPL (dbi_register_kprobe);
 922 EXPORT_SYMBOL_GPL (dbi_unregister_kprobe);
 923 EXPORT_SYMBOL_GPL (dbi_register_jprobe);
 924 EXPORT_SYMBOL_GPL (dbi_unregister_jprobe);
 925 EXPORT_SYMBOL_GPL (dbi_jprobe_return);
 926 EXPORT_SYMBOL_GPL (dbi_register_kretprobe);
 927 EXPORT_SYMBOL_GPL (dbi_unregister_kretprobe);
 928
 929 MODULE_LICENSE ("Dual BSD/GPL");
 930