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 int find_task_by_path (const char *path, struct task_struct **p_task, struct list_head *tids)
359 struct task_struct *task;
360 struct vm_area_struct *vma;
361 struct mm_struct *mm;
362 #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 38)
364 #else /* LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 38) */
366 #endif /* LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 38) */
370 /* find corresponding dir entry, this is also check for valid path */
371 // TODO: test - try to instrument process with non-existing path
372 // TODO: test - try to instrument process with existing path and delete file just after start
373 #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 38)
374 if (kern_path(us_proc_info.path, LOOKUP_FOLLOW, &s_path) != 0) {
375 #else /* LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 38) */
376 if (path_lookup(us_proc_info.path, LOOKUP_FOLLOW, &nd) != 0) {
377 #endif /* LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 38) */
378 EPRINTF ("failed to lookup dentry for path %s!", path);
383 for_each_process (task) {
385 if ( 0 != inst_pid && ( inst_pid != task->pid ) )
388 mm = get_task_mm(task);
393 if ((vma->vm_flags & VM_EXECUTABLE) && vma->vm_file) {
394 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 25)
395 if (vma->vm_file->f_dentry == nd.dentry) {
397 #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 38)
398 if (vma->vm_file->f_dentry == s_path.dentry ) {
399 #else /* LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 38) */
400 if (vma->vm_file->f_dentry == nd.path.dentry ) {
401 #endif /* LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 38) */
405 get_task_struct (task);
411 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 25)
412 if (is_slp_app_with_dentry(vma, nd.dentry)) {
414 #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 38)
415 if (is_slp_app_with_dentry(vma, s_path.dentry)) {
416 #else /* LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 38) */
417 if (is_slp_app_with_dentry(vma, nd.path.dentry)) {
418 #endif /* LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 38) */
421 get_task_struct(task);
427 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 25)
428 if (is_android_app_with_dentry(vma, nd.dentry)) {
430 #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 38)
431 if (is_android_app_with_dentry(vma, s_path.dentry)) {
432 #else /* LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 38) */
433 if (is_android_app_with_dentry(vma, nd.path.dentry)) {
434 #endif /* LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 38) */
437 get_task_struct(task);
440 #endif /* ANDROID_APP */
444 // only decrement usage count on mm since we cannot sleep here
445 atomic_dec(&mm->mm_users);
452 DPRINTF ("found pid %d for %s.", (*p_task)->pid, path);
453 *p_task = (*p_task)->group_leader;
454 gl_nNotifyTgid = (*p_task)->tgid;
456 DPRINTF ("pid for %s not found!", path);
459 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 25)
462 #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 38)
464 #else /* LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 38) */
466 #endif /* LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 38) */
472 static void us_vtp_event_pre_handler (us_proc_vtp_t * vtp, struct pt_regs *regs)
474 __get_cpu_var(gpVtp) = vtp;
475 __get_cpu_var(gpCurVtpRegs) = regs;
478 static void us_vtp_event_handler (unsigned long arg1, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5, unsigned long arg6)
480 us_proc_vtp_t *vtp = __get_cpu_var(gpVtp);
481 #if !defined(CONFIG_X86)
482 struct pt_regs *regs = __get_cpu_var(gpCurVtpRegs);
488 us_proc_vtp_data_t *vtp_data;
494 list_for_each_entry_rcu (vtp_data, &vtp->list, list) {
495 // DPRINTF ("[%d]proc %s(%d): %lx", nCount++, current->comm, current->pid, vtp->addr);
496 fmt[1] = vtp_data->type;
497 if (vtp_data->reg == -1)
498 vaddr = vtp_data->off;
500 vaddr = ARCH_REG_VAL (regs, vtp_data->reg) + vtp_data->off;
501 // DPRINTF ("VTP type '%c'", vtp_data->type);
502 switch (vtp_data->type)
507 if (read_proc_vm_atomic (current, vaddr, &ival, sizeof (ival)) < sizeof (ival))
508 EPRINTF ("failed to read vm of proc %s/%u addr %lu!", current->comm, current->pid, vaddr);
510 pack_event_info (VTP_PROBE_ID, RECORD_ENTRY, fmt, vtp->jprobe.kp.addr, ival, vtp_data->name);
513 if (read_proc_vm_atomic (current, vaddr, &ival, sizeof (ival)) < sizeof (ival))
514 EPRINTF ("failed to read vm of proc %s/%u addr %lu!", current->comm, current->pid, vaddr);
516 pack_event_info (VTP_PROBE_ID, RECORD_ENTRY, fmt, vtp->jprobe.kp.addr, ival, vtp_data->name);
519 if (read_proc_vm_atomic (current, vaddr, &cval, sizeof (cval)) < sizeof (cval))
520 EPRINTF ("failed to read vm of proc %s/%u addr %lu!", current->comm, current->pid, vaddr);
522 pack_event_info (VTP_PROBE_ID, RECORD_ENTRY, fmt, vtp->jprobe.kp.addr, cval, vtp_data->name);
525 if (current->active_mm) {
527 struct vm_area_struct *vma;
530 if (get_user_pages_atomic (current, current->active_mm, vaddr, 1, 0, 1, &page, &vma) <= 0) {
531 EPRINTF ("get_user_pages_atomic failed for proc %s/%u addr %lu!", current->comm, current->pid, vaddr);
534 maddr = kmap_atomic (page, KM_USER0);
535 len = strlen (maddr + (vaddr & ~PAGE_MASK));
536 sval = kmalloc (len + 1, GFP_KERNEL);
538 EPRINTF ("failed to alloc memory for string in proc %s/%u addr %lu!", current->comm, current->pid, vaddr);
540 copy_from_user_page (vma, page, vaddr, sval, maddr + (vaddr & ~PAGE_MASK), len + 1);
541 pack_event_info (VTP_PROBE_ID, RECORD_ENTRY, fmt, vtp->jprobe.kp.addr, sval, vtp_data->name);
544 kunmap_atomic (maddr, KM_USER0);
545 page_cache_release (page);
548 EPRINTF ("task %s/%u has no mm!", current->comm, current->pid);
551 EPRINTF ("unknown variable type '%c'", vtp_data->type);
554 dbi_uprobe_return ();
557 static int install_mapped_ips (struct task_struct *task, inst_us_proc_t* task_inst_info, int atomic)
559 struct vm_area_struct *vma;
562 unsigned int old_ips_count, old_vtps_count;
564 struct task_struct *t;
565 struct mm_struct *mm;
567 mm = atomic ? task->active_mm : get_task_mm (task);
569 return task_inst_info->unres_ips_count + task_inst_info->unres_vtps_count;
571 old_ips_count = task_inst_info->unres_ips_count;
572 old_vtps_count = task_inst_info->unres_vtps_count;
574 down_read (&mm->mmap_sem);
577 // skip non-text section
579 if (vma->vm_pgoff != 0 || !(vma->vm_flags & VM_EXEC) || !vma->vm_file || (vma->vm_flags & VM_ACCOUNT) ||
580 !(vma->vm_flags & (VM_WRITE | VM_MAYWRITE)) ||
581 !(vma->vm_flags & (VM_READ | VM_MAYREAD))) {
583 if (vma->vm_pgoff != 0 || !(vma->vm_flags & VM_EXEC) || !vma->vm_file) {
589 * After process was forked, some time it inherits parent process environment.
590 * We need to renew instrumentation when we detect that process gets own environment.
592 for (i = 0; i < task_inst_info->libs_count; i++) {
593 // struct path tmp_path;
594 // tmp_path.dentry = task_inst_info->p_libs[i].m_f_dentry;
595 // tmp_path.mnt = task_inst_info->p_libs[i].m_vfs_mount;
596 // char* p_path = d_path ( &tmp_path, path_buffer, 255 );
597 // DPRINTF("f_dentry:%x m_f_dentry:%x path:%s", vma->vm_file->f_dentry,
598 // task_inst_info->p_libs[i].m_f_dentry, p_path );
600 //TODO: test - try to instrument non-existing libs
601 if (vma->vm_file->f_dentry == task_inst_info->p_libs[i].m_f_dentry) {
602 // DPRINTF("vm_flags:%x loaded:%x ips_count:%d vtps_count:%d",
603 // vma->vm_flags, task_inst_info->p_libs[i].loaded,
604 // task_inst_info->p_libs[i].ips_count, task_inst_info->p_libs[i].vtps_count );
605 if (!task_inst_info->p_libs[i].loaded) {
606 // DPRINTF("!VM_EXECUTABLE && !loaded");
608 int app_flag = (vma->vm_file->f_dentry == task_inst_info->m_f_dentry);
609 DPRINTF ("post dyn lib event %s/%s", current->comm, task_inst_info->p_libs[i].path);
610 // if we installed something, post library info for those IPs
611 p = strrchr(task_inst_info->p_libs[i].path, '/');
613 p = task_inst_info->p_libs[i].path;
616 task_inst_info->p_libs[i].loaded = 1;
617 task_inst_info->p_libs[i].vma_start = vma->vm_start;
618 task_inst_info->p_libs[i].vma_end = vma->vm_end;
619 pack_event_info (DYN_LIB_PROBE_ID, RECORD_ENTRY, "dspdd",
620 task->tgid, p, vma->vm_start, vma->vm_end-vma->vm_start, app_flag);
622 for (k = 0; k < task_inst_info->p_libs[i].ips_count; k++) {
623 DPRINTF("ips_count current:%d", k);
624 if (!task_inst_info->p_libs[i].p_ips[k].installed) {
625 DPRINTF("!installed");
626 addr = task_inst_info->p_libs[i].p_ips[k].offset;
627 addr += vma->vm_start;
628 if (page_present (mm, addr)) {
629 DPRINTF ("pid %d, %s sym is loaded at %lx/%lx.",
630 task->pid, task_inst_info->p_libs[i].path,
631 task_inst_info->p_libs[i].p_ips[k].offset, addr);
632 task_inst_info->p_libs[i].p_ips[k].jprobe.kp.addr = (kprobe_opcode_t *) addr;
633 task_inst_info->p_libs[i].p_ips[k].retprobe.kp.addr = (kprobe_opcode_t *) addr;
634 task_inst_info->p_libs[i].p_ips[k].installed = 1;
635 task_inst_info->unres_ips_count--;
636 err = register_usprobe (task, mm, &task_inst_info->p_libs[i].p_ips[k], atomic, 0);
638 DPRINTF ("failed to install IP at %lx/%p. Error %d!",
639 task_inst_info->p_libs[i].p_ips[k].offset,
640 task_inst_info->p_libs[i].p_ips[k].jprobe.kp.addr, err);
645 for (k = 0; k < task_inst_info->p_libs[i].vtps_count; k++) {
646 DPRINTF("vtps_count current:%d", k);
647 if (!task_inst_info->p_libs[i].p_vtps[k].installed) {
648 DPRINTF("!installed");
649 addr = task_inst_info->p_libs[i].p_vtps[k].addr;
650 if (!(vma->vm_flags & VM_EXECUTABLE))
651 addr += vma->vm_start;
652 if (page_present (mm, addr)) {
653 DPRINTF ("pid %d, %s sym is loaded at %lx/%lx.",
654 task->pid, task_inst_info->p_libs[i].path,
655 task_inst_info->p_libs[i].p_ips[k].offset, addr);
656 task_inst_info->p_libs[i].p_vtps[k].jprobe.kp.tgid = task_inst_info->tgid;
657 task_inst_info->p_libs[i].p_vtps[k].jprobe.kp.addr = (kprobe_opcode_t *) addr;
658 task_inst_info->p_libs[i].p_vtps[k].jprobe.entry = (kprobe_opcode_t *) us_vtp_event_handler;
659 task_inst_info->p_libs[i].p_vtps[k].jprobe.pre_entry = (kprobe_pre_entry_handler_t) us_vtp_event_pre_handler;
660 task_inst_info->p_libs[i].p_vtps[k].jprobe.priv_arg = &task_inst_info->p_libs[i].p_vtps[k];
661 task_inst_info->p_libs[i].p_vtps[k].installed = 1;
662 task_inst_info->unres_vtps_count--;
663 err = dbi_register_ujprobe (task, mm, &task_inst_info->p_libs[i].p_vtps[k].jprobe, atomic);
665 EPRINTF ("failed to install VTP at %p. Error %d!",
666 task_inst_info->p_libs[i].p_vtps[k].jprobe.kp.addr, err);
674 if (is_java_inst_enabled()
675 && vma->vm_file->f_dentry == libdvm_dentry) {
676 us_proc_ip_t *entp = &task_inst_info->libdvm_entry_ip;
678 && task_inst_info->libdvm_start) {
679 unsigned long addr = LIBDVM_ENTRY + task_inst_info->libdvm_start;
680 if (page_present(mm, addr)) {
681 entp->jprobe.kp.tgid = task->tgid;
682 entp->jprobe.pre_entry = ujprobe_event_pre_handler;
683 entp->jprobe.entry = ujprobe_event_handler;
684 entp->jprobe.priv_arg = entp;
685 entp->jprobe.kp.addr = addr;
686 entp->retprobe.kp.tgid = task->tgid;
687 entp->retprobe.handler = uretprobe_event_handler;
688 entp->retprobe.priv_arg = entp;
689 entp->retprobe.kp.addr = addr;
690 err = register_usprobe(task, mm, entp, atomic, 0);
692 DPRINTF("failed to install IP at %p", addr);
697 us_proc_ip_t *retp = &task_inst_info->libdvm_return_ip;
699 && task_inst_info->libdvm_start) {
700 unsigned long addr = LIBDVM_RETURN + task_inst_info->libdvm_start;
701 if (page_present(mm, addr)) {
702 retp->jprobe.kp.tgid = task->tgid;
703 retp->jprobe.pre_entry = ujprobe_event_pre_handler;
704 retp->jprobe.entry = ujprobe_event_handler;
705 retp->jprobe.priv_arg = retp;
706 retp->jprobe.kp.addr = addr;
707 retp->retprobe.kp.tgid = task->tgid;
708 retp->retprobe.handler = uretprobe_event_handler;
709 retp->retprobe.priv_arg = retp;
710 retp->retprobe.kp.addr = addr;
711 err = register_usprobe(task, mm, retp, atomic, 0);
713 DPRINTF("failed to install IP at %p", addr);
719 #endif /* __ANDROID */
722 list_for_each_entry_rcu (p, &otg_us_proc_info, list) {
723 if (p->ip.installed) {
727 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 26)
728 t = find_task_by_pid(p->tgid);
730 t = pid_task(find_pid_ns(p->tgid, &init_pid_ns),
738 DPRINTF("task for pid %d not found! Dead probe?",
745 if (!page_present(t->active_mm, p->ip.offset)) {
746 DPRINTF("Page isn't present for %p.",
751 err = register_usprobe(current, t->active_mm,
754 DPRINTF("failed to install IP at %lx/%p. Error %d!",
756 p->ip.jprobe.kp.addr, err);
759 task_inst_info->unres_otg_ips_count--;
762 up_read (&mm->mmap_sem);
765 return task_inst_info->unres_ips_count + task_inst_info->unres_vtps_count;
768 static int install_otg_ip(unsigned long addr,
769 unsigned long pre_handler,
770 unsigned long jp_handler,
771 unsigned long rp_handler)
774 us_proc_otg_ip_t *pprobe;
775 struct mm_struct *mm;
777 inst_us_proc_t *task_inst_info = NULL;
778 struct task_struct *task;
780 /* Probe preparing */
781 err = add_otg_probe_to_list(addr, &pprobe);
784 DPRINTF("OTG probe %p already installed.", addr);
787 DPRINTF("Failed to add new OTG probe, err=%d",err);
792 pprobe->ip.jprobe.pre_entry =
793 (kprobe_pre_entry_handler_t)pre_handler;
795 pprobe->ip.jprobe.pre_entry =
796 (kprobe_pre_entry_handler_t)
797 dbi_ujprobe_event_pre_handler_custom_p;
801 pprobe->ip.jprobe.entry =
802 (kprobe_opcode_t *)jp_handler;
804 pprobe->ip.jprobe.entry =
806 dbi_ujprobe_event_handler_custom_p;
809 pprobe->ip.retprobe.handler =
810 (kretprobe_handler_t)rp_handler;
812 pprobe->ip.retprobe.handler =
813 (kretprobe_handler_t)
814 dbi_uretprobe_event_handler_custom_p;
817 mm = get_task_mm(current);
818 if (!page_present(mm, addr)) {
819 DPRINTF("Page isn't present for %p.", addr);
821 pprobe->tgid = current->tgid;
822 task = current->group_leader;
824 task_inst_info = get_task_inst_node(task);
827 task_inst_info = copy_task_inst_info(task, &us_proc_info);
828 put_task_inst_node(task, task_inst_info);
830 us_proc_info.unres_otg_ips_count++;
831 /* Probe will be installed in do_page_fault handler */
834 DPRINTF("Page present for %p.", addr);
836 /* Probe installing */
837 pprobe->tgid = current->tgid;
838 pprobe->ip.installed = 1;
839 err = register_usprobe(current, mm, &pprobe->ip, 1, 0);
841 DPRINTF("failed to install IP at %lx/%p. Error %d!",
842 addr, pprobe->ip.jprobe.kp.addr, err);
847 EXPORT_SYMBOL_GPL(install_otg_ip);
850 static int uninstall_mapped_ips (struct task_struct *task, inst_us_proc_t* task_inst_info, int atomic)
855 for (i = 0; i < task_inst_info->libs_count; i++)
857 DPRINTF ("clear lib %s.", task_inst_info->p_libs[i].path);
858 for (k = 0; k < task_inst_info->p_libs[i].ips_count; k++)
860 if (task_inst_info->p_libs[i].p_ips[k].installed)
862 DPRINTF ("remove IP at %p.", task_inst_info->p_libs[i].p_ips[k].jprobe.kp.addr);
863 err = unregister_usprobe (task, &task_inst_info->p_libs[i].p_ips[k], atomic);
866 EPRINTF ("failed to uninstall IP at %p. Error %d!", task_inst_info->p_libs[i].p_ips[k].jprobe.kp.addr, err);
869 task_inst_info->unres_ips_count++;
870 task_inst_info->p_libs[i].p_ips[k].installed = 0;
873 for (k = 0; k < task_inst_info->p_libs[i].vtps_count; k++)
875 if (task_inst_info->p_libs[i].p_vtps[k].installed)
877 dbi_unregister_ujprobe (task, &task_inst_info->p_libs[i].p_vtps[k].jprobe, atomic);
878 task_inst_info->unres_vtps_count++;
879 task_inst_info->p_libs[i].p_vtps[k].installed = 0;
882 task_inst_info->p_libs[i].loaded = 0;
885 if (is_java_inst_enabled()) {
886 us_proc_ip_t *entp = &task_inst_info->libdvm_entry_ip;
887 if (entp->installed) {
888 unregister_usprobe(task, entp, atomic);
891 us_proc_ip_t *retp = &task_inst_info->libdvm_return_ip;
892 if (retp->installed) {
893 unregister_usprobe(task, retp, atomic);
897 #endif /* __ANDROID */
898 list_for_each_entry_rcu (p, &otg_us_proc_info, list) {
899 if (!p->ip.installed) {
902 DPRINTF("remove OTG IP at %p.", p->ip.offset);
903 err = unregister_usprobe(task, &p->ip, atomic);
905 EPRINTF("failed to uninstall IP at %p. Error %d!",
906 p->ip.jprobe.kp.addr, err);
912 DPRINTF ("Ures IPs %d.", task_inst_info->unres_ips_count);
913 DPRINTF ("Ures VTPs %d.", task_inst_info->unres_vtps_count);
917 void send_sig_jprobe_event_handler (int sig, struct siginfo *info, struct task_struct *t, struct sigpending *signals)
920 struct task_struct *task;
921 inst_us_proc_t *task_inst_info = NULL;
923 //if user-space instrumentation is not set
924 if (!us_proc_info.path)
930 if (!strcmp(us_proc_info.path,"*"))
932 task_inst_info = get_task_inst_node(t);
935 iRet = uninstall_mapped_ips (t, task_inst_info, 1);
937 EPRINTF ("failed to uninstall IPs (%d)!", iRet);
938 dbi_unregister_all_uprobes(t, 1);
944 if (current->tgid != us_proc_info.tgid)
948 // look for another process with the same tgid
950 for_each_process (task)
952 if ((task->pid != t->pid) && (task->tgid == us_proc_info.tgid))
961 DPRINTF ("%s(%d) send_signal SIGKILL for the last target proc %s(%d)",
962 current->comm, current->pid, t->comm, t->pid);
963 iRet = uninstall_mapped_ips (t, &us_proc_info, 1);
965 EPRINTF ("failed to uninstall IPs (%d)!", iRet);
969 static int uninstall_kernel_probe (unsigned long addr, int uflag, int kflag, kernel_probe_t ** pprobe)
971 kernel_probe_t *probe = NULL;
973 if (probes_flags & kflag) {
974 probe = find_probe(addr);
976 iRet = remove_probe_from_list (addr);
978 EPRINTF ("remove_probe_from_list(0x%lx) result=%d!", addr, iRet);
982 probes_flags &= ~kflag;
984 if (us_proc_probes & uflag) {
985 if (!(probes_flags & uflag)) {
987 iRet = unregister_kernel_probe(probe);
989 EPRINTF ("unregister_kernel_probe(0x%lx) result=%d!",
995 us_proc_probes &= ~uflag;
1000 int deinst_usr_space_proc (void)
1002 int iRet = 0, found = 0;
1003 struct task_struct *task = 0;
1004 inst_us_proc_t *task_inst_info = NULL;
1006 //if user-space instrumentation is not set
1007 if (!us_proc_info.path)
1010 iRet = uninstall_kernel_probe (pf_addr, US_PROC_PF_INSTLD,
1013 EPRINTF ("uninstall_kernel_probe(do_page_fault) result=%d!", iRet);
1015 iRet = uninstall_kernel_probe (cp_addr, US_PROC_CP_INSTLD,
1018 EPRINTF ("uninstall_kernel_probe(copy_process) result=%d!", iRet);
1020 iRet = uninstall_kernel_probe (mr_addr, US_PROC_MR_INSTLD,
1023 EPRINTF ("uninstall_kernel_probe(mm_release) result=%d!", iRet);
1025 iRet = uninstall_kernel_probe (exit_addr, US_PROC_EXIT_INSTLD,
1028 EPRINTF ("uninstall_kernel_probe(do_exit) result=%d!", iRet);
1030 iRet = uninstall_kernel_probe (unmap_addr, US_PROC_UNMAP_INSTLD,
1033 EPRINTF ("uninstall_kernel_probe(do_munmap) result=%d!", iRet);
1035 if (!strcmp(us_proc_info.path,"*"))
1037 for_each_process (task)
1039 task_inst_info = get_task_inst_node(task);
1042 iRet = uninstall_mapped_ips (task, task_inst_info, 1);
1044 EPRINTF ("failed to uninstall IPs (%d)!", iRet);
1045 dbi_unregister_all_uprobes(task, 1);
1051 if (us_proc_info.tgid == 0)
1054 for_each_process (task)
1056 if (task->tgid == us_proc_info.tgid)
1059 get_task_struct (task);
1068 iRet = uninstall_mapped_ips (task, &us_proc_info, 0);
1070 EPRINTF ("failed to uninstall IPs %d!", iRet);
1071 put_task_struct (task);
1072 dbi_unregister_all_uprobes(task, 1);
1073 us_proc_info.tgid = 0;
1074 for(i = 0; i < us_proc_info.libs_count; i++)
1075 us_proc_info.p_libs[i].loaded = 0;
1081 static int install_kernel_probe (unsigned long addr, int uflag, int kflag, kernel_probe_t ** pprobe)
1083 kernel_probe_t *probe = NULL;
1086 DPRINTF("us_proc_probes = 0x%x, uflag = 0x%x, "
1087 "probes_flags = 0x%x, kflag = 0x%x",
1088 us_proc_probes, uflag, probes_flags, kflag);
1090 if (!(probes_flags & kflag)) {
1091 iRet = add_probe_to_list (addr, &probe);
1093 EPRINTF ("add_probe_to_list(0x%lx) result=%d!", addr, iRet);
1096 probes_flags |= kflag;
1098 if (!(us_proc_probes & uflag)) {
1099 if (!(probes_flags & uflag)) {
1100 iRet = register_kernel_probe (probe);
1102 EPRINTF ("register_kernel_probe(0x%lx) result=%d!", addr, iRet);
1106 us_proc_probes |= uflag;
1115 static struct dentry *get_dentry(const char *path)
1117 #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 38)
1118 struct path st_path;
1119 if (kern_path(path, LOOKUP_FOLLOW, &st_path) != 0) {
1120 #else /* LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 38) */
1121 struct nameidata nd;
1122 if (path_lookup(path, LOOKUP_FOLLOW, &nd) != 0) {
1123 #endif /* LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 38) */
1124 EPRINTF("failed to lookup dentry for path %s!", path);
1128 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 25)
1130 #elif LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 38)
1131 return nd.path.dentry;
1132 #else /* LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 38) */
1133 return st_path.dentry;
1134 #endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 25) */
1137 int inst_usr_space_proc (void)
1140 struct task_struct *task = 0;
1141 inst_us_proc_t *task_inst_info = NULL;
1143 //if user-space instrumentation is not set
1144 if (!us_proc_info.path)
1147 DPRINTF("User space instr");
1150 launchpad_daemon_dentry = get_dentry("/usr/bin/launchpad_preloading_preinitializing_daemon");
1151 if (launchpad_daemon_dentry == NULL) {
1155 #endif /* SLP_APP */
1158 app_process_dentry = get_dentry("/system/bin/app_process");
1159 if (app_process_dentry == NULL) {
1163 android_app_vma_start = 0;
1164 android_app_vma_end = 0;
1165 #endif /* ANDROID_APP */
1168 if (is_java_inst_enabled()) {
1169 libdvm_dentry = get_dentry("/system/lib/libdvm.so");
1170 if (libdvm_dentry == NULL) {
1174 memset(&us_proc_info.libdvm_entry_ip, 0, sizeof(us_proc_ip_t));
1175 memset(&us_proc_info.libdvm_return_ip, 0, sizeof(us_proc_ip_t));
1176 us_proc_info.libdvm_start = 0;
1177 us_proc_info.libdvm_end = 0;
1179 #endif /* __ANDROID */
1181 for (i = 0; i < us_proc_info.libs_count; i++) {
1182 us_proc_info.p_libs[i].loaded = 0;
1184 /* check whether process is already running
1185 * 1) if process is running - look for the libraries in the process maps
1186 * 1.1) check if page for symbol does exist
1187 * 1.1.1) if page exists - instrument it
1188 * 1.1.2) if page does not exist - make sure that do_page_fault handler is installed
1189 * 2) if process is not running - make sure that do_page_fault handler is installed
1192 if (!strcmp(us_proc_info.path,"*"))
1194 clear_task_inst_info();
1195 for_each_process (task) {
1196 if (task->flags & PF_KTHREAD){
1197 DPRINTF("ignored kernel thread %d\n",
1202 task_inst_info = get_task_inst_node(task);
1203 if (!task_inst_info) {
1205 copy_task_inst_info(task,
1207 put_task_inst_node(task, task_inst_info);
1209 DPRINTF("trying process");
1211 if (is_java_inst_enabled()) {
1212 find_libdvm_for_task(task, task_inst_info);
1214 #endif /* __ANDROID */
1215 install_mapped_ips (task, task_inst_info, 1);
1216 //put_task_struct (task);
1217 task_inst_info = NULL;
1222 ret = find_task_by_path (us_proc_info.path, &task, NULL);
1225 DPRINTF("task found. installing probes");
1226 us_proc_info.tgid = task->pid;
1228 if (is_java_inst_enabled()) {
1229 find_libdvm_for_task(task, &us_proc_info);
1231 #endif /* __ANDROID */
1232 install_mapped_ips (task, &us_proc_info, 0);
1233 put_task_struct (task);
1237 // enable 'do_page_fault' probe to detect when they will be loaded
1238 ret = install_kernel_probe (pf_addr, US_PROC_PF_INSTLD, 0, &pf_probe);
1241 EPRINTF ("install_kernel_probe(do_page_fault) result=%d!", ret);
1244 // enable 'do_exit' probe to detect for remove task_struct
1245 ret = install_kernel_probe (exit_addr, US_PROC_EXIT_INSTLD, 0, &exit_probe);
1248 EPRINTF ("install_kernel_probe(do_exit) result=%d!", ret);
1251 /* enable 'copy_process' */
1252 ret = install_kernel_probe (cp_addr, US_PROC_CP_INSTLD, 0, &cp_probe);
1255 EPRINTF ("instpall_kernel_probe(copy_process) result=%d!", ret);
1259 // enable 'mm_release' probe to detect when for remove user space probes
1260 ret = install_kernel_probe (mr_addr, US_PROC_MR_INSTLD, 0, &mr_probe);
1263 EPRINTF ("install_kernel_probe(mm_release) result=%d!", ret);
1267 // enable 'do_munmap' probe to detect when for remove user space probes
1268 ret = install_kernel_probe (unmap_addr, US_PROC_UNMAP_INSTLD, 0, &unmap_probe);
1271 EPRINTF ("install_kernel_probe(do_munmap) result=%d!", ret);
1277 void do_page_fault_ret_pre_code (void)
1279 struct mm_struct *mm;
1280 struct vm_area_struct *vma = 0;
1281 inst_us_proc_t *task_inst_info = NULL;
1283 * Because process threads have same address space
1284 * we instrument only group_leader of all this threads
1286 struct task_struct *task = current->group_leader;
1288 //if user-space instrumentation is not set
1289 if (!us_proc_info.path)
1292 if (task->flags & PF_KTHREAD) {
1293 DPRINTF("ignored kernel thread %d\n", task->pid);
1298 if (!strcmp(us_proc_info.path,"*"))
1300 task_inst_info = get_task_inst_node(task);
1301 if (!task_inst_info)
1303 task_inst_info = copy_task_inst_info(task,
1305 put_task_inst_node(task, task_inst_info);
1307 if (is_java_inst_enabled()) {
1308 find_libdvm_for_task(task, task_inst_info);
1310 #endif /* __ANDROID */
1312 install_mapped_ips (task, task_inst_info, 1);
1316 task_inst_info = &us_proc_info;
1317 //DPRINTF("do_page_fault from proc %d-%d-%d", current->pid, task_inst_info->tgid, task_inst_info->unres_ips_count);
1318 if (!is_java_inst_enabled()
1319 && (task_inst_info->unres_ips_count + task_inst_info->unres_vtps_count
1320 + task_inst_info->unres_otg_ips_count) == 0)
1322 //DPRINTF("do_page_fault: there no unresolved IPs");
1326 if (task_inst_info->tgid == 0)
1328 mm = task->active_mm;
1331 // down_read (&mm->mmap_sem);
1335 if ((vma->vm_flags & VM_EXECUTABLE) && vma->vm_file)
1337 if (vma->vm_file->f_dentry == task_inst_info->m_f_dentry)
1342 if (is_slp_app_with_dentry(vma, task_inst_info->m_f_dentry)) {
1345 #endif /* SLP_APP */
1347 if (is_android_app_with_dentry(vma, task_inst_info->m_f_dentry)) {
1350 #endif /* ANDROID_APP */
1354 // up_read (&mm->mmap_sem);
1357 // DPRINTF ("proc %s/%d has no mm", current->comm, current->pid);
1361 DPRINTF ("do_page_fault found target proc %s(%d)", task->comm, task->pid);
1362 task_inst_info->tgid = task->pid;
1363 gl_nNotifyTgid = task->tgid;
1366 if (task_inst_info->tgid == task->tgid)
1368 //DPRINTF("do_page_fault from target proc %d", task_inst_info->tgid);
1370 if (is_java_inst_enabled()) {
1371 find_libdvm_for_task(task, &us_proc_info);
1373 #endif /* __ANDROID */
1374 install_mapped_ips (task, &us_proc_info, 1);
1376 //DPRINTF("do_page_fault from proc %d-%d exit", task->pid, task_inst_info->pid);
1379 EXPORT_SYMBOL_GPL(do_page_fault_ret_pre_code);
1382 void do_exit_probe_pre_code (void)
1384 // TODO: remove task
1386 EXPORT_SYMBOL_GPL(do_exit_probe_pre_code);
1388 static int check_addr(unsigned long addr, unsigned long start, size_t len)
1390 if ((addr >= start) && (addr < start + (unsigned long)len)) {
1397 static int remove_unmap_probes(struct task_struct *task, inst_us_proc_t* task_inst_info, unsigned long start, size_t len)
1400 us_proc_otg_ip_t *p;
1402 const int atomic = 1;
1404 for (i = 0; i < task_inst_info->libs_count; ++i) {
1405 for (k = 0; k < task_inst_info->p_libs[i].ips_count; ++k) {
1406 if (task_inst_info->p_libs[i].p_ips[k].installed) {
1407 addr = task_inst_info->p_libs[i].p_ips[k].jprobe.kp.addr;
1408 if (check_addr(addr, start, len)) {
1409 err = unregister_usprobe(task, &task_inst_info->p_libs[i].p_ips[k], atomic);
1411 EPRINTF("failed to uninstall IP at %p. Error %d!", task_inst_info->p_libs[i].p_ips[k].jprobe.kp.addr, err);
1414 task_inst_info->unres_ips_count++;
1415 task_inst_info->p_libs[i].p_ips[k].installed = 0;
1419 for (k = 0; k < task_inst_info->p_libs[i].vtps_count; ++k) {
1420 if (task_inst_info->p_libs[i].p_vtps[k].installed) {
1421 addr = task_inst_info->p_libs[i].p_vtps[k].jprobe.kp.addr;
1422 if (check_addr(addr, start, len)) {
1423 dbi_unregister_ujprobe(task, &task_inst_info->p_libs[i].p_vtps[k].jprobe, atomic);
1424 task_inst_info->unres_vtps_count++;
1425 task_inst_info->p_libs[i].p_vtps[k].installed = 0;
1431 if (is_java_inst_enabled()) {
1432 us_proc_ip_t *entp = &task_inst_info->libdvm_entry_ip;
1433 if (entp->installed) {
1434 addr = entp->jprobe.kp.addr;
1435 if (check_addr(addr, start, len)) {
1436 unregister_usprobe(task, entp, atomic);
1437 entp->installed = 0;
1440 us_proc_ip_t *retp = &task_inst_info->libdvm_return_ip;
1441 if (retp->installed) {
1442 addr = retp->jprobe.kp.addr;
1443 if (check_addr(addr, start, len)) {
1444 unregister_usprobe(task, retp, atomic);
1445 retp->installed = 0;
1449 #endif /* __ANDROID */
1450 list_for_each_entry_rcu (p, &otg_us_proc_info, list) {
1451 if (!p->ip.installed) {
1455 addr = p->ip.jprobe.kp.addr;
1456 if (check_addr(addr, start, len) == 0) {
1460 err = unregister_usprobe(task, &p->ip, atomic);
1462 EPRINTF("failed to uninstall IP at %p. Error %d!",
1463 p->ip.jprobe.kp.addr, err);
1466 p->ip.installed = 0;
1472 void do_munmap_probe_pre_code(struct mm_struct *mm, unsigned long start, size_t len)
1474 inst_us_proc_t *task_inst_info = NULL;
1475 struct task_struct *task = current;
1477 //if user-space instrumentation is not set
1478 if (!us_proc_info.path || task->tgid != task->pid)
1481 if (!strcmp(us_proc_info.path,"*")) {
1482 task_inst_info = get_task_inst_node(task);
1484 if (task->tgid == us_proc_info.tgid) {
1485 task_inst_info = &us_proc_info;
1489 if (task_inst_info) {
1490 remove_unmap_probes(task, task_inst_info, start, len);
1493 EXPORT_SYMBOL_GPL(do_munmap_probe_pre_code);
1495 void mm_release_probe_pre_code(void)
1498 struct task_struct *task;
1499 inst_us_proc_t *task_inst_info = NULL;
1501 //if user-space instrumentation is not set
1502 if (!us_proc_info.path || current->tgid != current->pid)
1505 if (!strcmp(us_proc_info.path,"*"))
1507 task_inst_info = get_task_inst_node(current);
1510 iRet = uninstall_mapped_ips (current, task_inst_info, 1);
1512 EPRINTF ("failed to uninstall IPs (%d)!", iRet);
1513 dbi_unregister_all_uprobes(current, 1);
1518 if (current->tgid != us_proc_info.tgid)
1521 // look for another process with the same tgid
1523 for_each_process (task)
1525 if ((task->pid != current->pid) && (task->tgid == us_proc_info.tgid))
1535 iRet = uninstall_mapped_ips (current, &us_proc_info, 1);
1537 EPRINTF ("failed to uninstall IPs (%d)!", iRet);
1538 dbi_unregister_all_uprobes(current, 1);
1539 us_proc_info.tgid = 0;
1540 for(i = 0; i < us_proc_info.libs_count; i++)
1541 us_proc_info.p_libs[i].loaded = 0;
1545 EXPORT_SYMBOL_GPL(mm_release_probe_pre_code);
1548 static void recover_child(struct task_struct *child_task, inst_us_proc_t *parent_iup)
1551 for(i = 0; i < parent_iup->libs_count; ++i)
1553 for(k = 0; k < parent_iup->p_libs[i].ips_count; ++k)
1554 if(parent_iup->p_libs[i].p_ips[k].installed)
1555 arch_disarm_uprobe(&parent_iup->p_libs[i].p_ips[k].jprobe.kp, child_task);
1557 for(k = 0; k < parent_iup->p_libs[i].vtps_count; ++k)
1558 if(parent_iup->p_libs[i].p_vtps[k].installed)
1559 arch_disarm_uprobe(&parent_iup->p_libs[i].p_vtps[k].jprobe.kp, child_task);
1563 static void rm_uprobes_child(struct task_struct *new_task)
1565 if(!strcmp(us_proc_info.path, "*")) {
1566 inst_us_proc_t *task_inst_info = get_task_inst_node(current);
1568 recover_child(new_task, task_inst_info);
1570 if(us_proc_info.tgid == current->tgid) {
1571 recover_child(new_task, &us_proc_info);
1576 void copy_process_ret_pre_code(struct task_struct *p)
1581 if(p->mm != current->mm) // check flags CLONE_VM
1582 rm_uprobes_child(p);
1586 DEFINE_PER_CPU (us_proc_ip_t *, gpCurIp) = NULL;
1587 EXPORT_PER_CPU_SYMBOL_GPL(gpCurIp);
1588 DEFINE_PER_CPU(struct pt_regs *, gpUserRegs) = NULL;
1589 EXPORT_PER_CPU_SYMBOL_GPL(gpUserRegs);
1592 unsigned long ujprobe_event_pre_handler (us_proc_ip_t * ip, struct pt_regs *regs)
1594 __get_cpu_var (gpCurIp) = ip;
1595 __get_cpu_var (gpUserRegs) = regs;
1600 int handle_java_event(unsigned long addr)
1602 unsigned long start = 0;
1603 struct pt_regs *regs = __get_cpu_var(gpUserRegs);
1605 if (!strcmp(us_proc_info.path, "*")) {
1606 /* TODO: some stuff here */
1608 start = us_proc_info.libdvm_start;
1610 unsigned long end = us_proc_info.libdvm_end;
1612 if (addr == start + LIBDVM_ENTRY) {
1613 unsigned long *p_met = (unsigned long *)regs->ARM_r0;
1614 char *met_name = p_met ? (char *)(p_met[4]) : 0;
1615 unsigned long *p_cl = p_met ? (unsigned long *)p_met[0] : 0;
1616 char *cl_name = p_cl ? (char *)(p_cl[6]) : 0;
1617 if (!cl_name || !met_name) {
1618 EPRINTF("warn: class name or method name null\n");
1620 pack_event_info(JAVA_PROBE_ID, RECORD_ENTRY, "pss", addr, cl_name, met_name);
1622 dbi_uprobe_return ();
1626 if (addr == start + LIBDVM_RETURN) {
1627 unsigned long *p_th = (unsigned long *)regs->ARM_r6;
1628 unsigned long *p_st = p_th;
1629 unsigned long *p_met = p_st ? (unsigned long *)p_st[2] : 0;
1630 char *met_name = p_met ? (char *)(p_met[4]) : 0;
1631 unsigned long *p_cl = p_met ? (unsigned long *)p_met[0] : 0;
1632 char *cl_name = p_cl ? (char *)(p_cl[6]) : 0;
1633 if (!cl_name || !met_name) {
1634 EPRINTF("warn: class name or method name null\n");
1636 pack_event_info(JAVA_PROBE_ID, RECORD_RET, "pss", addr, cl_name, met_name);
1638 dbi_uprobe_return ();
1644 #endif /* __ANDROID */
1646 void ujprobe_event_handler (unsigned long arg1, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5, unsigned long arg6)
1648 us_proc_ip_t *ip = __get_cpu_var (gpCurIp);
1649 unsigned long addr = (unsigned long)ip->jprobe.kp.addr;
1652 if (is_java_inst_enabled() && handle_java_event(addr)) {
1655 #endif /* __ANDROID */
1658 #if defined(CONFIG_ARM)
1659 if (ip->offset & 0x01)
1661 pack_event_info (US_PROBE_ID, RECORD_ENTRY, "ppppppp", addr | 0x01, arg1, arg2, arg3, arg4, arg5, arg6);
1663 pack_event_info (US_PROBE_ID, RECORD_ENTRY, "ppppppp", addr, arg1, arg2, arg3, arg4, arg5, arg6);
1666 pack_event_info (US_PROBE_ID, RECORD_ENTRY, "ppppppp", addr, arg1, arg2, arg3, arg4, arg5, arg6);
1668 // Mr_Nobody: uncomment for valencia
1669 //unregister_usprobe(current, ip, 1);
1670 dbi_uprobe_return ();
1673 void find_plt_address(unsigned long addr)
1675 inst_us_proc_t *task_inst_info = NULL;
1678 struct vm_area_struct *vma;
1679 us_proc_lib_t *p_lib = NULL;
1680 char *szLibPath = NULL;
1682 // Search for library structure to check whether this function plt or not
1683 if (strcmp(us_proc_info.path, "*")){
1684 // If app lib instrumentation
1685 task_inst_info = &us_proc_info;
1687 // If lib only instrumentation
1688 task_inst_info = get_task_inst_node(current);
1690 if ((task_inst_info != NULL) && (task_inst_info->is_plt != 0)) {
1691 for (i = 0; i < task_inst_info->libs_count; i++)
1693 if ((task_inst_info->p_libs[i].loaded)
1694 && (task_inst_info->p_libs[i].plt_count > 0)
1695 && (addr > task_inst_info->p_libs[i].vma_start)
1696 && (addr < task_inst_info->p_libs[i].vma_end))
1698 p_lib = &(task_inst_info->p_libs[i]);
1702 if (p_lib != NULL) {
1703 for (i = 0; i < p_lib->plt_count; i++)
1705 if (addr == p_lib->p_plt[i].func_addr + p_lib->vma_start) {
1706 unsigned long real_got;
1707 if (strcmp(p_lib->path, task_inst_info->path)) {
1708 real_got = p_lib->p_plt[i].got_addr - 0x8000 + p_lib->vma_start;
1710 real_got = p_lib->p_plt[i].got_addr;
1712 if (!read_proc_vm_atomic(current, (unsigned long)(real_got), &real_addr, sizeof(unsigned long))) {
1713 printk("Failed to read got %p at memory address %p!\n", p_lib->p_plt[i].got_addr, real_got);
1716 if (real_addr != p_lib->p_plt[i].real_func_addr) {
1717 p_lib->p_plt[i].real_func_addr = real_addr;
1718 vma = find_vma(current->mm, real_addr);
1719 if ((vma->vm_start <= real_addr) && (vma->vm_end > real_addr)) {
1720 if (vma->vm_file != NULL) {
1721 szLibPath = &(vma->vm_file->f_dentry->d_iname);
1725 pack_event_info(PLT_ADDR_PROBE_ID, RECORD_RET, "ppsp", addr, real_addr, szLibPath, real_addr - vma->vm_start);
1728 pack_event_info(PLT_ADDR_PROBE_ID, RECORD_RET, "ppp", addr, real_addr, real_addr - vma->vm_start);
1740 int uretprobe_event_handler (struct kretprobe_instance *probe, struct pt_regs *regs, us_proc_ip_t * ip)
1742 int retval = regs_return_value(regs);
1743 unsigned long addr = (unsigned long)ip->jprobe.kp.addr;
1745 find_plt_address(addr);
1747 #if defined(CONFIG_ARM)
1748 if (ip->offset & 0x01)
1750 pack_event_info (US_PROBE_ID, RECORD_RET, "pd", addr | 0x01, retval);
1752 pack_event_info (US_PROBE_ID, RECORD_RET, "pd", addr, retval);
1755 pack_event_info (US_PROBE_ID, RECORD_RET, "pd", addr, retval);
1757 // Mr_Nobody: uncomment for valencia
1758 //unregister_usprobe(current, ip, 1);
1762 static int register_usprobe (struct task_struct *task, struct mm_struct *mm, us_proc_ip_t * ip, int atomic, kprobe_opcode_t * islot)
1765 ip->jprobe.kp.tgid = task->tgid;
1766 //ip->jprobe.kp.addr = (kprobe_opcode_t *) addr;
1767 if(!ip->jprobe.entry) {
1768 if (dbi_ujprobe_event_handler_custom_p != NULL)
1770 ip->jprobe.entry = (kprobe_opcode_t *) dbi_ujprobe_event_handler_custom_p;
1771 DPRINTF("Set custom event handler for %x\n", ip->offset);
1775 ip->jprobe.entry = (kprobe_opcode_t *) ujprobe_event_handler;
1776 DPRINTF("Set default event handler for %x\n", ip->offset);
1779 if(!ip->jprobe.pre_entry) {
1780 if (dbi_ujprobe_event_pre_handler_custom_p != NULL)
1782 ip->jprobe.pre_entry = (kprobe_pre_entry_handler_t) dbi_ujprobe_event_pre_handler_custom_p;
1783 DPRINTF("Set custom pre handler for %x\n", ip->offset);
1787 ip->jprobe.pre_entry = (kprobe_pre_entry_handler_t) ujprobe_event_pre_handler;
1788 DPRINTF("Set default pre handler for %x\n", ip->offset);
1791 ip->jprobe.priv_arg = ip;
1792 ret = dbi_register_ujprobe (task, mm, &ip->jprobe, atomic);
1795 DPRINTF ("dbi_register_ujprobe() failure %d", ret);
1799 // Mr_Nobody: comment for valencia
1800 ip->retprobe.kp.tgid = task->tgid;
1801 //ip->retprobe.kp.addr = (kprobe_opcode_t *) addr;
1802 if(!ip->retprobe.handler) {
1803 if (dbi_uretprobe_event_handler_custom_p != NULL)
1804 ip->retprobe.handler = (kretprobe_handler_t) dbi_uretprobe_event_handler_custom_p;
1806 ip->retprobe.handler = (kretprobe_handler_t) uretprobe_event_handler;
1807 //DPRINTF("Failed custom dbi_uretprobe_event_handler_custom_p");
1810 ip->retprobe.priv_arg = ip;
1811 ret = dbi_register_uretprobe (task, mm, &ip->retprobe, atomic);
1814 EPRINTF ("dbi_register_uretprobe() failure %d", ret);
1820 static int unregister_usprobe (struct task_struct *task, us_proc_ip_t * ip, int atomic)
1822 dbi_unregister_ujprobe (task, &ip->jprobe, atomic);
1823 dbi_unregister_uretprobe (task, &ip->retprobe, atomic);
1827 unsigned long get_stack_size(struct task_struct *task,
1828 struct pt_regs *regs)
1830 #ifdef CONFIG_ADD_THREAD_STACK_INFO
1831 return (task->stack_start - dbi_get_stack_ptr(regs));
1833 struct vm_area_struct *vma = NULL;
1834 struct mm_struct *mm = NULL;
1835 unsigned long result = 0;
1836 int atomic = in_atomic();
1838 mm = (atomic ? task->active_mm: get_task_mm(task));
1842 down_read(&mm->mmap_sem);
1844 vma = find_vma(mm, dbi_get_stack_ptr(regs));
1847 result = vma->vm_end - dbi_get_stack_ptr(regs);
1852 up_read(&mm->mmap_sem);
1860 EXPORT_SYMBOL_GPL(get_stack_size);
1862 unsigned long get_stack(struct task_struct *task, struct pt_regs *regs,
1863 char *buf, unsigned long sz)
1865 unsigned long stack_sz = get_stack_size(task, regs);
1866 unsigned long real_sz = (stack_sz > sz ? sz: stack_sz);
1867 int res = read_proc_vm_atomic(task, dbi_get_stack_ptr(regs), buf, real_sz);
1870 EXPORT_SYMBOL_GPL(get_stack);
1872 int dump_to_trace(probe_id_t probe_id, void *addr, const char *buf,
1875 unsigned long rest_sz = sz;
1876 const char *data = buf;
1878 while (rest_sz >= EVENT_MAX_SIZE) {
1879 pack_event_info(probe_id, RECORD_ENTRY, "pa",
1880 addr, EVENT_MAX_SIZE, data);
1881 rest_sz -= EVENT_MAX_SIZE;
1882 data += EVENT_MAX_SIZE;
1886 pack_event_info(probe_id, RECORD_ENTRY, "pa", addr, rest_sz, data);
1890 EXPORT_SYMBOL_GPL(dump_to_trace);
1892 int dump_backtrace(probe_id_t probe_id, struct task_struct *task,
1893 void *addr, struct pt_regs *regs, unsigned long sz)
1895 unsigned long real_sz = 0;
1898 buf = (char *)kmalloc(sz, GFP_ATOMIC);
1901 real_sz = get_stack(task, regs, buf, sz);
1903 dump_to_trace(probe_id, addr, buf, real_sz);
1910 EXPORT_SYMBOL_GPL(dump_backtrace);
1912 unsigned long get_ret_addr(struct task_struct *task, us_proc_ip_t *ip)
1914 unsigned long retaddr = 0;
1915 struct hlist_node *item, *tmp_node;
1916 struct kretprobe_instance *ri;
1919 hlist_for_each_safe (item, tmp_node, &ip->retprobe.used_instances) {
1920 ri = hlist_entry (item, struct kretprobe_instance, uflist);
1922 if (ri->task && ri->task->pid == task->pid &&
1923 ri->task->tgid == task->tgid)
1924 retaddr = (unsigned long)ri->ret_addr;
1931 return dbi_get_ret_addr(task_pt_regs(task));
1933 EXPORT_SYMBOL_GPL(get_ret_addr);
1935 /*function call removes all OTG-probes installed in library "lib_to_delete"*/
1936 void otg_probe_list_clean(char* lib_to_delete)
1938 struct task_struct *task = current->group_leader;
1939 struct mm_struct *mm;
1940 struct vm_area_struct *vma = 0;
1941 char *filename = "";
1943 unsigned long int addr_max = 0;
1944 unsigned long int addr_min = 0;
1946 us_proc_otg_ip_t *p;
1948 mm = task->active_mm;
1949 /*find in process space map file with name "lib_to_delete" and flag VM_EXEC
1950 and save address borders of this file*/
1955 if(vma->vm_file->f_dentry) {
1956 filename = d_path(&vma->vm_file->f_path, buf, 256);
1957 if((strcmp(lib_to_delete, filename) == 0) && (vma->vm_flags & VM_EXEC)) {
1958 addr_min = vma->vm_start;
1959 addr_max = vma->vm_end;
1967 /*remove OTG-probe if its address is between addr_min and addr_max*/
1968 list_for_each_entry_rcu (p, &otg_us_proc_info, list) {
1969 if (!p->ip.installed) {
1972 if ( ((unsigned long)p->ip.jprobe.kp.addr < addr_max) &&
1973 ((unsigned long)p->ip.jprobe.kp.addr >= addr_min) ) {
1974 err = unregister_usprobe(task, &p->ip, 1);
1976 EPRINTF("failed to uninstall IP at %p. Error %d!",
1977 p->ip.jprobe.kp.addr, err);
1980 p->ip.installed = 0;
1984 EXPORT_SYMBOL_GPL(otg_probe_list_clean);