Gecko [ dataharbor.africa ]

Name	Size	Permission
?;uprobes	[ DIR ]	drwxr-xr-x
?;uprobes2	[ DIR ]	drwxr-xr-x
access_process_vm.h	3.59 KB	-rw-r--r--
addr-map.c	8.03 KB	-rw-r--r--
alloc.c	15.02 KB	-rw-r--r--
arith.c	16.41 KB	-rw-r--r--
autoconf-alloc-percpu-align.c	118 B	-rw-r--r--
autoconf-asm-syscall.c	26 B	-rw-r--r--
autoconf-bio-bi_opf.c	824 B	-rw-r--r--
autoconf-blk-types.c	359 B	-rw-r--r--
autoconf-compat_sigaction.c	448 B	-rw-r--r--
autoconf-constant-tsc.c	63 B	-rw-r--r--
autoconf-cpu-clock.c	1.25 KB	-rw-r--r--
autoconf-dpath-path.c	121 B	-rw-r--r--
autoconf-from_kuid_munged.c	191 B	-rw-r--r--
autoconf-fs_supers-hlist.c	354 B	-rw-r--r--
autoconf-generated-compile.c	56 B	-rw-r--r--
autoconf-get_user_pages_remote...	1.51 KB	-rw-r--r--
autoconf-get_user_pages_remote...	1.3 KB	-rw-r--r--
autoconf-grsecurity.c	219 B	-rw-r--r--
autoconf-hlist-4args.c	296 B	-rw-r--r--
autoconf-hrtimer-getset-expire...	126 B	-rw-r--r--
autoconf-hrtimer-rel.c	87 B	-rw-r--r--
autoconf-hw_breakpoint_context...	315 B	-rw-r--r--
autoconf-inode-private.c	173 B	-rw-r--r--
autoconf-inode-rwsem.c	172 B	-rw-r--r--
autoconf-inode-uretprobes.c	264 B	-rw-r--r--
autoconf-kallsyms-on-each-symb...	192 B	-rw-r--r--
autoconf-kprobe-symbol-name.c	90 B	-rw-r--r--
autoconf-ktime-get-real.c	98 B	-rw-r--r--
autoconf-linux-sched_headers.c	1.64 KB	-rw-r--r--
autoconf-local-clock.c	1.25 KB	-rw-r--r--
autoconf-mm-context-vdso-base....	117 B	-rw-r--r--
autoconf-mm-context-vdso.c	114 B	-rw-r--r--
autoconf-mod_kallsyms.c	51 B	-rw-r--r--
autoconf-module-sect-attrs.c	158 B	-rw-r--r--
autoconf-module_layout.c	52 B	-rw-r--r--
autoconf-nameidata.c	96 B	-rw-r--r--
autoconf-netfilter-313b.c	602 B	-rw-r--r--
autoconf-netfilter-4_1.c	769 B	-rw-r--r--
autoconf-netfilter-4_4.c	1.43 KB	-rw-r--r--
autoconf-netfilter.c	422 B	-rw-r--r--
autoconf-old-inode-uprobes.c	357 B	-rw-r--r--
autoconf-oneachcpu-retry.c	957 B	-rw-r--r--
autoconf-pagefault_disable.c	137 B	-rw-r--r--
autoconf-perf-structpid.c	444 B	-rw-r--r--
autoconf-procfs-owner.c	158 B	-rw-r--r--
autoconf-real-parent.c	427 B	-rw-r--r--
autoconf-regset.c	239 B	-rw-r--r--
autoconf-relay-umode_t.c	730 B	-rw-r--r--
autoconf-relay_buf-per_cpu_ptr...	920 B	-rw-r--r--
autoconf-ring_buffer-flags.c	112 B	-rw-r--r--
autoconf-ring_buffer_lost_even...	296 B	-rw-r--r--
autoconf-ring_buffer_read_prep...	181 B	-rw-r--r--
autoconf-save-stack-trace-no-b...	498 B	-rw-r--r--
autoconf-save-stack-trace.c	501 B	-rw-r--r--
autoconf-smpcall-4args.c	166 B	-rw-r--r--
autoconf-smpcall-5args.c	169 B	-rw-r--r--
autoconf-stacktrace_ops-int-ad...	409 B	-rw-r--r--
autoconf-stacktrace_ops-warnin...	188 B	-rw-r--r--
autoconf-task-uid.c	152 B	-rw-r--r--
autoconf-task_work-struct.c	219 B	-rw-r--r--
autoconf-timerfd.c	232 B	-rw-r--r--
autoconf-trace-printk.c	151 B	-rw-r--r--
autoconf-tracepoint-strings.c	233 B	-rw-r--r--
autoconf-uaccess.c	28 B	-rw-r--r--
autoconf-udelay_simple.c	90 B	-rw-r--r--
autoconf-uidgid.c	50 B	-rw-r--r--
autoconf-unwind-stack-trace.c	326 B	-rw-r--r--
autoconf-uprobe-get-pc.c	374 B	-rw-r--r--
autoconf-utrace-regset.c	273 B	-rw-r--r--
autoconf-utrace-via-tracepoint...	1.67 KB	-rw-r--r--
autoconf-vm-area-pte.c	141 B	-rw-r--r--
autoconf-walk-stack.c	217 B	-rw-r--r--
autoconf-x86-fs.c	90 B	-rw-r--r--
autoconf-x86-gs.c	90 B	-rw-r--r--
autoconf-x86-uniregs.c	115 B	-rw-r--r--
autoconf-x86-xfs.c	91 B	-rw-r--r--
common_session_state.h	2.93 KB	-rw-r--r--
compat_net.h	858 B	-rw-r--r--
compat_structs.h	4.31 KB	-rw-r--r--
compat_unistd.h	60.25 KB	-rw-r--r--
copy.c	2.58 KB	-rw-r--r--
debug.h	2.5 KB	-rw-r--r--
io.c	4.6 KB	-rw-r--r--
itrace.c	14.53 KB	-rw-r--r--
kprobes.c	22.57 KB	-rw-r--r--
loc2c-runtime.h	23.87 KB	-rw-r--r--
map_list.h	1.19 KB	-rw-r--r--
map_runtime.h	4.12 KB	-rw-r--r--
namespaces.h	6.96 KB	-rw-r--r--
netfilter.c	1.38 KB	-rw-r--r--
perf.c	7.42 KB	-rw-r--r--
perf.h	1.22 KB	-rw-r--r--
perf_event_counter_context.c	336 B	-rw-r--r--
perf_probe_handler_nmi.c	278 B	-rw-r--r--
perf_read.h	959 B	-rw-r--r--
print.c	5.85 KB	-rw-r--r--
probe_lock.h	1.69 KB	-rw-r--r--
regs-ia64.c	3.65 KB	-rw-r--r--
regs.c	12.63 KB	-rw-r--r--
runtime.h	10.55 KB	-rw-r--r--
runtime_context.h	4.75 KB	-rw-r--r--
runtime_defines.h	1.02 KB	-rw-r--r--
stat_runtime.h	1.7 KB	-rw-r--r--
stp_tracepoint.c	11.07 KB	-rw-r--r--
stp_tracepoint.h	2.1 KB	-rw-r--r--
syscalls-common.h	976 B	-rw-r--r--
task_finder.c	52.17 KB	-rw-r--r--
task_finder2.c	53.5 KB	-rw-r--r--
task_finder_map.c	5.07 KB	-rw-r--r--
task_finder_stubs.c	2.38 KB	-rw-r--r--
task_work_compatibility.h	1.25 KB	-rw-r--r--
timer.c	2.15 KB	-rw-r--r--
timer.h	1.35 KB	-rw-r--r--
timer_compatibility.h	2.26 KB	-rw-r--r--
uprobes-common.c	15.21 KB	-rw-r--r--
uprobes-common.h	1.61 KB	-rw-r--r--
uprobes-inc.h	484 B	-rw-r--r--
uprobes-inode.c	22.79 KB	-rw-r--r--

