1 ////////////////////////////////////////////////////////////////////////////////////
3 // FILE: us_proc_inst.c
6 // This file is C source for SWAP driver.
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
14 // REVISION DATE: 2008.12.02
16 ////////////////////////////////////////////////////////////////////////////////////
19 #include "us_proc_inst.h"
21 #include "../kprobe/dbi_kprobes_deps.h"
22 #include "../kprobe/dbi_uprobes.h"
24 DEFINE_PER_CPU (us_proc_vtp_t *, gpVtp) = NULL;
25 DEFINE_PER_CPU (struct pt_regs *, gpCurVtpRegs) = NULL;
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]
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!!!
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);
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);
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);
54 struct task_inst_info_node {
55 struct list_head plist;
56 inst_us_proc_t * task_inst_info;
59 LIST_HEAD(task_inst_info_list);
62 struct dentry *launchpad_daemon_dentry = NULL;
63 EXPORT_SYMBOL_GPL(launchpad_daemon_dentry);
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 */
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 */
80 us_proc_otg_ip_t *find_otg_probe(unsigned long addr)
84 list_for_each_entry_rcu (p, &otg_us_proc_info, list) {
85 if (p->ip.offset == addr) {
93 int add_otg_probe_to_list(unsigned long addr, us_proc_otg_ip_t **pprobe)
95 us_proc_otg_ip_t *new_probe;
96 us_proc_otg_ip_t *probe;
101 /* check if such probe does already exist */
102 probe = find_otg_probe(addr);
107 new_probe = kmalloc(sizeof(us_proc_otg_ip_t), GFP_KERNEL);
109 EPRINTF ("no memory for new probe!");
112 memset(new_probe,0, sizeof(us_proc_otg_ip_t));
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;
120 INIT_LIST_HEAD(&new_probe->list);
121 list_add_rcu(&new_probe->list, &otg_us_proc_info);
129 int remove_otg_probe_from_list(unsigned long addr)
133 //check if such probe does exist
134 p = find_otg_probe(addr);
136 /* We do not care about it. Nothing bad. */
140 list_del_rcu(&p->list);
148 * Prepare copy of instrumentation data for task
149 * in case of library only instrumentation
152 inst_us_proc_t* copy_task_inst_info (struct task_struct *task, inst_us_proc_t * task_inst_info)
155 kprobe_opcode_t *entry_save;
156 kprobe_pre_entry_handler_t pre_entry_save;
157 kretprobe_handler_t handler_save;
159 inst_us_proc_t* copy_info = 0;
161 int unres_ips_count = 0, unres_vtps_count = 0;
163 copy_info = kmalloc (sizeof (inst_us_proc_t), GFP_ATOMIC);
164 memset ((void *) copy_info, 0, sizeof (inst_us_proc_t));
166 copy_info->path = task_inst_info->path;
167 copy_info->m_f_dentry = NULL;
169 copy_info->libs_count = task_inst_info->libs_count;
171 kmalloc (task_inst_info->libs_count * sizeof (us_proc_lib_t), GFP_ATOMIC);
173 if (!copy_info->p_libs) {
174 DPRINTF ("No enough memory for copy_info->p_libs");
177 memcpy (copy_info->p_libs, task_inst_info->p_libs,
178 copy_info->libs_count * sizeof (us_proc_lib_t));
180 for (i = 0; i < copy_info->libs_count; i++) {
181 if (copy_info->p_libs[i].ips_count > 0)
183 unres_ips_count += copy_info->p_libs[i].ips_count;
185 copy_info->p_libs[i].p_ips =
186 kmalloc (copy_info->p_libs[i].ips_count * sizeof (us_proc_ip_t), GFP_ATOMIC);
188 if (!copy_info->p_libs[i].p_ips) {
189 DPRINTF ("No enough memory for copy_info->p_libs[i].p_ips");
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++) {
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;
201 copy_info->p_libs[i].p_ips[j].installed = 0;
202 memset(©_info->p_libs[i].p_ips[j].jprobe, 0, sizeof(struct jprobe));
203 memset(©_info->p_libs[i].p_ips[j].retprobe, 0, sizeof(struct kretprobe));
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;
211 unres_ips_count += copy_info->p_libs[i].ips_count;
214 for (j = 0; j < copy_info->p_libs[i].plt_count; j++)
216 copy_info->p_libs[i].p_plt[j].real_func_addr = 0;
219 if (copy_info->p_libs[i].vtps_count > 0) {
220 unres_vtps_count += copy_info->p_libs[i].vtps_count;
222 copy_info->p_libs[i].p_vtps =
223 kmalloc (copy_info->p_libs[i].vtps_count * sizeof (us_proc_vtp_t), GFP_ATOMIC);
225 if (!copy_info->p_libs[i].p_vtps) {
226 DPRINTF ("No enough memory for copy_info->p_libs[i].p_vtps");
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 (©_info->p_libs[i].p_vtps[j].jprobe, 0, sizeof(struct jprobe));
236 unres_vtps_count = copy_info->p_libs[i].vtps_count;
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;
242 copy_info->p_libs[i].vma_start = 0;
243 copy_info->p_libs[i].vma_end = 0;
245 copy_info->unres_ips_count = unres_ips_count;
246 copy_info->unres_vtps_count = unres_vtps_count;
251 inst_us_proc_t* get_task_inst_node(struct task_struct *task)
253 struct task_inst_info_node *node, *tnode;
255 list_for_each_entry_safe(node, tnode, &task_inst_info_list, plist)
257 if (node && task && node->tgid == task->tgid) {
258 return node->task_inst_info;
264 void put_task_inst_node(struct task_struct *task, inst_us_proc_t *task_inst_info)
266 struct task_inst_info_node * node;
268 node = kmalloc (sizeof(struct task_inst_info_node), GFP_ATOMIC);
270 node->tgid = task->tgid;
271 node->task_inst_info = task_inst_info;
273 list_add_tail (&(node->plist), &task_inst_info_list);
277 void clear_task_inst_info(void)
279 struct list_head *node, *tmp;
281 list_for_each_safe(node, tmp, &task_inst_info_list)
286 static int is_slp_app_with_dentry(struct vm_area_struct *vma,
287 struct dentry *dentry)
289 struct vm_area_struct *slp_app_vma = NULL;
291 if (vma->vm_file->f_dentry == launchpad_daemon_dentry) {
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) {
300 slp_app_vma = slp_app_vma->vm_next;
309 static int is_android_app_with_dentry(struct vm_area_struct *vma,
310 struct dentry *dentry)
312 struct vm_area_struct *android_app_vma = NULL;
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;
324 android_app_vma = android_app_vma->vm_next;
330 #endif /* ANDROID_APP */
333 void find_libdvm_for_task(struct task_struct *task, inst_us_proc_t *info)
335 struct vm_area_struct *vma = NULL;
336 struct mm_struct *mm = NULL;
338 mm = get_task_mm(task);
343 if (vma->vm_file->f_dentry == libdvm_dentry) {
344 info->libdvm_start = vma->vm_start;
345 info->libdvm_end = vma->vm_end;
354 #endif /* __ANDROID */
356 static struct dentry *dentry_by_path(const char *path)
358 struct dentry *dentry;
359 #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 38)
361 if (kern_path(path, LOOKUP_FOLLOW, &st_path) != 0) {
362 #else /* LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 38) */
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);
370 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 25)
373 #elif LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 38)
374 dentry = nd.path.dentry;
376 #else /* LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 38) */
377 dentry = st_path.dentry;
379 #endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 25) */
383 static int find_task_by_path (const char *path, struct task_struct **p_task, struct list_head *tids)
386 struct task_struct *task;
387 struct vm_area_struct *vma;
388 struct mm_struct *mm;
389 struct dentry *dentry = dentry_by_path(path);
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) {
401 for_each_process (task) {
403 if ( 0 != inst_pid && ( inst_pid != task->pid ) )
406 mm = get_task_mm(task);
411 if ((vma->vm_flags & VM_EXECUTABLE) && vma->vm_file) {
412 if (vma->vm_file->f_dentry == dentry) {
415 get_task_struct (task);
421 if (is_slp_app_with_dentry(vma, dentry)) {
423 get_task_struct(task);
429 if (is_android_app_with_dentry(vma, dentry)) {
431 get_task_struct(task);
434 #endif /* ANDROID_APP */
438 // only decrement usage count on mm since we cannot sleep here
439 atomic_dec(&mm->mm_users);
446 DPRINTF ("found pid %d for %s.", (*p_task)->pid, path);
447 *p_task = (*p_task)->group_leader;
448 gl_nNotifyTgid = (*p_task)->tgid;
450 DPRINTF ("pid for %s not found!", path);
457 static void us_vtp_event_pre_handler (us_proc_vtp_t * vtp, struct pt_regs *regs)
459 __get_cpu_var(gpVtp) = vtp;
460 __get_cpu_var(gpCurVtpRegs) = regs;
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)
465 us_proc_vtp_t *vtp = __get_cpu_var(gpVtp);
466 #if !defined(CONFIG_X86)
467 struct pt_regs *regs = __get_cpu_var(gpCurVtpRegs);
473 us_proc_vtp_data_t *vtp_data;
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;
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)
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);
495 pack_event_info (VTP_PROBE_ID, RECORD_ENTRY, fmt, vtp->jprobe.kp.addr, ival, vtp_data->name);
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);
501 pack_event_info (VTP_PROBE_ID, RECORD_ENTRY, fmt, vtp->jprobe.kp.addr, ival, vtp_data->name);
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);
507 pack_event_info (VTP_PROBE_ID, RECORD_ENTRY, fmt, vtp->jprobe.kp.addr, cval, vtp_data->name);
510 if (current->active_mm) {
512 struct vm_area_struct *vma;
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);
519 maddr = kmap_atomic (page, KM_USER0);
520 len = strlen (maddr + (vaddr & ~PAGE_MASK));
521 sval = kmalloc (len + 1, GFP_KERNEL);
523 EPRINTF ("failed to alloc memory for string in proc %s/%u addr %lu!", current->comm, current->pid, vaddr);
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);
529 kunmap_atomic (maddr, KM_USER0);
530 page_cache_release (page);
533 EPRINTF ("task %s/%u has no mm!", current->comm, current->pid);
536 EPRINTF ("unknown variable type '%c'", vtp_data->type);
539 dbi_uprobe_return ();
542 static int install_mapped_ips (struct task_struct *task, inst_us_proc_t* task_inst_info, int atomic)
544 struct vm_area_struct *vma;
547 unsigned int old_ips_count, old_vtps_count;
549 struct task_struct *t;
550 struct mm_struct *mm;
552 mm = atomic ? task->active_mm : get_task_mm (task);
554 return task_inst_info->unres_ips_count + task_inst_info->unres_vtps_count;
556 old_ips_count = task_inst_info->unres_ips_count;
557 old_vtps_count = task_inst_info->unres_vtps_count;
559 down_read (&mm->mmap_sem);
562 // skip non-text section
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))) {
568 if (vma->vm_pgoff != 0 || !(vma->vm_flags & VM_EXEC) || !vma->vm_file) {
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.
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 );
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");
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, '/');
598 p = task_inst_info->p_libs[i].path;
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);
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);
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);
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);
651 EPRINTF ("failed to install VTP at %p. Error %d!",
652 task_inst_info->p_libs[i].p_vtps[k].jprobe.kp.addr, err);
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;
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);
678 DPRINTF("failed to install IP at %p", addr);
683 us_proc_ip_t *retp = &task_inst_info->libdvm_return_ip;
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);
699 DPRINTF("failed to install IP at %p", addr);
705 #endif /* __ANDROID */
708 list_for_each_entry_rcu (p, &otg_us_proc_info, list) {
709 if (p->ip.installed) {
713 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 26)
714 t = find_task_by_pid(p->tgid);
716 t = pid_task(find_pid_ns(p->tgid, &init_pid_ns),
724 DPRINTF("task for pid %d not found! Dead probe?",
731 if (!page_present(t->active_mm, p->ip.offset)) {
732 DPRINTF("Page isn't present for %p.",
737 err = register_usprobe(current, t->active_mm,
740 DPRINTF("failed to install IP at %lx/%p. Error %d!",
742 p->ip.jprobe.kp.addr, err);
745 task_inst_info->unres_otg_ips_count--;
748 up_read (&mm->mmap_sem);
751 return task_inst_info->unres_ips_count + task_inst_info->unres_vtps_count;
754 static int install_otg_ip(unsigned long addr,
755 unsigned long pre_handler,
756 unsigned long jp_handler,
757 unsigned long rp_handler)
760 us_proc_otg_ip_t *pprobe;
761 struct mm_struct *mm;
763 inst_us_proc_t *task_inst_info = NULL;
764 struct task_struct *task;
766 /* Probe preparing */
767 err = add_otg_probe_to_list(addr, &pprobe);
770 DPRINTF("OTG probe %p already installed.", addr);
773 DPRINTF("Failed to add new OTG probe, err=%d",err);
778 pprobe->ip.jprobe.pre_entry =
779 (kprobe_pre_entry_handler_t)pre_handler;
781 pprobe->ip.jprobe.pre_entry =
782 (kprobe_pre_entry_handler_t)
783 dbi_ujprobe_event_pre_handler_custom_p;
787 pprobe->ip.jprobe.entry =
788 (kprobe_opcode_t *)jp_handler;
790 pprobe->ip.jprobe.entry =
792 dbi_ujprobe_event_handler_custom_p;
795 pprobe->ip.retprobe.handler =
796 (kretprobe_handler_t)rp_handler;
798 pprobe->ip.retprobe.handler =
799 (kretprobe_handler_t)
800 dbi_uretprobe_event_handler_custom_p;
803 mm = get_task_mm(current);
804 if (!page_present(mm, addr)) {
805 DPRINTF("Page isn't present for %p.", addr);
807 pprobe->tgid = current->tgid;
808 task = current->group_leader;
810 task_inst_info = get_task_inst_node(task);
813 task_inst_info = copy_task_inst_info(task, &us_proc_info);
814 put_task_inst_node(task, task_inst_info);
816 us_proc_info.unres_otg_ips_count++;
817 /* Probe will be installed in do_page_fault handler */
820 DPRINTF("Page present for %p.", addr);
822 /* Probe installing */
823 pprobe->tgid = current->tgid;
824 pprobe->ip.installed = 1;
825 err = register_usprobe(current, mm, &pprobe->ip, 1, 0);
827 DPRINTF("failed to install IP at %lx/%p. Error %d!",
828 addr, pprobe->ip.jprobe.kp.addr, err);
833 EXPORT_SYMBOL_GPL(install_otg_ip);
836 static int uninstall_mapped_ips (struct task_struct *task, inst_us_proc_t* task_inst_info, int atomic)
841 for (i = 0; i < task_inst_info->libs_count; i++)
843 DPRINTF ("clear lib %s.", task_inst_info->p_libs[i].path);
844 for (k = 0; k < task_inst_info->p_libs[i].ips_count; k++)
846 if (task_inst_info->p_libs[i].p_ips[k].installed)
848 DPRINTF ("remove IP at %p.", task_inst_info->p_libs[i].p_ips[k].jprobe.kp.addr);
849 err = unregister_usprobe (task, &task_inst_info->p_libs[i].p_ips[k], atomic);
852 EPRINTF ("failed to uninstall IP at %p. Error %d!", task_inst_info->p_libs[i].p_ips[k].jprobe.kp.addr, err);
855 task_inst_info->unres_ips_count++;
856 task_inst_info->p_libs[i].p_ips[k].installed = 0;
859 for (k = 0; k < task_inst_info->p_libs[i].vtps_count; k++)
861 if (task_inst_info->p_libs[i].p_vtps[k].installed)
863 dbi_unregister_ujprobe (task, &task_inst_info->p_libs[i].p_vtps[k].jprobe, atomic);
864 task_inst_info->unres_vtps_count++;
865 task_inst_info->p_libs[i].p_vtps[k].installed = 0;
868 task_inst_info->p_libs[i].loaded = 0;
871 if (is_java_inst_enabled()) {
872 us_proc_ip_t *entp = &task_inst_info->libdvm_entry_ip;
873 if (entp->installed) {
874 unregister_usprobe(task, entp, atomic);
877 us_proc_ip_t *retp = &task_inst_info->libdvm_return_ip;
878 if (retp->installed) {
879 unregister_usprobe(task, retp, atomic);
883 #endif /* __ANDROID */
884 list_for_each_entry_rcu (p, &otg_us_proc_info, list) {
885 if (!p->ip.installed) {
888 DPRINTF("remove OTG IP at %p.", p->ip.offset);
889 err = unregister_usprobe(task, &p->ip, atomic);
891 EPRINTF("failed to uninstall IP at %p. Error %d!",
892 p->ip.jprobe.kp.addr, err);
898 DPRINTF ("Ures IPs %d.", task_inst_info->unres_ips_count);
899 DPRINTF ("Ures VTPs %d.", task_inst_info->unres_vtps_count);
903 void send_sig_jprobe_event_handler (int sig, struct siginfo *info, struct task_struct *t, struct sigpending *signals)
906 struct task_struct *task;
907 inst_us_proc_t *task_inst_info = NULL;
909 //if user-space instrumentation is not set
910 if (!us_proc_info.path)
916 if (!strcmp(us_proc_info.path,"*"))
918 task_inst_info = get_task_inst_node(t);
921 iRet = uninstall_mapped_ips (t, task_inst_info, 1);
923 EPRINTF ("failed to uninstall IPs (%d)!", iRet);
924 dbi_unregister_all_uprobes(t, 1);
930 if (current->tgid != us_proc_info.tgid)
934 // look for another process with the same tgid
936 for_each_process (task)
938 if ((task->pid != t->pid) && (task->tgid == us_proc_info.tgid))
947 DPRINTF ("%s(%d) send_signal SIGKILL for the last target proc %s(%d)",
948 current->comm, current->pid, t->comm, t->pid);
949 iRet = uninstall_mapped_ips (t, &us_proc_info, 1);
951 EPRINTF ("failed to uninstall IPs (%d)!", iRet);
955 static int uninstall_kernel_probe (unsigned long addr, int uflag, int kflag, kernel_probe_t ** pprobe)
957 kernel_probe_t *probe = NULL;
959 if (probes_flags & kflag) {
960 probe = find_probe(addr);
962 iRet = remove_probe_from_list (addr);
964 EPRINTF ("remove_probe_from_list(0x%lx) result=%d!", addr, iRet);
968 probes_flags &= ~kflag;
970 if (us_proc_probes & uflag) {
971 if (!(probes_flags & uflag)) {
973 iRet = unregister_kernel_probe(probe);
975 EPRINTF ("unregister_kernel_probe(0x%lx) result=%d!",
981 us_proc_probes &= ~uflag;
986 int deinst_usr_space_proc (void)
988 int iRet = 0, found = 0;
989 struct task_struct *task = 0;
990 inst_us_proc_t *task_inst_info = NULL;
992 //if user-space instrumentation is not set
993 if (!us_proc_info.path)
996 iRet = uninstall_kernel_probe (pf_addr, US_PROC_PF_INSTLD,
999 EPRINTF ("uninstall_kernel_probe(do_page_fault) result=%d!", iRet);
1001 iRet = uninstall_kernel_probe (cp_addr, US_PROC_CP_INSTLD,
1004 EPRINTF ("uninstall_kernel_probe(copy_process) result=%d!", iRet);
1006 iRet = uninstall_kernel_probe (mr_addr, US_PROC_MR_INSTLD,
1009 EPRINTF ("uninstall_kernel_probe(mm_release) result=%d!", iRet);
1011 iRet = uninstall_kernel_probe (exit_addr, US_PROC_EXIT_INSTLD,
1014 EPRINTF ("uninstall_kernel_probe(do_exit) result=%d!", iRet);
1016 iRet = uninstall_kernel_probe (unmap_addr, US_PROC_UNMAP_INSTLD,
1019 EPRINTF ("uninstall_kernel_probe(do_munmap) result=%d!", iRet);
1021 if (!strcmp(us_proc_info.path,"*"))
1023 for_each_process (task)
1025 task_inst_info = get_task_inst_node(task);
1028 iRet = uninstall_mapped_ips (task, task_inst_info, 1);
1030 EPRINTF ("failed to uninstall IPs (%d)!", iRet);
1031 dbi_unregister_all_uprobes(task, 1);
1037 if (us_proc_info.tgid == 0)
1040 for_each_process (task)
1042 if (task->tgid == us_proc_info.tgid)
1045 get_task_struct (task);
1054 iRet = uninstall_mapped_ips (task, &us_proc_info, 0);
1056 EPRINTF ("failed to uninstall IPs %d!", iRet);
1057 put_task_struct (task);
1058 dbi_unregister_all_uprobes(task, 1);
1059 us_proc_info.tgid = 0;
1060 for(i = 0; i < us_proc_info.libs_count; i++)
1061 us_proc_info.p_libs[i].loaded = 0;
1067 static int install_kernel_probe (unsigned long addr, int uflag, int kflag, kernel_probe_t ** pprobe)
1069 kernel_probe_t *probe = NULL;
1072 DPRINTF("us_proc_probes = 0x%x, uflag = 0x%x, "
1073 "probes_flags = 0x%x, kflag = 0x%x",
1074 us_proc_probes, uflag, probes_flags, kflag);
1076 if (!(probes_flags & kflag)) {
1077 iRet = add_probe_to_list (addr, &probe);
1079 EPRINTF ("add_probe_to_list(0x%lx) result=%d!", addr, iRet);
1082 probes_flags |= kflag;
1084 if (!(us_proc_probes & uflag)) {
1085 if (!(probes_flags & uflag)) {
1086 iRet = register_kernel_probe (probe);
1088 EPRINTF ("register_kernel_probe(0x%lx) result=%d!", addr, iRet);
1092 us_proc_probes |= uflag;
1101 int inst_usr_space_proc (void)
1104 struct task_struct *task = 0;
1105 inst_us_proc_t *task_inst_info = NULL;
1107 //if user-space instrumentation is not set
1108 if (!us_proc_info.path)
1111 DPRINTF("User space instr");
1114 launchpad_daemon_dentry = dentry_by_path("/usr/bin/launchpad_preloading_preinitializing_daemon");
1115 if (launchpad_daemon_dentry == NULL) {
1119 #endif /* SLP_APP */
1122 app_process_dentry = dentry_by_path("/system/bin/app_process");
1123 if (app_process_dentry == NULL) {
1127 android_app_vma_start = 0;
1128 android_app_vma_end = 0;
1129 #endif /* ANDROID_APP */
1132 if (is_java_inst_enabled()) {
1133 libdvm_dentry = dentry_by_path("/system/lib/libdvm.so");
1134 if (libdvm_dentry == NULL) {
1138 memset(&us_proc_info.libdvm_entry_ip, 0, sizeof(us_proc_ip_t));
1139 memset(&us_proc_info.libdvm_return_ip, 0, sizeof(us_proc_ip_t));
1140 us_proc_info.libdvm_start = 0;
1141 us_proc_info.libdvm_end = 0;
1143 #endif /* __ANDROID */
1145 for (i = 0; i < us_proc_info.libs_count; i++) {
1146 us_proc_info.p_libs[i].loaded = 0;
1148 /* check whether process is already running
1149 * 1) if process is running - look for the libraries in the process maps
1150 * 1.1) check if page for symbol does exist
1151 * 1.1.1) if page exists - instrument it
1152 * 1.1.2) if page does not exist - make sure that do_page_fault handler is installed
1153 * 2) if process is not running - make sure that do_page_fault handler is installed
1156 if (!strcmp(us_proc_info.path,"*"))
1158 clear_task_inst_info();
1159 for_each_process (task) {
1160 if (task->flags & PF_KTHREAD){
1161 DPRINTF("ignored kernel thread %d\n",
1166 task_inst_info = get_task_inst_node(task);
1167 if (!task_inst_info) {
1169 copy_task_inst_info(task,
1171 put_task_inst_node(task, task_inst_info);
1173 DPRINTF("trying process");
1175 if (is_java_inst_enabled()) {
1176 find_libdvm_for_task(task, task_inst_info);
1178 #endif /* __ANDROID */
1179 install_mapped_ips (task, task_inst_info, 1);
1180 //put_task_struct (task);
1181 task_inst_info = NULL;
1186 ret = find_task_by_path (us_proc_info.path, &task, NULL);
1189 DPRINTF("task found. installing probes");
1190 us_proc_info.tgid = task->pid;
1192 if (is_java_inst_enabled()) {
1193 find_libdvm_for_task(task, &us_proc_info);
1195 #endif /* __ANDROID */
1196 install_mapped_ips (task, &us_proc_info, 0);
1197 put_task_struct (task);
1201 // enable 'do_page_fault' probe to detect when they will be loaded
1202 ret = install_kernel_probe (pf_addr, US_PROC_PF_INSTLD, 0, &pf_probe);
1205 EPRINTF ("install_kernel_probe(do_page_fault) result=%d!", ret);
1208 // enable 'do_exit' probe to detect for remove task_struct
1209 ret = install_kernel_probe (exit_addr, US_PROC_EXIT_INSTLD, 0, &exit_probe);
1212 EPRINTF ("install_kernel_probe(do_exit) result=%d!", ret);
1215 /* enable 'copy_process' */
1216 ret = install_kernel_probe (cp_addr, US_PROC_CP_INSTLD, 0, &cp_probe);
1219 EPRINTF ("instpall_kernel_probe(copy_process) result=%d!", ret);
1223 // enable 'mm_release' probe to detect when for remove user space probes
1224 ret = install_kernel_probe (mr_addr, US_PROC_MR_INSTLD, 0, &mr_probe);
1227 EPRINTF ("install_kernel_probe(mm_release) result=%d!", ret);
1231 // enable 'do_munmap' probe to detect when for remove user space probes
1232 ret = install_kernel_probe (unmap_addr, US_PROC_UNMAP_INSTLD, 0, &unmap_probe);
1235 EPRINTF ("install_kernel_probe(do_munmap) result=%d!", ret);
1241 void do_page_fault_ret_pre_code (void)
1243 struct mm_struct *mm;
1244 struct vm_area_struct *vma = 0;
1245 inst_us_proc_t *task_inst_info = NULL;
1247 * Because process threads have same address space
1248 * we instrument only group_leader of all this threads
1250 struct task_struct *task = current->group_leader;
1252 //if user-space instrumentation is not set
1253 if (!us_proc_info.path)
1256 if (task->flags & PF_KTHREAD) {
1257 DPRINTF("ignored kernel thread %d\n", task->pid);
1262 if (!strcmp(us_proc_info.path,"*"))
1264 task_inst_info = get_task_inst_node(task);
1265 if (!task_inst_info)
1267 task_inst_info = copy_task_inst_info(task,
1269 put_task_inst_node(task, task_inst_info);
1271 if (is_java_inst_enabled()) {
1272 find_libdvm_for_task(task, task_inst_info);
1274 #endif /* __ANDROID */
1276 install_mapped_ips (task, task_inst_info, 1);
1280 task_inst_info = &us_proc_info;
1281 //DPRINTF("do_page_fault from proc %d-%d-%d", current->pid, task_inst_info->tgid, task_inst_info->unres_ips_count);
1282 if (!is_java_inst_enabled()
1283 && (task_inst_info->unres_ips_count + task_inst_info->unres_vtps_count
1284 + task_inst_info->unres_otg_ips_count) == 0)
1286 //DPRINTF("do_page_fault: there no unresolved IPs");
1290 if (task_inst_info->tgid == 0)
1292 mm = task->active_mm;
1295 // down_read (&mm->mmap_sem);
1299 if ((vma->vm_flags & VM_EXECUTABLE) && vma->vm_file)
1301 if (vma->vm_file->f_dentry == task_inst_info->m_f_dentry)
1306 if (is_slp_app_with_dentry(vma, task_inst_info->m_f_dentry)) {
1309 #endif /* SLP_APP */
1311 if (is_android_app_with_dentry(vma, task_inst_info->m_f_dentry)) {
1314 #endif /* ANDROID_APP */
1318 // up_read (&mm->mmap_sem);
1321 // DPRINTF ("proc %s/%d has no mm", current->comm, current->pid);
1325 DPRINTF ("do_page_fault found target proc %s(%d)", task->comm, task->pid);
1326 task_inst_info->tgid = task->pid;
1327 gl_nNotifyTgid = task->tgid;
1330 if (task_inst_info->tgid == task->tgid)
1332 //DPRINTF("do_page_fault from target proc %d", task_inst_info->tgid);
1334 if (is_java_inst_enabled()) {
1335 find_libdvm_for_task(task, &us_proc_info);
1337 #endif /* __ANDROID */
1338 install_mapped_ips (task, &us_proc_info, 1);
1340 //DPRINTF("do_page_fault from proc %d-%d exit", task->pid, task_inst_info->pid);
1343 EXPORT_SYMBOL_GPL(do_page_fault_ret_pre_code);
1346 void do_exit_probe_pre_code (void)
1348 // TODO: remove task
1350 EXPORT_SYMBOL_GPL(do_exit_probe_pre_code);
1352 static int check_addr(unsigned long addr, unsigned long start, size_t len)
1354 if ((addr >= start) && (addr < start + (unsigned long)len)) {
1361 static int remove_unmap_probes(struct task_struct *task, inst_us_proc_t* task_inst_info, unsigned long start, size_t len)
1364 us_proc_otg_ip_t *p;
1366 const int atomic = 1;
1368 for (i = 0; i < task_inst_info->libs_count; ++i) {
1369 for (k = 0; k < task_inst_info->p_libs[i].ips_count; ++k) {
1370 if (task_inst_info->p_libs[i].p_ips[k].installed) {
1371 addr = task_inst_info->p_libs[i].p_ips[k].jprobe.kp.addr;
1372 if (check_addr(addr, start, len)) {
1373 err = unregister_usprobe(task, &task_inst_info->p_libs[i].p_ips[k], atomic);
1375 EPRINTF("failed to uninstall IP at %p. Error %d!", task_inst_info->p_libs[i].p_ips[k].jprobe.kp.addr, err);
1378 task_inst_info->unres_ips_count++;
1379 task_inst_info->p_libs[i].p_ips[k].installed = 0;
1383 for (k = 0; k < task_inst_info->p_libs[i].vtps_count; ++k) {
1384 if (task_inst_info->p_libs[i].p_vtps[k].installed) {
1385 addr = task_inst_info->p_libs[i].p_vtps[k].jprobe.kp.addr;
1386 if (check_addr(addr, start, len)) {
1387 dbi_unregister_ujprobe(task, &task_inst_info->p_libs[i].p_vtps[k].jprobe, atomic);
1388 task_inst_info->unres_vtps_count++;
1389 task_inst_info->p_libs[i].p_vtps[k].installed = 0;
1395 if (is_java_inst_enabled()) {
1396 us_proc_ip_t *entp = &task_inst_info->libdvm_entry_ip;
1397 if (entp->installed) {
1398 addr = entp->jprobe.kp.addr;
1399 if (check_addr(addr, start, len)) {
1400 unregister_usprobe(task, entp, atomic);
1401 entp->installed = 0;
1404 us_proc_ip_t *retp = &task_inst_info->libdvm_return_ip;
1405 if (retp->installed) {
1406 addr = retp->jprobe.kp.addr;
1407 if (check_addr(addr, start, len)) {
1408 unregister_usprobe(task, retp, atomic);
1409 retp->installed = 0;
1413 #endif /* __ANDROID */
1414 list_for_each_entry_rcu (p, &otg_us_proc_info, list) {
1415 if (!p->ip.installed) {
1419 addr = p->ip.jprobe.kp.addr;
1420 if (check_addr(addr, start, len) == 0) {
1424 err = unregister_usprobe(task, &p->ip, atomic);
1426 EPRINTF("failed to uninstall IP at %p. Error %d!",
1427 p->ip.jprobe.kp.addr, err);
1430 p->ip.installed = 0;
1436 void do_munmap_probe_pre_code(struct mm_struct *mm, unsigned long start, size_t len)
1438 inst_us_proc_t *task_inst_info = NULL;
1439 struct task_struct *task = current;
1441 //if user-space instrumentation is not set
1442 if (!us_proc_info.path || task->tgid != task->pid)
1445 if (!strcmp(us_proc_info.path,"*")) {
1446 task_inst_info = get_task_inst_node(task);
1448 if (task->tgid == us_proc_info.tgid) {
1449 task_inst_info = &us_proc_info;
1453 if (task_inst_info) {
1454 remove_unmap_probes(task, task_inst_info, start, len);
1457 EXPORT_SYMBOL_GPL(do_munmap_probe_pre_code);
1459 void mm_release_probe_pre_code(void)
1462 struct task_struct *task;
1463 inst_us_proc_t *task_inst_info = NULL;
1465 //if user-space instrumentation is not set
1466 if (!us_proc_info.path || current->tgid != current->pid)
1469 if (!strcmp(us_proc_info.path,"*"))
1471 task_inst_info = get_task_inst_node(current);
1474 iRet = uninstall_mapped_ips (current, task_inst_info, 1);
1476 EPRINTF ("failed to uninstall IPs (%d)!", iRet);
1477 dbi_unregister_all_uprobes(current, 1);
1482 if (current->tgid != us_proc_info.tgid)
1485 // look for another process with the same tgid
1487 for_each_process (task)
1489 if ((task->pid != current->pid) && (task->tgid == us_proc_info.tgid))
1499 iRet = uninstall_mapped_ips (current, &us_proc_info, 1);
1501 EPRINTF ("failed to uninstall IPs (%d)!", iRet);
1502 dbi_unregister_all_uprobes(current, 1);
1503 us_proc_info.tgid = 0;
1504 for(i = 0; i < us_proc_info.libs_count; i++)
1505 us_proc_info.p_libs[i].loaded = 0;
1509 EXPORT_SYMBOL_GPL(mm_release_probe_pre_code);
1512 static void recover_child(struct task_struct *child_task, inst_us_proc_t *parent_iup)
1515 for(i = 0; i < parent_iup->libs_count; ++i)
1517 for(k = 0; k < parent_iup->p_libs[i].ips_count; ++k)
1518 if(parent_iup->p_libs[i].p_ips[k].installed)
1519 arch_disarm_uprobe(&parent_iup->p_libs[i].p_ips[k].jprobe.kp, child_task);
1521 for(k = 0; k < parent_iup->p_libs[i].vtps_count; ++k)
1522 if(parent_iup->p_libs[i].p_vtps[k].installed)
1523 arch_disarm_uprobe(&parent_iup->p_libs[i].p_vtps[k].jprobe.kp, child_task);
1527 static void rm_uprobes_child(struct task_struct *new_task)
1529 if(!strcmp(us_proc_info.path, "*")) {
1530 inst_us_proc_t *task_inst_info = get_task_inst_node(current);
1532 recover_child(new_task, task_inst_info);
1534 if(us_proc_info.tgid == current->tgid) {
1535 recover_child(new_task, &us_proc_info);
1540 void copy_process_ret_pre_code(struct task_struct *p)
1545 if(p->mm != current->mm) // check flags CLONE_VM
1546 rm_uprobes_child(p);
1550 DEFINE_PER_CPU (us_proc_ip_t *, gpCurIp) = NULL;
1551 EXPORT_PER_CPU_SYMBOL_GPL(gpCurIp);
1552 DEFINE_PER_CPU(struct pt_regs *, gpUserRegs) = NULL;
1553 EXPORT_PER_CPU_SYMBOL_GPL(gpUserRegs);
1556 unsigned long ujprobe_event_pre_handler (us_proc_ip_t * ip, struct pt_regs *regs)
1558 __get_cpu_var (gpCurIp) = ip;
1559 __get_cpu_var (gpUserRegs) = regs;
1564 int handle_java_event(unsigned long addr)
1566 unsigned long start = 0;
1567 struct pt_regs *regs = __get_cpu_var(gpUserRegs);
1569 if (!strcmp(us_proc_info.path, "*")) {
1570 /* TODO: some stuff here */
1572 start = us_proc_info.libdvm_start;
1574 unsigned long end = us_proc_info.libdvm_end;
1576 if (addr == start + LIBDVM_ENTRY) {
1577 unsigned long *p_met = (unsigned long *)regs->ARM_r0;
1578 char *met_name = p_met ? (char *)(p_met[4]) : 0;
1579 unsigned long *p_cl = p_met ? (unsigned long *)p_met[0] : 0;
1580 char *cl_name = p_cl ? (char *)(p_cl[6]) : 0;
1581 if (!cl_name || !met_name) {
1582 EPRINTF("warn: class name or method name null\n");
1584 pack_event_info(JAVA_PROBE_ID, RECORD_ENTRY, "pss", addr, cl_name, met_name);
1586 dbi_uprobe_return ();
1590 if (addr == start + LIBDVM_RETURN) {
1591 unsigned long *p_th = (unsigned long *)regs->ARM_r6;
1592 unsigned long *p_st = p_th;
1593 unsigned long *p_met = p_st ? (unsigned long *)p_st[2] : 0;
1594 char *met_name = p_met ? (char *)(p_met[4]) : 0;
1595 unsigned long *p_cl = p_met ? (unsigned long *)p_met[0] : 0;
1596 char *cl_name = p_cl ? (char *)(p_cl[6]) : 0;
1597 if (!cl_name || !met_name) {
1598 EPRINTF("warn: class name or method name null\n");
1600 pack_event_info(JAVA_PROBE_ID, RECORD_RET, "pss", addr, cl_name, met_name);
1602 dbi_uprobe_return ();
1608 #endif /* __ANDROID */
1610 void ujprobe_event_handler (unsigned long arg1, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5, unsigned long arg6)
1612 us_proc_ip_t *ip = __get_cpu_var (gpCurIp);
1613 unsigned long addr = (unsigned long)ip->jprobe.kp.addr;
1616 if (is_java_inst_enabled() && handle_java_event(addr)) {
1619 #endif /* __ANDROID */
1622 #if defined(CONFIG_ARM)
1623 if (ip->offset & 0x01)
1625 pack_event_info (US_PROBE_ID, RECORD_ENTRY, "ppppppp", addr | 0x01, arg1, arg2, arg3, arg4, arg5, arg6);
1627 pack_event_info (US_PROBE_ID, RECORD_ENTRY, "ppppppp", addr, arg1, arg2, arg3, arg4, arg5, arg6);
1630 pack_event_info (US_PROBE_ID, RECORD_ENTRY, "ppppppp", addr, arg1, arg2, arg3, arg4, arg5, arg6);
1632 // Mr_Nobody: uncomment for valencia
1633 //unregister_usprobe(current, ip, 1);
1634 dbi_uprobe_return ();
1637 void find_plt_address(unsigned long addr)
1639 inst_us_proc_t *task_inst_info = NULL;
1642 struct vm_area_struct *vma;
1643 us_proc_lib_t *p_lib = NULL;
1644 char *szLibPath = NULL;
1646 // Search for library structure to check whether this function plt or not
1647 if (strcmp(us_proc_info.path, "*")){
1648 // If app lib instrumentation
1649 task_inst_info = &us_proc_info;
1651 // If lib only instrumentation
1652 task_inst_info = get_task_inst_node(current);
1654 if ((task_inst_info != NULL) && (task_inst_info->is_plt != 0)) {
1655 for (i = 0; i < task_inst_info->libs_count; i++)
1657 if ((task_inst_info->p_libs[i].loaded)
1658 && (task_inst_info->p_libs[i].plt_count > 0)
1659 && (addr > task_inst_info->p_libs[i].vma_start)
1660 && (addr < task_inst_info->p_libs[i].vma_end))
1662 p_lib = &(task_inst_info->p_libs[i]);
1666 if (p_lib != NULL) {
1667 for (i = 0; i < p_lib->plt_count; i++)
1669 if (addr == p_lib->p_plt[i].func_addr + p_lib->vma_start) {
1670 unsigned long real_got;
1671 if (p_lib->vma_flag & VM_EXECUTABLE) {
1672 real_got = p_lib->p_plt[i].got_addr;
1674 real_got = p_lib->p_plt[i].got_addr + p_lib->vma_start;
1676 if (!read_proc_vm_atomic(current, (unsigned long)(real_got), &real_addr, sizeof(unsigned long))) {
1677 printk("Failed to read got %p at memory address %p!\n", p_lib->p_plt[i].got_addr, real_got);
1680 if (real_addr != p_lib->p_plt[i].real_func_addr) {
1681 p_lib->p_plt[i].real_func_addr = real_addr;
1682 vma = find_vma(current->mm, real_addr);
1683 if ((vma != NULL) && (vma->vm_start <= real_addr) && (vma->vm_end > real_addr)) {
1684 if (vma->vm_file != NULL) {
1685 szLibPath = &(vma->vm_file->f_dentry->d_iname);
1688 printk("Failed to get vma, includes %x address\n", real_addr);
1692 pack_event_info(PLT_ADDR_PROBE_ID, RECORD_RET, "ppsp", addr, real_addr, szLibPath, real_addr - vma->vm_start);
1695 pack_event_info(PLT_ADDR_PROBE_ID, RECORD_RET, "ppp", addr, real_addr, real_addr - vma->vm_start);
1707 int uretprobe_event_handler (struct kretprobe_instance *probe, struct pt_regs *regs, us_proc_ip_t * ip)
1709 int retval = regs_return_value(regs);
1710 unsigned long addr = (unsigned long)ip->jprobe.kp.addr;
1712 find_plt_address(addr);
1714 #if defined(CONFIG_ARM)
1715 if (ip->offset & 0x01)
1717 pack_event_info (US_PROBE_ID, RECORD_RET, "pd", addr | 0x01, retval);
1719 pack_event_info (US_PROBE_ID, RECORD_RET, "pd", addr, retval);
1722 pack_event_info (US_PROBE_ID, RECORD_RET, "pd", addr, retval);
1724 // Mr_Nobody: uncomment for valencia
1725 //unregister_usprobe(current, ip, 1);
1729 static int register_usprobe (struct task_struct *task, struct mm_struct *mm, us_proc_ip_t * ip, int atomic, kprobe_opcode_t * islot)
1732 ip->jprobe.kp.tgid = task->tgid;
1733 //ip->jprobe.kp.addr = (kprobe_opcode_t *) addr;
1734 if(!ip->jprobe.entry) {
1735 if (dbi_ujprobe_event_handler_custom_p != NULL)
1737 ip->jprobe.entry = (kprobe_opcode_t *) dbi_ujprobe_event_handler_custom_p;
1738 DPRINTF("Set custom event handler for %x\n", ip->offset);
1742 ip->jprobe.entry = (kprobe_opcode_t *) ujprobe_event_handler;
1743 DPRINTF("Set default event handler for %x\n", ip->offset);
1746 if(!ip->jprobe.pre_entry) {
1747 if (dbi_ujprobe_event_pre_handler_custom_p != NULL)
1749 ip->jprobe.pre_entry = (kprobe_pre_entry_handler_t) dbi_ujprobe_event_pre_handler_custom_p;
1750 DPRINTF("Set custom pre handler for %x\n", ip->offset);
1754 ip->jprobe.pre_entry = (kprobe_pre_entry_handler_t) ujprobe_event_pre_handler;
1755 DPRINTF("Set default pre handler for %x\n", ip->offset);
1758 ip->jprobe.priv_arg = ip;
1759 ret = dbi_register_ujprobe (task, mm, &ip->jprobe, atomic);
1762 DPRINTF ("dbi_register_ujprobe() failure %d", ret);
1766 // Mr_Nobody: comment for valencia
1767 ip->retprobe.kp.tgid = task->tgid;
1768 //ip->retprobe.kp.addr = (kprobe_opcode_t *) addr;
1769 if(!ip->retprobe.handler) {
1770 if (dbi_uretprobe_event_handler_custom_p != NULL)
1771 ip->retprobe.handler = (kretprobe_handler_t) dbi_uretprobe_event_handler_custom_p;
1773 ip->retprobe.handler = (kretprobe_handler_t) uretprobe_event_handler;
1774 //DPRINTF("Failed custom dbi_uretprobe_event_handler_custom_p");
1777 ip->retprobe.priv_arg = ip;
1778 ret = dbi_register_uretprobe (task, mm, &ip->retprobe, atomic);
1781 EPRINTF ("dbi_register_uretprobe() failure %d", ret);
1787 static int unregister_usprobe (struct task_struct *task, us_proc_ip_t * ip, int atomic)
1789 dbi_unregister_ujprobe (task, &ip->jprobe, atomic);
1790 dbi_unregister_uretprobe (task, &ip->retprobe, atomic);
1794 unsigned long get_stack_size(struct task_struct *task,
1795 struct pt_regs *regs)
1797 #ifdef CONFIG_ADD_THREAD_STACK_INFO
1798 return (task->stack_start - dbi_get_stack_ptr(regs));
1800 struct vm_area_struct *vma = NULL;
1801 struct mm_struct *mm = NULL;
1802 unsigned long result = 0;
1803 int atomic = in_atomic();
1805 mm = (atomic ? task->active_mm: get_task_mm(task));
1809 down_read(&mm->mmap_sem);
1811 vma = find_vma(mm, dbi_get_stack_ptr(regs));
1814 result = vma->vm_end - dbi_get_stack_ptr(regs);
1819 up_read(&mm->mmap_sem);
1827 EXPORT_SYMBOL_GPL(get_stack_size);
1829 unsigned long get_stack(struct task_struct *task, struct pt_regs *regs,
1830 char *buf, unsigned long sz)
1832 unsigned long stack_sz = get_stack_size(task, regs);
1833 unsigned long real_sz = (stack_sz > sz ? sz: stack_sz);
1834 int res = read_proc_vm_atomic(task, dbi_get_stack_ptr(regs), buf, real_sz);
1837 EXPORT_SYMBOL_GPL(get_stack);
1839 int dump_to_trace(probe_id_t probe_id, void *addr, const char *buf,
1842 unsigned long rest_sz = sz;
1843 const char *data = buf;
1845 while (rest_sz >= EVENT_MAX_SIZE) {
1846 pack_event_info(probe_id, RECORD_ENTRY, "pa",
1847 addr, EVENT_MAX_SIZE, data);
1848 rest_sz -= EVENT_MAX_SIZE;
1849 data += EVENT_MAX_SIZE;
1853 pack_event_info(probe_id, RECORD_ENTRY, "pa", addr, rest_sz, data);
1857 EXPORT_SYMBOL_GPL(dump_to_trace);
1859 int dump_backtrace(probe_id_t probe_id, struct task_struct *task,
1860 void *addr, struct pt_regs *regs, unsigned long sz)
1862 unsigned long real_sz = 0;
1865 buf = (char *)kmalloc(sz, GFP_ATOMIC);
1868 real_sz = get_stack(task, regs, buf, sz);
1870 dump_to_trace(probe_id, addr, buf, real_sz);
1877 EXPORT_SYMBOL_GPL(dump_backtrace);
1879 unsigned long get_ret_addr(struct task_struct *task, us_proc_ip_t *ip)
1881 unsigned long retaddr = 0;
1882 struct hlist_node *item, *tmp_node;
1883 struct kretprobe_instance *ri;
1886 hlist_for_each_safe (item, tmp_node, &ip->retprobe.used_instances) {
1887 ri = hlist_entry (item, struct kretprobe_instance, uflist);
1889 if (ri->task && ri->task->pid == task->pid &&
1890 ri->task->tgid == task->tgid)
1891 retaddr = (unsigned long)ri->ret_addr;
1898 return dbi_get_ret_addr(task_pt_regs(task));
1900 EXPORT_SYMBOL_GPL(get_ret_addr);