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