Code Editor : uprobes-common.c

/* -*- linux-c -*- 
 * uprobe Functions
 * Copyright (C) 2014 Red Hat Inc.
 *
 * This file is part of systemtap, and is free software.  You can
 * redistribute it and/or modify it under the terms of the GNU General
 * Public License (GPL); either version 2, or (at your option) any
 * later version.
 */

#ifndef _UPROBE_COMMON_C_
#define _UPROBE_COMMON_C_

/* NB: Because these utrace callbacks only occur before / after
   userspace instructions run, there is no concurrency control issue
   between active uprobe callbacks and these registration /
   unregistration pieces.

We protect the stap_uprobe->spec_index (which also serves as a
   free/busy flag) value with the outer protective stap_probes_lock
   spinlock, to protect it against concurrent registration /
   unregistration.
*/

static int stap_uprobe_change_plus (struct task_struct *tsk, unsigned long relocation, unsigned long length, const struct stap_uprobe_tf *stf, unsigned long offset, unsigned long vm_flags) {
  int tfi = (stf - stap_uprobe_finders);
  int spec_index;
  /* iterate over stap_uprobe_spec[] that use this same stap_uprobe_tf */
  for (spec_index=0; spec_index<sizeof(stap_uprobe_specs)/sizeof(stap_uprobe_specs[0]); spec_index++) {
    int handled_p = 0;
    int slotted_p = 0;
    const struct stap_uprobe_spec *sups = &stap_uprobe_specs [spec_index];
    struct stap_uprobe *sup;
    pid_t sdt_sem_pid;
    int rc = 0;
    int i;
    int pci;
    
    if (likely(sups->tfi != tfi)) continue;
    /* skip probes with an address beyond this map event; should not 
       happen unless a shlib/exec got mmapped in weirdly piecemeal */
    if (likely((vm_flags & VM_EXEC) && sups->address >= length)) continue;

/* Found a uprobe_spec for this stap_uprobe_tf.  Need to lock the
       stap_uprobes[] array to allocate a free spot, but then we can
       unlock and do the register_*probe subsequently. */

might_sleep();
    mutex_lock (& stap_uprobes_lock);
    for (i=0; i<MAXUPROBES; i++) { /* XXX: slow linear search */
      sup = & stap_uprobes[i];

/* register new uprobe
	 We make two passes for semaphores;
	 see stap_uprobe_change_semaphore_plus */
 
      if (sup->spec_index < 0 || (sups->sdt_sem_offset && vm_flags & VM_WRITE && sup->spec_index == spec_index)) {
        #if (UPROBES_API_VERSION < 2)
	/* See PR6829 comment. */
        if (sup->spec_index == -1 && sup->up.kdata != NULL) continue;
        else if (sup->spec_index == -2 && sup->urp.u.kdata != NULL) continue;
        #endif
        sup->spec_index = spec_index;
        slotted_p = 1;
        break;
      }
    }
    mutex_unlock (& stap_uprobes_lock);
    #ifdef DEBUG_UPROBES
    _stp_dbug(__FUNCTION__,__LINE__, "+uprobe spec %d idx %d process %s[%d] addr %p pp %s\n", spec_index, (slotted_p ? i : -1), tsk->comm, tsk->tgid, (void*)(relocation+sups->address), sups->probe->pp);
    #endif

/* NB: check for user-module build-id only if we have a pathname
       at all; for a process(PID#).* probe, we may not.  If at some
       point we map process(PID#) to process("/proc/PID#/exe"), we'll
       get a pathname. */
    if (stf->pathname)
            if ((rc = _stp_usermodule_check(tsk, stf->pathname, relocation)))
                    return rc;

/* Here, slotted_p implies that `i' points to the single
       stap_uprobes[] element that has been slotted in for registration
       or unregistration processing.  !slotted_p implies that the table
       was full (registration; MAXUPROBES) or that no matching entry was
       found (unregistration; should not happen). */

sdt_sem_pid = (sups->return_p ? sup->urp.u.pid : sup->up.pid);
    if (sups->sdt_sem_offset && (sdt_sem_pid != tsk->tgid || sup->sdt_sem_address == 0)) {
      /* If the probe is in an ET_EXEC binary, then the sdt_sem_offset already
       * is a real address.  But stap_uprobe_process_found calls us in this
       * case with relocation=offset=0, so we don't have to worry about it.  */
      sup->sdt_sem_address = (relocation - offset) + sups->sdt_sem_offset;
    } /* sdt_sem_offset */

for (pci=0; pci < sups->perf_counters_dim; pci++) {
	if ((sups->perf_counters)[pci] > -1)
	  _stp_perf_read_init ((sups->perf_counters)[pci], tsk);
      }

if (slotted_p) {
      struct stap_uprobe *sup = & stap_uprobes[i];
      if (sups->return_p) {
        sup->urp.u.pid = tsk->tgid;
        sup->urp.u.vaddr = relocation + sups->address;
        sup->urp.handler = &enter_uretprobe_probe;
        rc = register_uretprobe (& sup->urp);
      } else {
        sup->up.pid = tsk->tgid;
        sup->up.vaddr = relocation + sups->address;
        sup->up.handler = &enter_uprobe_probe;
        rc = register_uprobe (& sup->up);
      }

/* The u*probe failed to register.  However, if we got EEXIST,
       * that means that the u*probe is already there, so just ignore
       * the error.  This could happen if CLONE_THREAD or CLONE_VM was
       * used. */
      if (rc != 0 && rc != -EEXIST) {
        _stp_warn ("u*probe failed %s[%d] '%s' addr %p rc %d\n", tsk->comm, tsk->tgid, sups->probe->pp, (void*)(relocation + sups->address), rc);
	/* NB: we need to release this slot,
	   so we need to borrow the mutex temporarily. */
	might_sleep();
        mutex_lock (& stap_uprobes_lock);
        sup->spec_index = -1;
	sup->sdt_sem_address = 0;
        mutex_unlock (& stap_uprobes_lock);
      } else {
        handled_p = 1;
      }
    }
    /* NB: handled_p implies slotted_p */
    if (unlikely (! handled_p)) {
      #ifdef STP_TIMING
      atomic_inc (skipped_count_uprobe_reg());
      #endif
      /* NB: duplicates common_entryfn_epilogue,
	 but then this is not a probe entry fn epilogue. */
#ifndef STAP_SUPPRESS_HANDLER_ERRORS
      if (unlikely (atomic_inc_return (skipped_count()) > MAXSKIPPED)) {
        if (unlikely (pseudo_atomic_cmpxchg(session_state(), STAP_SESSION_RUNNING, STAP_SESSION_ERROR) == STAP_SESSION_RUNNING))
          _stp_error ("Skipped too many probes, check MAXSKIPPED or try again with stap -t for more details.");
      }
#endif
    }
  }  /* close iteration over stap_uprobe_spec[] */
  return 0; /* XXX: or rc? */
}

