driver/us_proc_inst.c

   1 ////////////////////////////////////////////////////////////////////////////////////
   2 //
   3 //      FILE:           us_proc_inst.c
   4 //
   5 //      DESCRIPTION:
   6 //      This file is C source for SWAP driver.
   7 //
   8 //      SEE ALSO:       us_proc_inst.h
   9 //      AUTHOR:         A.Gerenkov, E. Gorelkina
  10 //      COMPANY NAME:   Samsung Research Center in Moscow
  11 //      DEPT NAME:      Advanced Software Group
  12 //      CREATED:        2008.06.02
  13 //      VERSION:        1.0
  14 //      REVISION DATE:  2008.12.02
  15 //
  16 ////////////////////////////////////////////////////////////////////////////////////
  17
  18 #include "module.h"
  19 #include "us_proc_inst.h"
  20
  21 #include "../kprobe/dbi_kprobes_deps.h"
  22 #include "../kprobe/dbi_uprobes.h"
  23
  24 DEFINE_PER_CPU (us_proc_vtp_t *, gpVtp) = NULL;
  25 DEFINE_PER_CPU (struct pt_regs *, gpCurVtpRegs) = NULL;
  26
  27 #if defined(CONFIG_MIPS)
  28 #       define ARCH_REG_VAL(regs, idx)  regs->regs[idx]
  29 #elif defined(CONFIG_ARM)
  30 #       define ARCH_REG_VAL(regs, idx)  regs->uregs[idx]
  31 #else
  32 #       define ARCH_REG_VAL(regs, idx)  0
  33 #       warning ARCH_REG_VAL is not implemented for this architecture. FBI will work improperly or even crash!!!
  34 #endif // ARCH
  35
  36 unsigned long (*dbi_ujprobe_event_pre_handler_custom_p)
  37 (us_proc_ip_t *, struct pt_regs *) = NULL;
  38 EXPORT_SYMBOL(dbi_ujprobe_event_pre_handler_custom_p);
  39 void (*dbi_ujprobe_event_handler_custom_p)(void) = NULL;
  40 EXPORT_SYMBOL(dbi_ujprobe_event_handler_custom_p);
  41 int (*dbi_uretprobe_event_handler_custom_p)
  42 (struct kretprobe_instance *, struct pt_regs *, us_proc_ip_t *) = NULL;
  43 EXPORT_SYMBOL(dbi_uretprobe_event_handler_custom_p);
  44
  45 unsigned long ujprobe_event_pre_handler (us_proc_ip_t * ip, struct pt_regs *regs);
  46 void ujprobe_event_handler (unsigned long arg1, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5, unsigned long arg6);
  47 int uretprobe_event_handler (struct kretprobe_instance *probe, struct pt_regs *regs, us_proc_ip_t * ip);
  48
  49 static int register_usprobe (struct task_struct *task, struct mm_struct *mm, us_proc_ip_t * ip, int atomic, kprobe_opcode_t * islot);
  50 static int unregister_usprobe (struct task_struct *task, us_proc_ip_t * ip, int atomic);
  51
  52 int us_proc_probes;
  53
  54 struct task_inst_info_node {
  55         struct list_head      plist;
  56         inst_us_proc_t *      task_inst_info;
  57         int                   tgid;
  58 };
  59 LIST_HEAD(task_inst_info_list);
  60
  61 #ifdef SLP_APP
  62 struct dentry *launchpad_daemon_dentry = NULL;
  63 EXPORT_SYMBOL_GPL(launchpad_daemon_dentry);
  64 #endif /* SLP_APP */
  65
  66 #ifdef ANDROID_APP
  67 unsigned long android_app_vma_start = 0;
  68 unsigned long android_app_vma_end = 0;
  69 struct dentry *app_process_dentry = NULL;
  70 #endif /* ANDROID_APP */
  71
  72 #ifdef __ANDROID
  73 struct dentry *libdvm_dentry = NULL;
  74 /* Defines below are for libdvm.so with md5sum:
  75  * 5941c87b49198368e7db726c2977bf1d */
  76 #define LIBDVM_ENTRY 0x30a64
  77 #define LIBDVM_RETURN 0x30bdc
  78 #endif /* __ANDROID */
  79
  80 us_proc_otg_ip_t *find_otg_probe(unsigned long addr)
  81 {
  82         us_proc_otg_ip_t *p;
  83
  84         list_for_each_entry_rcu (p, &otg_us_proc_info, list) {
  85                 if (p->ip.offset == addr) {
  86                         return p;
  87                 }
  88         }
  89
  90         return NULL;
  91 }
  92
  93 int add_otg_probe_to_list(unsigned long addr, us_proc_otg_ip_t **pprobe)
  94 {
  95         us_proc_otg_ip_t *new_probe;
  96         us_proc_otg_ip_t *probe;
  97
  98         if (pprobe) {
  99                 *pprobe = NULL;
 100         }
 101         /* check if such probe does already exist */
 102         probe = find_otg_probe(addr);
 103         if (probe) {
 104                 return 1;
 105         }
 106
 107         new_probe = kmalloc(sizeof(us_proc_otg_ip_t), GFP_KERNEL);
 108         if (!new_probe) {
 109                 EPRINTF ("no memory for new probe!");
 110                 return -ENOMEM;
 111         }
 112         memset(new_probe,0, sizeof(us_proc_otg_ip_t));
 113
 114         new_probe->ip.offset = addr;
 115         new_probe->ip.jprobe.kp.addr =
 116                 new_probe->ip.retprobe.kp.addr = (kprobe_opcode_t *)addr;
 117         new_probe->ip.jprobe.priv_arg =
 118                 new_probe->ip.retprobe.priv_arg = new_probe;
 119
 120         INIT_LIST_HEAD(&new_probe->list);
 121         list_add_rcu(&new_probe->list, &otg_us_proc_info);
 122
 123         if (pprobe) {
 124                 *pprobe = new_probe;
 125         }
 126         return 0;
 127 }
 128
 129 int remove_otg_probe_from_list(unsigned long addr)
 130 {
 131         us_proc_otg_ip_t *p;
 132
 133         //check if such probe does exist
 134         p = find_otg_probe(addr);
 135         if (!p) {
 136                 /* We do not care about it. Nothing bad. */
 137                 return 0;
 138         }
 139
 140         list_del_rcu(&p->list);
 141
 142         kfree (p);
 143
 144         return 0;
 145 }
 146
 147 /**
 148  * Prepare copy of instrumentation data for task
 149  * in case of library only instrumentation
 150  */
 151
 152 inst_us_proc_t* copy_task_inst_info (struct task_struct *task, inst_us_proc_t * task_inst_info)
 153 {
 154         int i, j;
 155         kprobe_opcode_t *entry_save;
 156         kprobe_pre_entry_handler_t pre_entry_save;
 157         kretprobe_handler_t handler_save;
 158
 159         inst_us_proc_t* copy_info = 0;
 160
 161         int unres_ips_count = 0, unres_vtps_count = 0;
 162
 163         copy_info = kmalloc (sizeof (inst_us_proc_t), GFP_ATOMIC);
 164         memset ((void *) copy_info, 0, sizeof (inst_us_proc_t));
 165
 166         copy_info->path = task_inst_info->path;
 167         copy_info->m_f_dentry = NULL;
 168
 169         copy_info->libs_count = task_inst_info->libs_count;
 170         copy_info->p_libs =
 171                 kmalloc (task_inst_info->libs_count * sizeof (us_proc_lib_t), GFP_ATOMIC);
 172
 173         if (!copy_info->p_libs) {
 174                 DPRINTF ("No enough memory for copy_info->p_libs");
 175                 return NULL;
 176         }
 177         memcpy (copy_info->p_libs, task_inst_info->p_libs,
 178                         copy_info->libs_count * sizeof (us_proc_lib_t));
 179
 180         for (i = 0; i < copy_info->libs_count; i++) {
 181                 if (copy_info->p_libs[i].ips_count > 0)
 182                 {
 183                         unres_ips_count += copy_info->p_libs[i].ips_count;
 184
 185                         copy_info->p_libs[i].p_ips =
 186                                 kmalloc (copy_info->p_libs[i].ips_count * sizeof (us_proc_ip_t), GFP_ATOMIC);
 187
 188                         if (!copy_info->p_libs[i].p_ips) {
 189                                 DPRINTF ("No enough memory for copy_info->p_libs[i].p_ips");
 190                                 return NULL;
 191                         }
 192
 193                         memcpy (copy_info->p_libs[i].p_ips, task_inst_info->p_libs[i].p_ips,
 194                                         copy_info->p_libs[i].ips_count * sizeof (us_proc_ip_t));
 195                         for (j = 0; j < copy_info->p_libs[i].ips_count; j++) {
 196                                 // save handlers
 197                                 entry_save = copy_info->p_libs[i].p_ips[j].jprobe.entry;
 198                                 pre_entry_save = copy_info->p_libs[i].p_ips[j].jprobe.pre_entry;
 199                                 handler_save = copy_info->p_libs[i].p_ips[j].retprobe.handler;
 200
 201                                 copy_info->p_libs[i].p_ips[j].installed = 0;
 202                                 memset(&copy_info->p_libs[i].p_ips[j].jprobe, 0, sizeof(struct jprobe));
 203                                 memset(&copy_info->p_libs[i].p_ips[j].retprobe, 0, sizeof(struct kretprobe));
 204
 205                                 // restore handlers
 206                                 copy_info->p_libs[i].p_ips[j].jprobe.entry = entry_save;
 207                                 copy_info->p_libs[i].p_ips[j].jprobe.pre_entry = pre_entry_save;
 208                                 copy_info->p_libs[i].p_ips[j].retprobe.handler = handler_save;
 209                         }
 210
 211                         unres_ips_count += copy_info->p_libs[i].ips_count;
 212                 }
 213
 214                 for (j = 0; j < copy_info->p_libs[i].plt_count; j++)
 215                 {
 216                         copy_info->p_libs[i].p_plt[j].real_func_addr = 0;
 217                 }
 218
 219                 if (copy_info->p_libs[i].vtps_count > 0) {
 220                         unres_vtps_count += copy_info->p_libs[i].vtps_count;
 221
 222                         copy_info->p_libs[i].p_vtps =
 223                                 kmalloc (copy_info->p_libs[i].vtps_count * sizeof (us_proc_vtp_t), GFP_ATOMIC);
 224
 225                         if (!copy_info->p_libs[i].p_vtps) {
 226                                 DPRINTF ("No enough memory for copy_info->p_libs[i].p_vtps");
 227                                 return NULL;
 228                         }
 229
 230                         memcpy (copy_info->p_libs[i].p_vtps, task_inst_info->p_libs[i].p_vtps,
 231                                         copy_info->p_libs[i].vtps_count * sizeof (us_proc_vtp_t));
 232                         for (j = 0; j < copy_info->p_libs[i].vtps_count; j++) {
 233                                 copy_info->p_libs[i].p_vtps[j].installed = 0;
 234                                 memset (&copy_info->p_libs[i].p_vtps[j].jprobe, 0, sizeof(struct jprobe));
 235                         }
 236                         unres_vtps_count = copy_info->p_libs[i].vtps_count;
 237                 }
 238
 239                 copy_info->p_libs[i].m_f_dentry = task_inst_info->p_libs[i].m_f_dentry;
 240                 copy_info->p_libs[i].loaded = 0;
 241
 242                 copy_info->p_libs[i].vma_start = 0;
 243                 copy_info->p_libs[i].vma_end = 0;
 244         }
 245         copy_info->unres_ips_count = unres_ips_count;
 246         copy_info->unres_vtps_count = unres_vtps_count;
 247
 248         return copy_info;
 249 }
 250
 251 inst_us_proc_t* get_task_inst_node(struct task_struct *task)
 252 {
 253         struct task_inst_info_node *node, *tnode;
 254
 255         list_for_each_entry_safe(node, tnode, &task_inst_info_list, plist)
 256         {
 257                 if (node && task && node->tgid == task->tgid) {
 258                         return node->task_inst_info;
 259                 }
 260         }
 261         return NULL;
 262 }
 263
 264 void put_task_inst_node(struct task_struct *task, inst_us_proc_t *task_inst_info)
 265 {
 266         struct task_inst_info_node * node;
 267
 268         node = kmalloc (sizeof(struct task_inst_info_node), GFP_ATOMIC);
 269
 270         node->tgid = task->tgid;
 271         node->task_inst_info = task_inst_info;
 272
 273         list_add_tail (&(node->plist), &task_inst_info_list);
 274 }
 275
 276
 277 void clear_task_inst_info(void)
 278 {
 279         struct list_head *node, *tmp;
 280
 281         list_for_each_safe(node, tmp, &task_inst_info_list)
 282                 list_del(node);
 283 }
 284
 285 #ifdef SLP_APP
 286 static int is_slp_app_with_dentry(struct vm_area_struct *vma,
 287                                                                   struct dentry *dentry)
 288 {
 289         struct vm_area_struct *slp_app_vma = NULL;
 290
 291         if (vma->vm_file->f_dentry == launchpad_daemon_dentry) {
 292                 slp_app_vma = vma;
 293                 while (slp_app_vma) {
 294                         if (slp_app_vma->vm_file) {
 295                                 if (slp_app_vma->vm_file->f_dentry == dentry &&
 296                                         slp_app_vma->vm_pgoff == 0) {
 297                                         return 1;
 298                                 }
 299                         }
 300                         slp_app_vma = slp_app_vma->vm_next;
 301                 }
 302         }
 303
 304         return 0;
 305 }
 306 #endif /* SLP_APP */
 307
 308 #ifdef ANDROID_APP
 309 static int is_android_app_with_dentry(struct vm_area_struct *vma,
 310                                                                           struct dentry *dentry)
 311 {
 312         struct vm_area_struct *android_app_vma = NULL;
 313
 314         if (vma->vm_file->f_dentry == app_process_dentry) {
 315                 android_app_vma = vma;
 316                 while (android_app_vma) {
 317                         if (android_app_vma->vm_file) {
 318                                 if (android_app_vma->vm_file->f_dentry == dentry) {
 319                                         android_app_vma_start = android_app_vma->vm_start;
 320                                         android_app_vma_end = android_app_vma->vm_end;
 321                                         return 1;
 322                                 }
 323                         }
 324                         android_app_vma = android_app_vma->vm_next;
 325                 }
 326         }
 327
 328         return 0;
 329 }
 330 #endif /* ANDROID_APP */
 331
 332 #ifdef __ANDROID
 333 void find_libdvm_for_task(struct task_struct *task, inst_us_proc_t *info)
 334 {
 335         struct vm_area_struct *vma = NULL;
 336         struct mm_struct *mm = NULL;
 337
 338         mm = get_task_mm(task);
 339         if (mm) {
 340                 vma = mm->mmap;
 341                 while (vma) {
 342                         if (vma->vm_file) {
 343                                 if (vma->vm_file->f_dentry == libdvm_dentry) {
 344                                         info->libdvm_start = vma->vm_start;
 345                                         info->libdvm_end = vma->vm_end;
 346                                         break;
 347                                 }
 348                         }
 349                         vma = vma->vm_next;
 350                 }
 351                 mmput(mm);
 352         }
 353 }
 354 #endif /* __ANDROID */
 355
 356 struct dentry *dentry_by_path(const char *path)
 357 {
 358         struct dentry *dentry;
 359 #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 38)
 360         struct path st_path;
 361         if (kern_path(path, LOOKUP_FOLLOW, &st_path) != 0) {
 362 #else /* LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 38) */
 363         struct nameidata nd;
 364         if (path_lookup(path, LOOKUP_FOLLOW, &nd) != 0) {
 365 #endif /* LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 38) */
 366                 EPRINTF("failed to lookup dentry for path %s!", path);
 367                 return NULL;
 368         }
 369
 370 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 25)
 371         dentry = nd.dentry;
 372         path_release(&nd);
 373 #elif LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 38)
 374         dentry = nd.path.dentry;
 375         path_put(&nd.path);
 376 #else /* LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 38) */
 377         dentry = st_path.dentry;
 378         path_put(&st_path);
 379 #endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 25) */
 380         return dentry;
 381 }
 382
 383 static int find_task_by_path (const char *path, struct task_struct **p_task, struct list_head *tids)
 384 {
 385         int found = 0;
 386         struct task_struct *task;
 387         struct vm_area_struct *vma;
 388         struct mm_struct *mm;
 389         struct dentry *dentry = dentry_by_path(path);
 390
 391         *p_task = 0;
 392
 393         /* find corresponding dir entry, this is also check for valid path */
 394         // TODO: test - try to instrument process with non-existing path
 395         // TODO: test - try to instrument process  with existing path and delete file just after start
 396         if (dentry == NULL) {
 397                 return -EINVAL;
 398         }
 399
 400         rcu_read_lock();
 401         for_each_process (task) {
 402
 403                 if  ( 0 != inst_pid && ( inst_pid != task->pid ) )
 404                         continue;
 405
 406                 mm = get_task_mm(task);
 407                 if (!mm)
 408                         continue;
 409                 vma = mm->mmap;
 410                 while (vma) {
 411                         if ((vma->vm_flags & VM_EXECUTABLE) && vma->vm_file) {
 412                                 if (vma->vm_file->f_dentry == dentry) {
 413                                         if (!*p_task) {
 414                                                 *p_task = task;
 415                                                 get_task_struct (task);
 416                                         }
 417                                                 //break;
 418                                 }
 419 #ifdef SLP_APP
 420                                 if (!*p_task) {
 421                                         if (is_slp_app_with_dentry(vma, dentry)) {
 422                                                 *p_task = task;
 423                                                 get_task_struct(task);
 424                                         }
 425                                 }
 426 #endif /* SLP_APP */
 427 #ifdef ANDROID_APP
 428                                 if (!*p_task) {
 429                                         if (is_android_app_with_dentry(vma, dentry)) {
 430                                                 *p_task = task;
 431                                                 get_task_struct(task);
 432                                         }
 433                                 }
 434 #endif /* ANDROID_APP */
 435                         }
 436                         vma = vma->vm_next;
 437                 }
 438                 // only decrement usage count on mm since we cannot sleep here
 439                 atomic_dec(&mm->mm_users);
 440                 if (found)
 441                         break;
 442         }
 443         rcu_read_unlock();
 444
 445         if (*p_task) {
 446                 DPRINTF ("found pid %d for %s.", (*p_task)->pid, path);
 447                 *p_task = (*p_task)->group_leader;
 448                 gl_nNotifyTgid = (*p_task)->tgid;
 449         } else {
 450                 DPRINTF ("pid for %s not found!", path);
 451         }
 452
 453         return 0;
 454 }
 455
 456
 457 static void us_vtp_event_pre_handler (us_proc_vtp_t * vtp, struct pt_regs *regs)
 458 {
 459         __get_cpu_var(gpVtp) = vtp;
 460         __get_cpu_var(gpCurVtpRegs) = regs;
 461 }
 462
 463 static void us_vtp_event_handler (unsigned long arg1, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5, unsigned long arg6)
 464 {
 465         us_proc_vtp_t *vtp = __get_cpu_var(gpVtp);
 466 #if !defined(CONFIG_X86)
 467         struct pt_regs *regs = __get_cpu_var(gpCurVtpRegs);
 468 #endif
 469         char fmt[4];
 470         unsigned long vaddr;
 471         long ival;
 472         char cval, *sval;
 473         us_proc_vtp_data_t *vtp_data;
 474 unsigned long ll;
 475         fmt[0] = 'p';
 476         fmt[3] = 0;
 477         fmt[2] = 's';
 478
 479         list_for_each_entry_rcu (vtp_data, &vtp->list, list) {
 480                 //              DPRINTF ("[%d]proc %s(%d): %lx", nCount++, current->comm, current->pid, vtp->addr);
 481                 fmt[1] = vtp_data->type;
 482                 if (vtp_data->reg == -1)
 483                         vaddr = vtp_data->off;
 484                 else
 485                         vaddr = ARCH_REG_VAL (regs, vtp_data->reg) + vtp_data->off;
 486                 //              DPRINTF ("VTP type '%c'", vtp_data->type);
 487                 switch (vtp_data->type)
 488                 {
 489                         case 'd':
 490                         case 'x':
 491                         case 'p':
 492                                 if (read_proc_vm_atomic (current, vaddr, &ival, sizeof (ival)) < sizeof (ival))
 493                                         EPRINTF ("failed to read vm of proc %s/%u addr %lu!", current->comm, current->pid, vaddr);
 494                                 else
 495                                         pack_event_info (VTP_PROBE_ID, RECORD_ENTRY, fmt, vtp->jprobe.kp.addr, ival, vtp_data->name);
 496                                 break;
 497                         case 'f':
 498                                 if (read_proc_vm_atomic (current, vaddr, &ival, sizeof (ival)) < sizeof (ival))
 499                                         EPRINTF ("failed to read vm of proc %s/%u addr %lu!", current->comm, current->pid, vaddr);
 500                                 else
 501                                         pack_event_info (VTP_PROBE_ID, RECORD_ENTRY, fmt, vtp->jprobe.kp.addr, ival, vtp_data->name);
 502                                 break;
 503                         case 'c':
 504                                 if (read_proc_vm_atomic (current, vaddr, &cval, sizeof (cval)) < sizeof (cval))
 505                                         EPRINTF ("failed to read vm of proc %s/%u addr %lu!", current->comm, current->pid, vaddr);
 506                                 else
 507                                         pack_event_info (VTP_PROBE_ID, RECORD_ENTRY, fmt, vtp->jprobe.kp.addr, cval, vtp_data->name);
 508                                 break;
 509                         case 's':
 510                                 if (current->active_mm) {
 511                                         struct page *page;
 512                                         struct vm_area_struct *vma;
 513                                         void *maddr;
 514                                         int len;
 515                                         if (get_user_pages_atomic (current, current->active_mm, vaddr, 1, 0, 1, &page, &vma) <= 0) {
 516                                                 EPRINTF ("get_user_pages_atomic failed for proc %s/%u addr %lu!", current->comm, current->pid, vaddr);
 517                                                 break;
 518                                         }
 519                                         maddr = kmap_atomic (page, KM_USER0);
 520                                         len = strlen (maddr + (vaddr & ~PAGE_MASK));
 521                                         sval = kmalloc (len + 1, GFP_KERNEL);
 522                                         if (!sval)
 523                                                 EPRINTF ("failed to alloc memory for string in proc %s/%u addr %lu!", current->comm, current->pid, vaddr);
 524                                         else {
 525                                                 copy_from_user_page (vma, page, vaddr, sval, maddr + (vaddr & ~PAGE_MASK), len + 1);
 526                                                 pack_event_info (VTP_PROBE_ID, RECORD_ENTRY, fmt, vtp->jprobe.kp.addr, sval,  vtp_data->name);
 527                                                 kfree (sval);
 528                                         }
 529                                         kunmap_atomic (maddr, KM_USER0);
 530                                         page_cache_release (page);
 531                                 }
 532                                 else
 533                                         EPRINTF ("task %s/%u has no mm!", current->comm, current->pid);
 534                                 break;
 535                         default:
 536                                 EPRINTF ("unknown variable type '%c'", vtp_data->type);
 537                 }
 538         }
 539         dbi_uprobe_return ();
 540 }
 541
 542 static int install_mapped_ips (struct task_struct *task, inst_us_proc_t* task_inst_info, int atomic)
 543 {
 544         struct vm_area_struct *vma;
 545         int i, k, err;
 546         unsigned long addr;
 547         unsigned int old_ips_count, old_vtps_count;
 548         us_proc_otg_ip_t *p;
 549         struct task_struct *t;
 550         struct mm_struct *mm;
 551
 552         mm = atomic ? task->active_mm : get_task_mm (task);
 553         if (!mm) {
 554                 return task_inst_info->unres_ips_count + task_inst_info->unres_vtps_count;
 555         }
 556         old_ips_count = task_inst_info->unres_ips_count;
 557         old_vtps_count = task_inst_info->unres_vtps_count;
 558         if(!atomic)
 559                 down_read (&mm->mmap_sem);
 560         vma = mm->mmap;
 561         while (vma) {
 562                 // skip non-text section
 563 #ifndef __ANDROID
 564                 if (vma->vm_pgoff != 0 || !(vma->vm_flags & VM_EXEC) || !vma->vm_file || (vma->vm_flags & VM_ACCOUNT) ||
 565                         !(vma->vm_flags & (VM_WRITE | VM_MAYWRITE)) ||
 566                         !(vma->vm_flags & (VM_READ | VM_MAYREAD))) {
 567 #else // __ANDROID
 568                 if (vma->vm_pgoff != 0 || !(vma->vm_flags & VM_EXEC) || !vma->vm_file) {
 569 #endif // __ANDROID
 570                         vma = vma->vm_next;
 571                         continue;
 572                 }
 573                 /**
 574                  * After process was forked, some time it inherits parent process environment.
 575                  * We need to renew instrumentation when we detect that process gets own environment.
 576                  */
 577                 for (i = 0; i < task_inst_info->libs_count; i++) {
 578 //                      struct path tmp_path;
 579 //                      tmp_path.dentry = task_inst_info->p_libs[i].m_f_dentry;
 580 //                      tmp_path.mnt = task_inst_info->p_libs[i].m_vfs_mount;
 581 //                      char* p_path = d_path ( &tmp_path, path_buffer, 255 );
 582 //                      DPRINTF("f_dentry:%x m_f_dentry:%x path:%s", vma->vm_file->f_dentry,
 583 //                              task_inst_info->p_libs[i].m_f_dentry, p_path );
 584
 585                         //TODO: test - try to instrument non-existing libs
 586                         if (vma->vm_file->f_dentry == task_inst_info->p_libs[i].m_f_dentry) {
 587 //                              DPRINTF("vm_flags:%x loaded:%x ips_count:%d vtps_count:%d",
 588 //                                              vma->vm_flags, task_inst_info->p_libs[i].loaded,
 589 //                                              task_inst_info->p_libs[i].ips_count, task_inst_info->p_libs[i].vtps_count );
 590                                 if (!task_inst_info->p_libs[i].loaded) {
 591 //                                      DPRINTF("!VM_EXECUTABLE && !loaded");
 592                                         char *p;
 593                                         int app_flag = (vma->vm_file->f_dentry == task_inst_info->m_f_dentry);
 594                                         DPRINTF ("post dyn lib event %s/%s", current->comm, task_inst_info->p_libs[i].path);
 595                                         // if we installed something, post library info for those IPs
 596                                         p = strrchr(task_inst_info->p_libs[i].path, '/');
 597                                         if(!p)
 598                                                 p = task_inst_info->p_libs[i].path;
 599                                         else
 600                                                 p++;
 601                                         task_inst_info->p_libs[i].loaded = 1;
 602                                         task_inst_info->p_libs[i].vma_start = vma->vm_start;
 603                                         task_inst_info->p_libs[i].vma_end = vma->vm_end;
 604                                         task_inst_info->p_libs[i].vma_flag = vma->vm_flags;
 605                                         pack_event_info (DYN_LIB_PROBE_ID, RECORD_ENTRY, "dspdd",
 606                                                         task->tgid, p, vma->vm_start, vma->vm_end-vma->vm_start, app_flag);
 607                                 }
 608                                 for (k = 0; k < task_inst_info->p_libs[i].ips_count; k++) {
 609                                         DPRINTF("ips_count current:%d", k);
 610                                         if (!task_inst_info->p_libs[i].p_ips[k].installed) {
 611                                                 DPRINTF("!installed");
 612                                                 addr = task_inst_info->p_libs[i].p_ips[k].offset;
 613                                                 addr += vma->vm_start;
 614                                                 if (page_present (mm, addr)) {
 615                                                         DPRINTF ("pid %d, %s sym is loaded at %lx/%lx.",
 616                                                                 task->pid, task_inst_info->p_libs[i].path,
 617                                                                 task_inst_info->p_libs[i].p_ips[k].offset, addr);
 618                                                         task_inst_info->p_libs[i].p_ips[k].jprobe.kp.addr = (kprobe_opcode_t *) addr;
 619                                                         task_inst_info->p_libs[i].p_ips[k].retprobe.kp.addr = (kprobe_opcode_t *) addr;
 620                                                         task_inst_info->p_libs[i].p_ips[k].installed = 1;
 621                                                         task_inst_info->unres_ips_count--;
 622                                                         err = register_usprobe (task, mm, &task_inst_info->p_libs[i].p_ips[k], atomic, 0);
 623                                                         if (err != 0) {
 624                                                                 DPRINTF ("failed to install IP at %lx/%p. Error %d!",
 625                                                                         task_inst_info->p_libs[i].p_ips[k].offset,
 626                                                                         task_inst_info->p_libs[i].p_ips[k].jprobe.kp.addr, err);
 627                                                         }
 628                                                 }
 629                                         }
 630                                 }
 631                                 for (k = 0; k < task_inst_info->p_libs[i].vtps_count; k++) {
 632                                         DPRINTF("vtps_count current:%d", k);
 633                                         if (!task_inst_info->p_libs[i].p_vtps[k].installed) {
 634                                                 DPRINTF("!installed");
 635                                                 addr = task_inst_info->p_libs[i].p_vtps[k].addr;
 636                                                 if (!(vma->vm_flags & VM_EXECUTABLE))
 637                                                         addr += vma->vm_start;
 638                                                 if (page_present (mm, addr)) {
 639                                                         DPRINTF ("pid %d, %s sym is loaded at %lx/%lx.",
 640                                                                 task->pid, task_inst_info->p_libs[i].path,
 641                                                                 task_inst_info->p_libs[i].p_ips[k].offset, addr);
 642                                                         task_inst_info->p_libs[i].p_vtps[k].jprobe.kp.tgid = task_inst_info->tgid;
 643                                                         task_inst_info->p_libs[i].p_vtps[k].jprobe.kp.addr = (kprobe_opcode_t *) addr;
 644                                                         task_inst_info->p_libs[i].p_vtps[k].jprobe.entry = (kprobe_opcode_t *) us_vtp_event_handler;
 645                                                         task_inst_info->p_libs[i].p_vtps[k].jprobe.pre_entry = (kprobe_pre_entry_handler_t) us_vtp_event_pre_handler;
 646                                                         task_inst_info->p_libs[i].p_vtps[k].jprobe.priv_arg = &task_inst_info->p_libs[i].p_vtps[k];
 647                                                         task_inst_info->p_libs[i].p_vtps[k].installed = 1;
 648                                                         task_inst_info->unres_vtps_count--;
 649                                                         err = dbi_register_ujprobe (task, mm, &task_inst_info->p_libs[i].p_vtps[k].jprobe, atomic);
 650                                                         if ( err != 0 ) {
 651                                                                 EPRINTF ("failed to install VTP at %p. Error %d!",
 652                                                                                 task_inst_info->p_libs[i].p_vtps[k].jprobe.kp.addr, err);
 653                                                         }
 654                                                 }
 655                                         }
 656                                 }
 657                         }
 658                 }
 659 #ifdef __ANDROID
 660                 if (is_java_inst_enabled()
 661                     && vma->vm_file->f_dentry == libdvm_dentry) {
 662                         us_proc_ip_t *entp = &task_inst_info->libdvm_entry_ip;
 663                         if (!entp->installed
 664                             && task_inst_info->libdvm_start) {
 665                                 unsigned long addr = LIBDVM_ENTRY + task_inst_info->libdvm_start;
 666                                 if (page_present(mm, addr)) {
 667                                         entp->jprobe.kp.tgid = task->tgid;
 668                                         entp->jprobe.pre_entry = ujprobe_event_pre_handler;
 669                                         entp->jprobe.entry = ujprobe_event_handler;
 670                                         entp->jprobe.priv_arg = entp;
 671                                         entp->jprobe.kp.addr = addr;
 672                                         entp->retprobe.kp.tgid = task->tgid;
 673                                         entp->retprobe.handler = uretprobe_event_handler;
 674                                         entp->retprobe.priv_arg = entp;
 675                                         entp->retprobe.kp.addr = addr;
 676                                         err = register_usprobe(task, mm, entp, atomic, 0);
 677                                         if (err != 0) {
 678                                                 DPRINTF("failed to install IP at %p", addr);
 679                                         }
 680                                 }
 681                                 entp->installed = 1;
 682                         }
 683                         us_proc_ip_t *retp = &task_inst_info->libdvm_return_ip;
 684                         if (!retp->installed
 685                             && task_inst_info->libdvm_start) {
 686                                 unsigned long addr = LIBDVM_RETURN + task_inst_info->libdvm_start;
 687                                 if (page_present(mm, addr)) {
 688                                         retp->jprobe.kp.tgid = task->tgid;
 689                                         retp->jprobe.pre_entry = ujprobe_event_pre_handler;
 690                                         retp->jprobe.entry = ujprobe_event_handler;
 691                                         retp->jprobe.priv_arg = retp;
 692                                         retp->jprobe.kp.addr = addr;
 693                                         retp->retprobe.kp.tgid = task->tgid;
 694                                         retp->retprobe.handler = uretprobe_event_handler;
 695                                         retp->retprobe.priv_arg = retp;
 696                                         retp->retprobe.kp.addr = addr;
 697                                         err = register_usprobe(task, mm, retp, atomic, 0);
 698                                         if (err != 0) {
 699                                                 DPRINTF("failed to install IP at %p", addr);
 700                                         }
 701                                 }
 702                                 retp->installed = 1;
 703                         }
 704                 }
 705 #endif /* __ANDROID */
 706                 vma = vma->vm_next;
 707         }
 708         list_for_each_entry_rcu (p, &otg_us_proc_info, list) {
 709                 if (p->ip.installed) {
 710                         continue;
 711                 }
 712
 713                 if (!page_present(mm, p->ip.offset)) {
 714                         DPRINTF("Page isn't present for %p.",
 715                                 p->ip.offset);
 716                         continue;
 717                 }
 718                 p->ip.installed = 1;
 719                 err = register_usprobe(task, mm, &p->ip, atomic, 0);
 720                 if (err != 0) {
 721                         DPRINTF("failed to install IP at %lx/%p. Error %d!",
 722                                 p->ip.offset,
 723                                 p->ip.jprobe.kp.addr, err);
 724                         continue;
 725                 }
 726                 task_inst_info->unres_otg_ips_count--;
 727         }
 728         if (!atomic) {
 729                 up_read (&mm->mmap_sem);
 730                 mmput (mm);
 731         }
 732         return task_inst_info->unres_ips_count + task_inst_info->unres_vtps_count;
 733 }
 734
 735 static int install_otg_ip(unsigned long addr,
 736                       unsigned long pre_handler,
 737                       unsigned long jp_handler,
 738                       unsigned long rp_handler)
 739 {
 740         int err;
 741         us_proc_otg_ip_t *pprobe;
 742         struct task_struct *task = current->group_leader;
 743         struct mm_struct *mm = task->mm;
 744
 745         /* Probe preparing */
 746         err = add_otg_probe_to_list(addr, &pprobe);
 747         if (err) {
 748                 if (err == 1) {
 749                         DPRINTF("OTG probe %p already installed.", addr);
 750                         return 0;
 751                 } else {
 752                         DPRINTF("Failed to add new OTG probe, err=%d",err);
 753                         return err;
 754                 }
 755         }
 756         if (pre_handler) {
 757                 pprobe->ip.jprobe.pre_entry =
 758                         (kprobe_pre_entry_handler_t)pre_handler;
 759         } else {
 760                 pprobe->ip.jprobe.pre_entry =
 761                         (kprobe_pre_entry_handler_t)
 762                         dbi_ujprobe_event_pre_handler_custom_p;
 763
 764         }
 765         if (jp_handler) {
 766                 pprobe->ip.jprobe.entry =
 767                         (kprobe_opcode_t *)jp_handler;
 768         } else {
 769                 pprobe->ip.jprobe.entry =
 770                         (kprobe_opcode_t *)
 771                         dbi_ujprobe_event_handler_custom_p;
 772         }
 773         if (rp_handler) {
 774                 pprobe->ip.retprobe.handler =
 775                         (kretprobe_handler_t)rp_handler;
 776         } else {
 777                 pprobe->ip.retprobe.handler =
 778                         (kretprobe_handler_t)
 779                         dbi_uretprobe_event_handler_custom_p;
 780         }
 781
 782         pprobe->tgid = task->tgid;
 783         if (!page_present(mm, addr)) {
 784                 DPRINTF("Page isn't present for %p.", addr);
 785
 786                 us_proc_info.unres_otg_ips_count++;
 787                 /* Probe will be installed in do_page_fault handler */
 788                 return 0;
 789         }
 790         DPRINTF("Page present for %p.", addr);
 791
 792         /* Probe installing */
 793         pprobe->ip.installed = 1;
 794         err = register_usprobe(current, mm, &pprobe->ip, 1, 0);
 795         if (err != 0) {
 796                 DPRINTF("failed to install IP at %lx/%p. Error %d!",
 797                          addr, pprobe->ip.jprobe.kp.addr, err);
 798                 return err;
 799         }
 800         return 0;
 801 }
 802 EXPORT_SYMBOL_GPL(install_otg_ip);
 803
 804
 805 static int uninstall_mapped_ips (struct task_struct *task,  inst_us_proc_t* task_inst_info, int atomic)
 806 {
 807         int i, k, err;
 808         us_proc_otg_ip_t *p;
 809
 810         for (i = 0; i < task_inst_info->libs_count; i++)
 811         {
 812                 DPRINTF ("clear lib %s.", task_inst_info->p_libs[i].path);
 813                 for (k = 0; k < task_inst_info->p_libs[i].ips_count; k++)
 814                 {
 815                         if (task_inst_info->p_libs[i].p_ips[k].installed)
 816                         {
 817                                 DPRINTF ("remove IP at %p.", task_inst_info->p_libs[i].p_ips[k].jprobe.kp.addr);
 818                                 err = unregister_usprobe (task, &task_inst_info->p_libs[i].p_ips[k], atomic);
 819                                 if (err != 0)
 820                                 {
 821                                         EPRINTF ("failed to uninstall IP at %p. Error %d!", task_inst_info->p_libs[i].p_ips[k].jprobe.kp.addr, err);
 822                                         continue;
 823                                 }
 824                                 task_inst_info->unres_ips_count++;
 825                                 task_inst_info->p_libs[i].p_ips[k].installed = 0;
 826                         }
 827                 }
 828                 for (k = 0; k < task_inst_info->p_libs[i].vtps_count; k++)
 829                 {
 830                         if (task_inst_info->p_libs[i].p_vtps[k].installed)
 831                         {
 832                                 dbi_unregister_ujprobe (task, &task_inst_info->p_libs[i].p_vtps[k].jprobe, atomic);
 833                                 task_inst_info->unres_vtps_count++;
 834                                 task_inst_info->p_libs[i].p_vtps[k].installed = 0;
 835                         }
 836                 }
 837                 task_inst_info->p_libs[i].loaded = 0;
 838         }
 839 #ifdef __ANDROID
 840         if (is_java_inst_enabled()) {
 841                 us_proc_ip_t *entp = &task_inst_info->libdvm_entry_ip;
 842                 if (entp->installed) {
 843                         unregister_usprobe(task, entp, atomic);
 844                         entp->installed = 0;
 845                 }
 846                 us_proc_ip_t *retp = &task_inst_info->libdvm_return_ip;
 847                 if (retp->installed) {
 848                         unregister_usprobe(task, retp, atomic);
 849                         retp->installed = 0;
 850                 }
 851         }
 852 #endif /* __ANDROID */
 853         list_for_each_entry_rcu (p, &otg_us_proc_info, list) {
 854                 if (!p->ip.installed) {
 855                         continue;
 856                 }
 857                 DPRINTF("remove OTG IP at %p.", p->ip.offset);
 858                 err = unregister_usprobe(task, &p->ip, atomic);
 859                 if (err != 0) {
 860                         EPRINTF("failed to uninstall IP at %p. Error %d!",
 861                                  p->ip.jprobe.kp.addr, err);
 862                         continue;
 863                 }
 864                 p->ip.installed = 0;
 865         }
 866
 867         DPRINTF ("Ures IPs  %d.", task_inst_info->unres_ips_count);
 868         DPRINTF ("Ures VTPs %d.", task_inst_info->unres_vtps_count);
 869         return 0;
 870 }
 871
 872 void send_sig_jprobe_event_handler (int sig, struct siginfo *info, struct task_struct *t, struct sigpending *signals)
 873 {
 874         int iRet, del = 0;
 875         struct task_struct *task;
 876         inst_us_proc_t *task_inst_info = NULL;
 877
 878         //if user-space instrumentation is not set
 879         if (!us_proc_info.path)
 880             return;
 881
 882         if (sig != SIGKILL)
 883                 return;
 884
 885         if (!strcmp(us_proc_info.path,"*"))
 886         {
 887                 task_inst_info = get_task_inst_node(t);
 888                 if (task_inst_info)
 889                 {
 890                         iRet = uninstall_mapped_ips (t, task_inst_info, 1);
 891                         if (iRet != 0)
 892                                 EPRINTF ("failed to uninstall IPs (%d)!", iRet);
 893                         dbi_unregister_all_uprobes(t, 1);
 894                         return;
 895                 }
 896         }
 897         else
 898         {
 899                 if (current->tgid != us_proc_info.tgid)
 900                         return;
 901                         del = 1;
 902
 903                 // look for another process with the same tgid
 904                 rcu_read_lock ();
 905                 for_each_process (task)
 906                 {
 907                         if ((task->pid != t->pid) && (task->tgid == us_proc_info.tgid))
 908                         {
 909                                 del = 0;
 910                                 break;
 911                         }
 912                 }
 913                 rcu_read_unlock ();
 914                 if (del)
 915                 {
 916                         DPRINTF ("%s(%d) send_signal SIGKILL for the last target proc %s(%d)",
 917                                         current->comm, current->pid, t->comm, t->pid);
 918                         iRet = uninstall_mapped_ips (t, &us_proc_info, 1);
 919                         if (iRet != 0)
 920                                 EPRINTF ("failed to uninstall IPs (%d)!", iRet);
 921                 }
 922         }
 923 }
 924 static int uninstall_kernel_probe (unsigned long addr, int uflag, int kflag, kernel_probe_t ** pprobe)
 925 {
 926         kernel_probe_t *probe = NULL;
 927         int iRet = 0;
 928         if (probes_flags & kflag) {
 929                 probe = find_probe(addr);
 930                 if (probe) {
 931                         iRet = remove_probe_from_list (addr);
 932                         if (iRet)
 933                                 EPRINTF ("remove_probe_from_list(0x%lx) result=%d!", addr, iRet);
 934                         if (pprobe)
 935                                 *pprobe = NULL;
 936                 }
 937                 probes_flags &= ~kflag;
 938         }
 939         if (us_proc_probes & uflag) {
 940                 if (!(probes_flags & uflag)) {
 941                         if (probe) {
 942                                 iRet = unregister_kernel_probe(probe);
 943                                 if (iRet) {
 944                                         EPRINTF ("unregister_kernel_probe(0x%lx) result=%d!",
 945                                                         addr, iRet);
 946                                         return iRet;
 947                                 }
 948                         }
 949                 }
 950                 us_proc_probes &= ~uflag;
 951         }
 952         return iRet;
 953 }
 954
 955 int deinst_usr_space_proc (void)
 956 {
 957         int iRet = 0, found = 0;
 958         struct task_struct *task = 0;
 959         inst_us_proc_t *task_inst_info = NULL;
 960
 961         //if user-space instrumentation is not set
 962         if (!us_proc_info.path)
 963                 return 0;
 964
 965         iRet = uninstall_kernel_probe (pf_addr, US_PROC_PF_INSTLD,
 966                         0, &pf_probe);
 967         if (iRet)
 968                 EPRINTF ("uninstall_kernel_probe(do_page_fault) result=%d!", iRet);
 969
 970         iRet = uninstall_kernel_probe (cp_addr, US_PROC_CP_INSTLD,
 971                         0, &cp_probe);
 972         if (iRet)
 973                 EPRINTF ("uninstall_kernel_probe(copy_process) result=%d!", iRet);
 974
 975         iRet = uninstall_kernel_probe (mr_addr, US_PROC_MR_INSTLD,
 976                         0, &mr_probe);
 977         if (iRet)
 978                 EPRINTF ("uninstall_kernel_probe(mm_release) result=%d!", iRet);
 979
 980         iRet = uninstall_kernel_probe (exit_addr, US_PROC_EXIT_INSTLD,
 981                         0, &exit_probe);
 982         if (iRet)
 983                 EPRINTF ("uninstall_kernel_probe(do_exit) result=%d!", iRet);
 984
 985         iRet = uninstall_kernel_probe (unmap_addr, US_PROC_UNMAP_INSTLD,
 986                         0, &unmap_probe);
 987         if (iRet)
 988                 EPRINTF ("uninstall_kernel_probe(do_munmap) result=%d!", iRet);
 989
 990         if (!strcmp(us_proc_info.path,"*"))
 991         {
 992                 for_each_process (task)
 993                 {
 994                         task_inst_info = get_task_inst_node(task);
 995                         if (task_inst_info)
 996                         {
 997                                 iRet = uninstall_mapped_ips (task, task_inst_info, 1);
 998                                 if (iRet != 0)
 999                                         EPRINTF ("failed to uninstall IPs (%d)!", iRet);
1000                                 dbi_unregister_all_uprobes(task, 1);
1001                         }
1002                 }
1003         }
1004         else
1005         {
1006                 if (us_proc_info.tgid == 0)
1007                         return 0;
1008                         rcu_read_lock ();
1009                 for_each_process (task)
1010                 {
1011                         if (task->tgid == us_proc_info.tgid)
1012                         {
1013                                 found = 1;
1014                                 get_task_struct (task);
1015                                 break;
1016                         }
1017                 }
1018                 rcu_read_unlock ();
1019                 if (found)
1020                 {
1021                         int i;
1022                         // uninstall IPs
1023                         iRet = uninstall_mapped_ips (task, &us_proc_info, 0);
1024                         if (iRet != 0)
1025                         EPRINTF ("failed to uninstall IPs %d!", iRet);
1026                         put_task_struct (task);
1027                         dbi_unregister_all_uprobes(task, 1);
1028                         us_proc_info.tgid = 0;
1029                         for(i = 0; i < us_proc_info.libs_count; i++)
1030                                 us_proc_info.p_libs[i].loaded = 0;
1031                 }
1032         }
1033
1034         return iRet;
1035 }
1036 static int install_kernel_probe (unsigned long addr, int uflag, int kflag, kernel_probe_t ** pprobe)
1037 {
1038         kernel_probe_t *probe = NULL;
1039         int iRet = 0;
1040
1041         DPRINTF("us_proc_probes = 0x%x, uflag = 0x%x, "
1042                         "probes_flags = 0x%x, kflag = 0x%x",
1043                         us_proc_probes, uflag, probes_flags, kflag);
1044
1045         if (!(probes_flags & kflag)) {
1046                 iRet = add_probe_to_list (addr, &probe);
1047                 if (iRet) {
1048                         EPRINTF ("add_probe_to_list(0x%lx) result=%d!", addr, iRet);
1049                         return iRet;
1050                 }
1051                 probes_flags |= kflag;
1052         }
1053         if (!(us_proc_probes & uflag)) {
1054                 if (!(probes_flags & uflag)) {
1055                         iRet = register_kernel_probe (probe);
1056                         if (iRet) {
1057                                 EPRINTF ("register_kernel_probe(0x%lx) result=%d!", addr, iRet);
1058                                 return iRet;
1059                         }
1060                 }
1061                 us_proc_probes |= uflag;
1062         }
1063
1064         if (probe)
1065                 *pprobe = probe;
1066
1067         return 0;
1068 }
1069
1070 int inst_usr_space_proc (void)
1071 {
1072         int ret, i;
1073         struct task_struct *task = 0;
1074         inst_us_proc_t *task_inst_info = NULL;
1075
1076         //if user-space instrumentation is not set
1077         if (!us_proc_info.path)
1078                 return 0;
1079
1080         DPRINTF("User space instr");
1081
1082 #ifdef SLP_APP
1083         launchpad_daemon_dentry = dentry_by_path("/usr/bin/launchpad_preloading_preinitializing_daemon");
1084         if (launchpad_daemon_dentry == NULL) {
1085                 return -EINVAL;
1086         }
1087
1088 #endif /* SLP_APP */
1089
1090 #ifdef ANDROID_APP
1091         app_process_dentry = dentry_by_path("/system/bin/app_process");
1092         if (app_process_dentry == NULL) {
1093                 return -EINVAL;
1094         }
1095
1096         android_app_vma_start = 0;
1097         android_app_vma_end = 0;
1098 #endif /* ANDROID_APP */
1099
1100 #ifdef __ANDROID
1101         if (is_java_inst_enabled()) {
1102                 libdvm_dentry = dentry_by_path("/system/lib/libdvm.so");
1103                 if (libdvm_dentry == NULL) {
1104                         return -EINVAL;
1105                 }
1106
1107                 memset(&us_proc_info.libdvm_entry_ip, 0, sizeof(us_proc_ip_t));
1108                 memset(&us_proc_info.libdvm_return_ip, 0, sizeof(us_proc_ip_t));
1109                 us_proc_info.libdvm_start = 0;
1110                 us_proc_info.libdvm_end = 0;
1111         }
1112 #endif /* __ANDROID */
1113
1114         for (i = 0; i < us_proc_info.libs_count; i++) {
1115                 us_proc_info.p_libs[i].loaded = 0;
1116         }
1117         /* check whether process is already running
1118          * 1) if process is running - look for the libraries in the process maps
1119          * 1.1) check if page for symbol does exist
1120          * 1.1.1) if page exists - instrument it
1121          * 1.1.2) if page does not exist - make sure that do_page_fault handler is installed
1122          * 2) if process is not running - make sure that do_page_fault handler is installed
1123          * */
1124
1125         if (!strcmp(us_proc_info.path,"*"))
1126         {
1127                 clear_task_inst_info();
1128                 for_each_process (task) {
1129                         if (task->flags & PF_KTHREAD){
1130                                 DPRINTF("ignored kernel thread %d\n",
1131                                         task->pid);
1132                                 continue;
1133                         }
1134
1135                         task_inst_info = get_task_inst_node(task);
1136                         if (!task_inst_info) {
1137                                 task_inst_info =
1138                                         copy_task_inst_info(task,
1139                                                             &us_proc_info);
1140                                 put_task_inst_node(task, task_inst_info);
1141                         }
1142                         DPRINTF("trying process");
1143 #ifdef __ANDROID
1144                         if (is_java_inst_enabled()) {
1145                                 find_libdvm_for_task(task, task_inst_info);
1146                         }
1147 #endif /* __ANDROID */
1148                         install_mapped_ips (task, task_inst_info, 1);
1149                         //put_task_struct (task);
1150                         task_inst_info = NULL;
1151                 }
1152         }
1153         else
1154         {
1155                 ret = find_task_by_path (us_proc_info.path, &task, NULL);
1156                 if ( task  )
1157                 {
1158                         DPRINTF("task found. installing probes");
1159                         us_proc_info.tgid = task->pid;
1160 #ifdef __ANDROID
1161                         if (is_java_inst_enabled()) {
1162                                 find_libdvm_for_task(task, &us_proc_info);
1163                         }
1164 #endif /* __ANDROID */
1165                         install_mapped_ips (task, &us_proc_info, 0);
1166                         put_task_struct (task);
1167                 }
1168         }
1169
1170         // enable 'do_page_fault' probe to detect when they will be loaded
1171         ret = install_kernel_probe (pf_addr, US_PROC_PF_INSTLD, 0, &pf_probe);
1172         if (ret != 0)
1173         {
1174                 EPRINTF ("install_kernel_probe(do_page_fault) result=%d!", ret);
1175                 return ret;
1176         }
1177         // enable 'do_exit' probe to detect for remove task_struct
1178         ret = install_kernel_probe (exit_addr, US_PROC_EXIT_INSTLD, 0, &exit_probe);
1179         if (ret != 0)
1180         {
1181                 EPRINTF ("install_kernel_probe(do_exit) result=%d!", ret);
1182                 return ret;
1183         }
1184         /* enable 'copy_process' */
1185         ret = install_kernel_probe (cp_addr, US_PROC_CP_INSTLD, 0, &cp_probe);
1186         if (ret != 0)
1187         {
1188                 EPRINTF ("instpall_kernel_probe(copy_process) result=%d!", ret);
1189                 return ret;
1190         }
1191
1192         // enable 'mm_release' probe to detect when for remove user space probes
1193         ret = install_kernel_probe (mr_addr, US_PROC_MR_INSTLD, 0, &mr_probe);
1194         if (ret != 0)
1195         {
1196                 EPRINTF ("install_kernel_probe(mm_release) result=%d!", ret);
1197                 return ret;
1198         }
1199
1200         // enable 'do_munmap' probe to detect when for remove user space probes
1201         ret = install_kernel_probe (unmap_addr, US_PROC_UNMAP_INSTLD, 0, &unmap_probe);
1202         if (ret != 0)
1203         {
1204                 EPRINTF ("install_kernel_probe(do_munmap) result=%d!", ret);
1205                 return ret;
1206         }
1207         return 0;
1208 }
1209
1210 void do_page_fault_ret_pre_code (void)
1211 {
1212         struct mm_struct *mm;
1213         struct vm_area_struct *vma = 0;
1214         inst_us_proc_t *task_inst_info = NULL;
1215         /*
1216          * Because process threads have same address space
1217          * we instrument only group_leader of all this threads
1218          */
1219         struct task_struct *task = current->group_leader;
1220
1221         //if user-space instrumentation is not set
1222         if (!us_proc_info.path)
1223                 return;
1224
1225         if (task->flags & PF_KTHREAD) {
1226                 DPRINTF("ignored kernel thread %d\n", task->pid);
1227                 return;
1228         }
1229
1230
1231         if (!strcmp(us_proc_info.path,"*"))
1232         {
1233                 task_inst_info = get_task_inst_node(task);
1234                 if (!task_inst_info)
1235                 {
1236                         task_inst_info = copy_task_inst_info(task,
1237                                                              &us_proc_info);
1238                         put_task_inst_node(task, task_inst_info);
1239 #ifdef __ANDROID
1240                         if (is_java_inst_enabled()) {
1241                                 find_libdvm_for_task(task, task_inst_info);
1242                         }
1243 #endif /* __ANDROID */
1244                 }
1245                 install_mapped_ips (task, task_inst_info, 1);
1246                 return;
1247         }
1248
1249         task_inst_info = &us_proc_info;
1250         //DPRINTF("do_page_fault from proc %d-%d-%d", current->pid, task_inst_info->tgid, task_inst_info->unres_ips_count);
1251         if (!is_java_inst_enabled()
1252             && (task_inst_info->unres_ips_count + task_inst_info->unres_vtps_count
1253                 + task_inst_info->unres_otg_ips_count) == 0)
1254         {
1255                 //DPRINTF("do_page_fault: there no unresolved IPs");
1256                 return;
1257         }
1258
1259         if (task_inst_info->tgid == 0)
1260         {
1261                 mm = task->active_mm;
1262                 if (mm)
1263                 {
1264 //                      down_read (&mm->mmap_sem);
1265                         vma = mm->mmap;
1266                         while (vma)
1267                         {
1268                                 if ((vma->vm_flags & VM_EXECUTABLE) && vma->vm_file)
1269                                 {
1270                                         if (vma->vm_file->f_dentry == task_inst_info->m_f_dentry)
1271                                         {
1272                                                 break;
1273                                         }
1274 #ifdef SLP_APP
1275                                         if (is_slp_app_with_dentry(vma, task_inst_info->m_f_dentry)) {
1276                                                 break;
1277                                         }
1278 #endif /* SLP_APP */
1279 #ifdef ANDROID_APP
1280                                         if (is_android_app_with_dentry(vma, task_inst_info->m_f_dentry)) {
1281                                                 break;
1282                                         }
1283 #endif /* ANDROID_APP */
1284                                 }
1285                                 vma = vma->vm_next;
1286                         }
1287 //                      up_read (&mm->mmap_sem);
1288 //                      mmput (mm);
1289                 } else {
1290                         //                      DPRINTF ("proc %s/%d has no mm", current->comm, current->pid);
1291                 }
1292                 if (vma)
1293                 {
1294                      DPRINTF ("do_page_fault found target proc %s(%d)", task->comm, task->pid);
1295                      task_inst_info->tgid = task->pid;
1296                      gl_nNotifyTgid = task->tgid;
1297                 }
1298         }
1299         if (task_inst_info->tgid == task->tgid)
1300         {
1301                 //DPRINTF("do_page_fault from target proc %d", task_inst_info->tgid);
1302 #ifdef __ANDROID
1303                 if (is_java_inst_enabled()) {
1304                         find_libdvm_for_task(task, &us_proc_info);
1305                 }
1306 #endif /* __ANDROID */
1307                 install_mapped_ips (task, &us_proc_info, 1);
1308         }
1309         //DPRINTF("do_page_fault from proc %d-%d exit", task->pid, task_inst_info->pid);
1310 }
1311
1312 EXPORT_SYMBOL_GPL(do_page_fault_ret_pre_code);
1313
1314
1315 void do_exit_probe_pre_code (void)
1316 {
1317         // TODO: remove task
1318 }
1319 EXPORT_SYMBOL_GPL(do_exit_probe_pre_code);
1320
1321 static int check_addr(unsigned long addr, unsigned long start, size_t len)
1322 {
1323         if ((addr >= start) && (addr < start + (unsigned long)len)) {
1324                 return 1;
1325         }
1326
1327         return 0;
1328 }
1329
1330 static int remove_unmap_probes(struct task_struct *task, inst_us_proc_t* task_inst_info, unsigned long start, size_t len)
1331 {
1332         int i, k, err;
1333         us_proc_otg_ip_t *p;
1334         unsigned long addr;
1335         const int atomic = 1;
1336
1337         for (i = 0; i < task_inst_info->libs_count; ++i) {
1338                 for (k = 0; k < task_inst_info->p_libs[i].ips_count; ++k) {
1339                         if (task_inst_info->p_libs[i].p_ips[k].installed) {
1340                                 addr = task_inst_info->p_libs[i].p_ips[k].jprobe.kp.addr;
1341                                 if (check_addr(addr, start, len)) {
1342                                         err = unregister_usprobe(task, &task_inst_info->p_libs[i].p_ips[k], atomic);
1343                                         if (err != 0) {
1344                                                 EPRINTF("failed to uninstall IP at %p. Error %d!", task_inst_info->p_libs[i].p_ips[k].jprobe.kp.addr, err);
1345                                                 continue;
1346                                         }
1347                                         task_inst_info->unres_ips_count++;
1348                                         task_inst_info->p_libs[i].p_ips[k].installed = 0;
1349                                 }
1350                         }
1351                 }
1352                 for (k = 0; k < task_inst_info->p_libs[i].vtps_count; ++k) {
1353                         if (task_inst_info->p_libs[i].p_vtps[k].installed) {
1354                                 addr = task_inst_info->p_libs[i].p_vtps[k].jprobe.kp.addr;
1355                                 if (check_addr(addr, start, len)) {
1356                                         dbi_unregister_ujprobe(task, &task_inst_info->p_libs[i].p_vtps[k].jprobe, atomic);
1357                                         task_inst_info->unres_vtps_count++;
1358                                         task_inst_info->p_libs[i].p_vtps[k].installed = 0;
1359                                 }
1360                         }
1361                 }
1362         }
1363 #ifdef __ANDROID
1364         if (is_java_inst_enabled()) {
1365                 us_proc_ip_t *entp = &task_inst_info->libdvm_entry_ip;
1366                 if (entp->installed) {
1367                         addr = entp->jprobe.kp.addr;
1368                         if (check_addr(addr, start, len)) {
1369                                 unregister_usprobe(task, entp, atomic);
1370                                 entp->installed = 0;
1371                         }
1372                 }
1373                 us_proc_ip_t *retp = &task_inst_info->libdvm_return_ip;
1374                 if (retp->installed) {
1375                         addr = retp->jprobe.kp.addr;
1376                         if (check_addr(addr, start, len)) {
1377                                 unregister_usprobe(task, retp, atomic);
1378                                 retp->installed = 0;
1379                         }
1380                 }
1381         }
1382 #endif /* __ANDROID */
1383
1384         // remove OTG-probes
1385         list_for_each_entry_rcu (p, &otg_us_proc_info, list) {
1386                 if (!p->ip.installed) {
1387                         continue;
1388                 }
1389
1390                 addr = p->ip.jprobe.kp.addr;
1391                 if (check_addr(addr, start, len) == 0) {
1392                         continue;
1393                 }
1394
1395                 err = unregister_usprobe(task, &p->ip, atomic);
1396                 if (err != 0) {
1397                         EPRINTF("failed to uninstall IP at %p. Error %d!",
1398                                  p->ip.jprobe.kp.addr, err);
1399                         continue;
1400                 }
1401                 p->ip.installed = 0;
1402                 remove_otg_probe_from_list(p->ip.offset);
1403         }
1404
1405         return 0;
1406 }
1407
1408 void do_munmap_probe_pre_code(struct mm_struct *mm, unsigned long start, size_t len)
1409 {
1410         inst_us_proc_t *task_inst_info = NULL;
1411         struct task_struct *task = current;
1412
1413         //if user-space instrumentation is not set
1414         if (!us_proc_info.path || task->tgid != task->pid)
1415                 return;
1416
1417         if (!strcmp(us_proc_info.path,"*")) {
1418                 task_inst_info = get_task_inst_node(task);
1419         } else {
1420                 if (task->tgid == us_proc_info.tgid) {
1421                         task_inst_info = &us_proc_info;
1422                 }
1423         }
1424
1425         if (task_inst_info) {
1426                 remove_unmap_probes(task, task_inst_info, start, len);
1427         }
1428 }
1429 EXPORT_SYMBOL_GPL(do_munmap_probe_pre_code);
1430
1431 void mm_release_probe_pre_code(void)
1432 {
1433         int iRet, del = 0;
1434         struct task_struct *task;
1435         inst_us_proc_t *task_inst_info = NULL;
1436
1437         //if user-space instrumentation is not set
1438         if (!us_proc_info.path || current->tgid != current->pid)
1439                 return;
1440
1441         if (!strcmp(us_proc_info.path,"*"))
1442         {
1443                 task_inst_info = get_task_inst_node(current);
1444                 if (task_inst_info)
1445                 {
1446                         iRet = uninstall_mapped_ips (current, task_inst_info, 1);
1447                         if (iRet != 0)
1448                                 EPRINTF ("failed to uninstall IPs (%d)!", iRet);
1449                         dbi_unregister_all_uprobes(current, 1);
1450                 }
1451         }
1452         else
1453         {
1454                 if (current->tgid != us_proc_info.tgid)
1455                         return;
1456                         del = 1;
1457                 // look for another process with the same tgid
1458                 rcu_read_lock ();
1459                 for_each_process (task)
1460                 {
1461                         if ((task->pid != current->pid) && (task->tgid == us_proc_info.tgid))
1462                         {
1463                                 del = 0;
1464                                 break;
1465                         }
1466                 }
1467                 rcu_read_unlock ();
1468                 if (del)
1469                 {
1470                         int i;
1471                         iRet = uninstall_mapped_ips (current, &us_proc_info, 1);
1472                         if (iRet != 0)
1473                                 EPRINTF ("failed to uninstall IPs (%d)!", iRet);
1474                         dbi_unregister_all_uprobes(current, 1);
1475                         us_proc_info.tgid = 0;
1476                         for(i = 0; i < us_proc_info.libs_count; i++)
1477                                 us_proc_info.p_libs[i].loaded = 0;
1478                 }
1479         }
1480 }
1481 EXPORT_SYMBOL_GPL(mm_release_probe_pre_code);
1482
1483
1484 static void recover_child(struct task_struct *child_task, inst_us_proc_t *parent_iup)
1485 {
1486         int i, k;
1487         for(i = 0; i < parent_iup->libs_count; ++i)
1488         {
1489                 for(k = 0; k < parent_iup->p_libs[i].ips_count; ++k)
1490                         if(parent_iup->p_libs[i].p_ips[k].installed)
1491                                 arch_disarm_uprobe(&parent_iup->p_libs[i].p_ips[k].jprobe.kp, child_task);
1492
1493                 for(k = 0; k < parent_iup->p_libs[i].vtps_count; ++k)
1494                         if(parent_iup->p_libs[i].p_vtps[k].installed)
1495                                 arch_disarm_uprobe(&parent_iup->p_libs[i].p_vtps[k].jprobe.kp, child_task);
1496         }
1497 }
1498
1499 static void rm_uprobes_child(struct task_struct *new_task)
1500 {
1501         if(!strcmp(us_proc_info.path, "*")) {
1502                 inst_us_proc_t *task_inst_info = get_task_inst_node(current);
1503                 if(task_inst_info)
1504                         recover_child(new_task, task_inst_info);
1505         } else {
1506                 if(us_proc_info.tgid == current->tgid) {
1507                         recover_child(new_task, &us_proc_info);
1508                 }
1509         }
1510 }
1511
1512 void copy_process_ret_pre_code(struct task_struct *p)
1513 {
1514         if(!p || IS_ERR(p))
1515                 return;
1516
1517         if(p->mm != current->mm)    // check flags CLONE_VM
1518                 rm_uprobes_child(p);
1519 }
1520
1521
1522 DEFINE_PER_CPU (us_proc_ip_t *, gpCurIp) = NULL;
1523 EXPORT_PER_CPU_SYMBOL_GPL(gpCurIp);
1524 DEFINE_PER_CPU(struct pt_regs *, gpUserRegs) = NULL;
1525 EXPORT_PER_CPU_SYMBOL_GPL(gpUserRegs);
1526
1527
1528 unsigned long ujprobe_event_pre_handler (us_proc_ip_t * ip, struct pt_regs *regs)
1529 {
1530         __get_cpu_var (gpCurIp) = ip;
1531         __get_cpu_var (gpUserRegs) = regs;
1532         return 0;
1533 }
1534
1535 #ifdef __ANDROID
1536 int handle_java_event(unsigned long addr)
1537 {
1538         unsigned long start = 0;
1539         struct pt_regs *regs = __get_cpu_var(gpUserRegs);
1540
1541         if (!strcmp(us_proc_info.path, "*")) {
1542                 /* TODO: some stuff here */
1543         } else {
1544                 start = us_proc_info.libdvm_start;
1545         }
1546         unsigned long end = us_proc_info.libdvm_end;
1547
1548         if (addr == start + LIBDVM_ENTRY) {
1549                 unsigned long *p_met = (unsigned long *)regs->ARM_r0;
1550                 char *met_name = p_met ? (char *)(p_met[4]) : 0;
1551                 unsigned long *p_cl = p_met ? (unsigned long *)p_met[0] : 0;
1552                 char *cl_name = p_cl ? (char *)(p_cl[6]) : 0;
1553                 if (!cl_name || !met_name) {
1554                         EPRINTF("warn: class name or method name null\n");
1555                 } else {
1556                         pack_event_info(JAVA_PROBE_ID, RECORD_ENTRY, "pss", addr, cl_name, met_name);
1557                 }
1558                 dbi_uprobe_return ();
1559                 return 1;
1560         }
1561
1562         if (addr == start + LIBDVM_RETURN) {
1563                 unsigned long *p_th = (unsigned long *)regs->ARM_r6;
1564                 unsigned long *p_st = p_th;
1565                 unsigned long *p_met = p_st ? (unsigned long *)p_st[2] : 0;
1566                 char *met_name = p_met ? (char *)(p_met[4]) : 0;
1567                 unsigned long *p_cl = p_met ? (unsigned long *)p_met[0] : 0;
1568                 char *cl_name = p_cl ? (char *)(p_cl[6]) : 0;
1569                 if (!cl_name || !met_name) {
1570                         EPRINTF("warn: class name or method name null\n");
1571                 } else {
1572                         pack_event_info(JAVA_PROBE_ID, RECORD_RET, "pss", addr, cl_name, met_name);
1573                 }
1574                 dbi_uprobe_return ();
1575                 return 1;
1576         }
1577
1578         return 0;
1579 }
1580 #endif /* __ANDROID */
1581
1582 void ujprobe_event_handler (unsigned long arg1, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5, unsigned long arg6)
1583 {
1584         us_proc_ip_t *ip = __get_cpu_var (gpCurIp);
1585         unsigned long addr = (unsigned long)ip->jprobe.kp.addr;
1586
1587 #ifdef __ANDROID
1588         if (is_java_inst_enabled() && handle_java_event(addr)) {
1589                 return;
1590         }
1591 #endif /* __ANDROID */
1592
1593
1594 #if defined(CONFIG_ARM)
1595         if (ip->offset & 0x01)
1596         {
1597                 pack_event_info (US_PROBE_ID, RECORD_ENTRY, "ppppppp", addr | 0x01, arg1, arg2, arg3, arg4, arg5, arg6);
1598         }else{
1599                 pack_event_info (US_PROBE_ID, RECORD_ENTRY, "ppppppp", addr, arg1, arg2, arg3, arg4, arg5, arg6);
1600         }
1601 #else
1602         pack_event_info (US_PROBE_ID, RECORD_ENTRY, "ppppppp", addr, arg1, arg2, arg3, arg4, arg5, arg6);
1603 #endif
1604         // Mr_Nobody: uncomment for valencia
1605         //unregister_usprobe(current, ip, 1);
1606         dbi_uprobe_return ();
1607 }
1608
1609 void find_plt_address(unsigned long addr)
1610 {
1611         inst_us_proc_t *task_inst_info = NULL;
1612         int i;
1613         unsigned real_addr;
1614         struct vm_area_struct *vma;
1615         us_proc_lib_t *p_lib = NULL;
1616         char *szLibPath = NULL;
1617
1618         // Search for library structure to check whether this function plt or not
1619         if (strcmp(us_proc_info.path, "*")){
1620         // If app lib instrumentation
1621                 task_inst_info = &us_proc_info;
1622         } else {
1623         // If lib only instrumentation
1624                 task_inst_info = get_task_inst_node(current);
1625         }
1626         if ((task_inst_info != NULL) && (task_inst_info->is_plt != 0)) {
1627                 for (i = 0; i < task_inst_info->libs_count; i++)
1628                 {
1629                         if ((task_inst_info->p_libs[i].loaded)
1630                                 && (task_inst_info->p_libs[i].plt_count > 0)
1631                                 && (addr > task_inst_info->p_libs[i].vma_start)
1632                                 && (addr < task_inst_info->p_libs[i].vma_end))
1633                         {
1634                                 p_lib = &(task_inst_info->p_libs[i]);
1635                                 break;
1636                         }
1637                 }
1638                 if (p_lib != NULL) {
1639                         for (i = 0; i < p_lib->plt_count; i++)
1640                         {
1641                                 if (addr == p_lib->p_plt[i].func_addr + p_lib->vma_start) {
1642                                         unsigned long real_got;
1643                                         if (p_lib->vma_flag & VM_EXECUTABLE) {
1644                                                 real_got = p_lib->p_plt[i].got_addr;
1645                                         } else {
1646                                                 real_got = p_lib->p_plt[i].got_addr + p_lib->vma_start;
1647                                         }
1648                                         if (!read_proc_vm_atomic(current, (unsigned long)(real_got), &real_addr, sizeof(unsigned long))) {
1649                                                 printk("Failed to read got %p at memory address %p!\n", p_lib->p_plt[i].got_addr, real_got);
1650                                                 return;
1651                                         }
1652                                         if (real_addr != p_lib->p_plt[i].real_func_addr) {
1653                                                 p_lib->p_plt[i].real_func_addr =  real_addr;
1654                                                 vma = find_vma(current->mm, real_addr);
1655                                                 if ((vma != NULL) && (vma->vm_start <= real_addr) && (vma->vm_end > real_addr)) {
1656                                                         if (vma->vm_file != NULL) {
1657                                                                 szLibPath = &(vma->vm_file->f_dentry->d_iname);
1658                                                         }
1659                                                 } else {
1660                                                         printk("Failed to get vma, includes %x address\n", real_addr);
1661                                                         return;
1662                                                 }
1663                                                 if (szLibPath) {
1664                                                         pack_event_info(PLT_ADDR_PROBE_ID, RECORD_RET, "ppsp", addr, real_addr, szLibPath, real_addr - vma->vm_start);
1665                                                         return;
1666                                                 } else {
1667                                                         pack_event_info(PLT_ADDR_PROBE_ID, RECORD_RET, "ppp", addr, real_addr, real_addr - vma->vm_start);
1668                                                         return;
1669                                                 }
1670                                         } else {
1671                                                 return;
1672                                         }
1673                                 }
1674                         }
1675                 }
1676         }
1677 }
1678
1679 int uretprobe_event_handler (struct kretprobe_instance *probe, struct pt_regs *regs, us_proc_ip_t * ip)
1680 {
1681         int retval = regs_return_value(regs);
1682         unsigned long addr = (unsigned long)ip->jprobe.kp.addr;
1683
1684         find_plt_address(addr);
1685
1686 #if defined(CONFIG_ARM)
1687         if (ip->offset & 0x01)
1688         {
1689                 pack_event_info (US_PROBE_ID, RECORD_RET, "pd", addr | 0x01, retval);
1690         }else{
1691                 pack_event_info (US_PROBE_ID, RECORD_RET, "pd", addr, retval);
1692         }
1693 #else
1694         pack_event_info (US_PROBE_ID, RECORD_RET, "pd", addr, retval);
1695 #endif
1696         // Mr_Nobody: uncomment for valencia
1697         //unregister_usprobe(current, ip, 1);
1698         return 0;
1699 }
1700
1701 static int register_usprobe (struct task_struct *task, struct mm_struct *mm, us_proc_ip_t * ip, int atomic, kprobe_opcode_t * islot)
1702 {
1703         int ret = 0;
1704         ip->jprobe.kp.tgid = task->tgid;
1705         //ip->jprobe.kp.addr = (kprobe_opcode_t *) addr;
1706         if(!ip->jprobe.entry) {
1707                 if (dbi_ujprobe_event_handler_custom_p != NULL)
1708                 {
1709                         ip->jprobe.entry = (kprobe_opcode_t *) dbi_ujprobe_event_handler_custom_p;
1710                         DPRINTF("Set custom event handler for %x\n", ip->offset);
1711                 }
1712                 else
1713                 {
1714                         ip->jprobe.entry = (kprobe_opcode_t *) ujprobe_event_handler;
1715                         DPRINTF("Set default event handler for %x\n", ip->offset);
1716                 }
1717         }
1718         if(!ip->jprobe.pre_entry) {
1719                 if (dbi_ujprobe_event_pre_handler_custom_p != NULL)
1720                 {
1721                         ip->jprobe.pre_entry = (kprobe_pre_entry_handler_t) dbi_ujprobe_event_pre_handler_custom_p;
1722                         DPRINTF("Set custom pre handler for %x\n", ip->offset);
1723                 }
1724                 else
1725                 {
1726                         ip->jprobe.pre_entry = (kprobe_pre_entry_handler_t) ujprobe_event_pre_handler;
1727                         DPRINTF("Set default pre handler for %x\n", ip->offset);
1728                 }
1729         }
1730         ip->jprobe.priv_arg = ip;
1731         ret = dbi_register_ujprobe (task, mm, &ip->jprobe, atomic);
1732         if (ret)
1733         {
1734                 DPRINTF ("dbi_register_ujprobe() failure %d", ret);
1735                 return ret;
1736         }
1737
1738         // Mr_Nobody: comment for valencia
1739         ip->retprobe.kp.tgid = task->tgid;
1740         //ip->retprobe.kp.addr = (kprobe_opcode_t *) addr;
1741         if(!ip->retprobe.handler) {
1742                 if (dbi_uretprobe_event_handler_custom_p != NULL)
1743                         ip->retprobe.handler = (kretprobe_handler_t) dbi_uretprobe_event_handler_custom_p;
1744                 else {
1745                         ip->retprobe.handler = (kretprobe_handler_t) uretprobe_event_handler;
1746                         //DPRINTF("Failed custom dbi_uretprobe_event_handler_custom_p");
1747                 }
1748         }
1749         ip->retprobe.priv_arg = ip;
1750         ret = dbi_register_uretprobe (task, mm, &ip->retprobe, atomic);
1751         if (ret)
1752         {
1753                 EPRINTF ("dbi_register_uretprobe() failure %d", ret);
1754                 return ret;
1755         }
1756         return 0;
1757 }
1758
1759 static int unregister_usprobe (struct task_struct *task, us_proc_ip_t * ip, int atomic)
1760 {
1761         dbi_unregister_ujprobe (task, &ip->jprobe, atomic);
1762         dbi_unregister_uretprobe (task, &ip->retprobe, atomic);
1763         return 0;
1764 }
1765
1766 unsigned long get_stack_size(struct task_struct *task,
1767                 struct pt_regs *regs)
1768 {
1769 #ifdef CONFIG_ADD_THREAD_STACK_INFO
1770         return (task->stack_start - dbi_get_stack_ptr(regs));
1771 #else
1772         struct vm_area_struct *vma = NULL;
1773         struct mm_struct *mm = NULL;
1774         unsigned long result = 0;
1775     int atomic = in_atomic();
1776
1777         mm = (atomic ? task->active_mm: get_task_mm(task));
1778
1779         if (mm) {
1780                 if (!atomic)
1781                         down_read(&mm->mmap_sem);
1782
1783                 vma = find_vma(mm, dbi_get_stack_ptr(regs));
1784
1785                 if (vma)
1786                         result = vma->vm_end - dbi_get_stack_ptr(regs);
1787                 else
1788                         result = 0;
1789
1790                 if (!atomic) {
1791                         up_read(&mm->mmap_sem);
1792                         mmput(mm);
1793                 }
1794         }
1795
1796         return result;
1797 #endif
1798 }
1799 EXPORT_SYMBOL_GPL(get_stack_size);
1800
1801 unsigned long get_stack(struct task_struct *task, struct pt_regs *regs,
1802                 char *buf, unsigned long sz)
1803 {
1804         unsigned long stack_sz = get_stack_size(task, regs);
1805         unsigned long real_sz = (stack_sz > sz ? sz: stack_sz);
1806         int res = read_proc_vm_atomic(task, dbi_get_stack_ptr(regs), buf, real_sz);
1807         return res;
1808 }
1809 EXPORT_SYMBOL_GPL(get_stack);
1810
1811 int dump_to_trace(probe_id_t probe_id, void *addr, const char *buf,
1812                 unsigned long sz)
1813 {
1814         unsigned long rest_sz = sz;
1815         const char *data = buf;
1816
1817         while (rest_sz >= EVENT_MAX_SIZE) {
1818                 pack_event_info(probe_id, RECORD_ENTRY, "pa",
1819                                 addr, EVENT_MAX_SIZE, data);
1820                 rest_sz -= EVENT_MAX_SIZE;
1821                 data += EVENT_MAX_SIZE;
1822         }
1823
1824         if (rest_sz > 0)
1825                 pack_event_info(probe_id, RECORD_ENTRY, "pa", addr, rest_sz, data);
1826
1827         return 0;
1828 }
1829 EXPORT_SYMBOL_GPL(dump_to_trace);
1830
1831 int dump_backtrace(probe_id_t probe_id, struct task_struct *task,
1832                 void *addr, struct pt_regs *regs, unsigned long sz)
1833 {
1834         unsigned long real_sz = 0;
1835         char *buf = NULL;
1836
1837         buf = (char *)kmalloc(sz, GFP_ATOMIC);
1838
1839         if (buf != NULL) {
1840                 real_sz = get_stack(task, regs, buf, sz);
1841                 if (real_sz > 0)
1842                         dump_to_trace(probe_id, addr, buf, real_sz);
1843                 kfree(buf);
1844                 return 0;
1845         } else {
1846                 return -1;
1847         }
1848 }
1849 EXPORT_SYMBOL_GPL(dump_backtrace);
1850
1851 unsigned long get_ret_addr(struct task_struct *task, us_proc_ip_t *ip)
1852 {
1853         unsigned long retaddr = 0;
1854         struct hlist_node *item, *tmp_node;
1855         struct kretprobe_instance *ri;
1856
1857         if (ip) {
1858                 hlist_for_each_safe (item, tmp_node, &ip->retprobe.used_instances) {
1859                         ri = hlist_entry (item, struct kretprobe_instance, uflist);
1860
1861                         if (ri->task && ri->task->pid == task->pid &&
1862                                         ri->task->tgid == task->tgid)
1863                                 retaddr = (unsigned long)ri->ret_addr;
1864                 }
1865         }
1866
1867         if (retaddr)
1868                 return retaddr;
1869         else
1870                 return dbi_get_ret_addr(task_pt_regs(task));
1871 }
1872 EXPORT_SYMBOL_GPL(get_ret_addr);
1873