static int stap_uprobe_change_semaphore_plus (struct task_struct *tsk, unsigned long relocation, unsigned long length, const struct stap_uprobe_tf *stf) {
  int tfi = (stf - stap_uprobe_finders);
  int spec_index;
  int rc = 0;
  struct stap_uprobe *sup;
  int i;

/* We make two passes for semaphores.
     The first pass, stap_uprobe_change_plus, calculates the address of the   
     semaphore.  If the probe is in a .so, we calculate the 
     address when the initial mmap maps the entire solib, e.g.
     7f089885a000-7f089885b000  rw-p-  libtcl.so
     A subsequent mmap maps in the writable segment where the 
     semaphore control variable lives, e.g.
     7f089850d000-7f0898647000  r-xp-  libtcl.so
     7f0898647000-7f0898846000  ---p   libtcl.so
     7f0898846000-7f089885b000  rw-p-  libtcl.so
     The second pass, stap_uprobe_change_semaphore_plus, sets the semaphore.
     If the probe is in a .so this will be when the writable segment of the .so
     is mapped in.  If the task changes, then recalculate the address.
  */

for (i=0; i<MAXUPROBES; i++) {  /* XXX: slow linear search */
    sup = & stap_uprobes[i];
    if (sup->spec_index == -1) continue;
    if (sup->sdt_sem_address != 0 && !(sup->up.pid == tsk->tgid && sup->sdt_sem_address >= relocation && sup->sdt_sem_address < relocation+length)) continue;
    if (sup->sdt_sem_address) {
      unsigned short sdt_semaphore = 0; /* NB: fixed size */
      if ((rc = get_user (sdt_semaphore, (unsigned short __user*) sup->sdt_sem_address)) == 0) {
        sdt_semaphore ++;
        #ifdef DEBUG_UPROBES
        {
          const struct stap_uprobe_spec *sups = &stap_uprobe_specs [sup->spec_index];
          _stp_dbug(__FUNCTION__,__LINE__, "+semaphore %#x @ %#lx spec %d idx %d task %d\n", sdt_semaphore, sup->sdt_sem_address, sup->spec_index, i, tsk->tgid);
        }
        #endif
	rc = put_user (sdt_semaphore, (unsigned short __user*) sup->sdt_sem_address);
	/* XXX: need to analyze possibility of race condition */
      }
    }
  }
  return rc;
}

/* Removing/unmapping a uprobe is simpler than adding one (in the
  _plus function above).  We need not care about stap_uprobe_finders
  or anything, we just scan through stap_uprobes[] for a live probe
  within the given address range, and kill it.  */
static int stap_uprobe_change_minus (struct task_struct *tsk, unsigned long relocation, unsigned long length, const struct stap_uprobe_tf *stf) {
  int i;

/* NB: it's not an error for us not to find a live uprobe within the
     given range.  We might have received a callback for a part of a
     shlib that was unmapped and unprobed. */

for (i=0; i<MAXUPROBES; i++) { /* XXX: slow linear search */
    struct stap_uprobe *sup = & stap_uprobes[i];
    struct stap_uprobe_spec *sups;
    if (sup->spec_index < 0) continue; /* skip free uprobes slot */
    sups = (struct stap_uprobe_spec*) & stap_uprobe_specs[sup->spec_index];
    might_sleep();
    mutex_lock (& stap_uprobes_lock);

/* PR6829, PR9940:
       Here we're unregistering for one of two reasons:
       1. the process image is going away (or gone) due to exit or exec; or
       2. the vma containing the probepoint has been unmapped.
       In case 1, it's sort of a nop, because uprobes will notice the event
       and dispose of the probes eventually, if it hasn't already.  But by
       calling unmap_u[ret]probe() ourselves, we free up sup right away.
       
       In both cases, we must use unmap_u[ret]probe instead of
       unregister_u[ret]probe, so uprobes knows not to try to restore the
       original opcode.
    */

/* URETPROBE */
    if (sups->return_p && sup->urp.u.pid == tsk->tgid && sup->urp.u.vaddr >= relocation && sup->urp.u.vaddr < relocation+length) { /* in range */
      
      #ifdef DEBUG_UPROBES
      _stp_dbug (__FUNCTION__,__LINE__, "-uretprobe spec %d idx %d process %s[%d] addr %p pp %s\n", sup->spec_index, i, tsk->comm, tsk->tgid, (void*) sup->urp.u.vaddr, sups->probe->pp);
      #endif
      #if (UPROBES_API_VERSION >= 2)
      unmap_uretprobe (& sup->urp);
      sup->spec_index = -1;
      sup->sdt_sem_address = 0;
      #else
      /* Uprobes lacks unmap_uretprobe.  Before reusing sup, we must wait
	 until uprobes turns loose of the uretprobe on its own, as indicated
	 by uretprobe.kdata = NULL. */
      sup->spec_index = -2;
      #endif
      /* UPROBE */
    } else if (!sups->return_p && sup->up.pid == tsk->tgid && sup->up.vaddr >= relocation && sup->up.vaddr < relocation+length) { /* in range */
      
      #ifdef DEBUG_UPROBES
      _stp_dbug (__FUNCTION__,__LINE__, "-uprobe spec %d idx %d process %s[%d] reloc %p pp %s\n", sup->spec_index, i, tsk->comm, tsk->tgid, (void*) sup->up.vaddr, sups->probe->pp);
      #endif
      #if (UPROBES_API_VERSION >= 2)
      unmap_uprobe (& sup->up);
      sup->spec_index = -1;
      sup->sdt_sem_address = 0;
      #else
      /* Uprobes lacks unmap_uprobe.  Before reusing sup, we must wait
	 until uprobes turns loose of the uprobe on its own, as indicated
	 by uprobe.kdata = NULL. */
      sup->spec_index = -1;
      sup->sdt_sem_address = 0;
      #endif
      /* PR10655: we don't need to fidget with the ENABLED semaphore either,
	 as the process is gone, buh-bye, toodaloo, au revoir, see ya later! */
    }
    mutex_unlock (& stap_uprobes_lock);
  }  /* close iteration over stap_uprobes[] */
  return 0; /* XXX: or !handled_p */
}

/* The task_finder_callback we use for ET_EXEC targets.
   We used to perform uprobe insertion/removal here, but not any more.
   (PR10524) */
static int stap_uprobe_process_found (struct stap_task_finder_target *tgt, struct task_struct *tsk, int register_p, int process_p) {
  const struct stap_uprobe_tf *stf = container_of(tgt, struct stap_uprobe_tf, finder);
  if (! process_p) return 0; /* ignore threads */
  dbug_task_vma(1, "%cproc pid %d stf %p %p path %s\n", register_p?'+':'-', tsk->tgid, tgt, stf, stf->pathname);
  /* ET_EXEC events are like shlib events, but with 0 relocation bases */
  if (register_p) {
    int rc = stap_uprobe_change_plus (tsk, 0, TASK_SIZE, stf, 0, 0);
    stap_uprobe_change_semaphore_plus (tsk, 0, TASK_SIZE, stf);
    return rc;
  } else
    return stap_uprobe_change_minus (tsk, 0, TASK_SIZE, stf);
}

/* The task_finder_mmap_callback */
static int
stap_uprobe_mmap_found (struct stap_task_finder_target *tgt,
                        struct task_struct *tsk, char *path,
                        struct dentry *dentry, unsigned long addr,
                        unsigned long length, unsigned long offset,
                        unsigned long vm_flags)
{
  int rc = 0;
  const struct stap_uprobe_tf *stf = container_of(tgt, struct stap_uprobe_tf, finder);
  /* 1 - shared libraries' executable segments load from offset 0
   *   - ld.so convention offset != 0 is now allowed
   *     so stap_uprobe_change_plus can set a semaphore,
   *     i.e. a static extern, in a shared object
   * 2 - the shared library we're interested in
   * 3 - mapping should be executable or writable (for semaphore in .so)
   *     NB: or both, on kernels that lack noexec mapping
   */
  if (path == NULL || strcmp (path, stf->pathname))
    return 0;

/* Check non-writable, executable sections for probes. */
  if ((vm_flags & VM_EXEC) && !(vm_flags & VM_WRITE)) {
    dbug_task_vma (1,
               "+mmap X pid %d path %s addr %p length %u offset %p stf %p %p path %s\n",
               tsk->tgid, path, (void *) addr, (unsigned)length, (void*) offset,
               tgt, stf, stf->pathname);
    rc = stap_uprobe_change_plus (tsk, addr, length, stf, offset, vm_flags);
  }

/* Check writable sections for semaphores.
   * NB: They may have also been executable for the check above, if we're
   *     running a kernel that lacks noexec mappings.  So long as there's
   *     no error (rc == 0), we need to look for semaphores too.
   */
  if ((rc == 0) && (vm_flags & VM_WRITE)) {
    dbug_task_vma (1,
               "+mmap W pid %d path %s addr %p length %u offset %p stf %p %p path %s\n",
               tsk->tgid, path, (void *) addr, (unsigned)length, (void*) offset,
               tgt, stf, stf->pathname);
    rc = stap_uprobe_change_semaphore_plus (tsk, addr, length, stf);
  }

return rc;
}

/* The task_finder_munmap_callback */
static int stap_uprobe_munmap_found (struct stap_task_finder_target *tgt, struct task_struct *tsk, unsigned long addr, unsigned long length) {
  const struct stap_uprobe_tf *stf = container_of(tgt, struct stap_uprobe_tf, finder);
  dbug_task_vma (1, "-mmap pid %d addr %p length %lu stf %p %p path %s\n", tsk->tgid, (void *) addr, length, tgt, stf, stf->pathname);
  return stap_uprobe_change_minus (tsk, addr, length, stf);
}

/* The task_finder_callback we use for ET_DYN targets.
   This just forces an unmap of everything as the process exits.
   (PR11151) */
static int stap_uprobe_process_munmap (struct stap_task_finder_target *tgt, struct task_struct *tsk, int register_p, int process_p) {
  const struct stap_uprobe_tf *stf = container_of(tgt, struct stap_uprobe_tf, finder);
  if (! process_p) return 0; /* ignore threads */
  dbug_task_vma (1, "%cproc pid %d stf %p %p path %s\n", register_p?'+':'-', tsk->tgid, tgt, stf, stf->pathname);
  /* Covering 0->TASK_SIZE means "unmap everything" */
  if (!register_p)
    return stap_uprobe_change_minus (tsk, 0, TASK_SIZE, stf);
  return 0;
}

#endif /* _UPROBE_COMMON_C_ */

${this.title}

Code Editor : uprobes-common.c