Unreachable code

|enum x86_regset {
| REGSET_GENERAL,
| REGSET_FP,
| REGSET_XFP,
| REGSET_IOPERM64 = REGSET_XFP,
| REGSET_XSTATE,
| REGSET_TLS,
| REGSET_IOPERM32,
|};
|
|struct pt_regs_offset {
| const char *name;
| int offset;
|};
|
|
|
|
|static const struct pt_regs_offset regoffset_table[] = {
|
| {.name = "r15", .offset = 1},
| {.name = "r14", .offset = 1},
| {.name = "r13", .offset = 1},
| {.name = "r12", .offset = 1},
| {.name = "r11", .offset = 1},
| {.name = "r10", .offset = 1},
| {.name = "r9", .offset = 1},
| {.name = "r8", .offset = 1},
|
| {.name = "bx", .offset = 1},
| {.name = "cx", .offset = 1},
| {.name = "dx", .offset = 1},
| {.name = "si", .offset = 1},
| {.name = "di", .offset = 1},
| {.name = "bp", .offset = 1},
| {.name = "ax", .offset = 1},
|
|
|
|
|
|
| {.name = "orig_ax", .offset = 1},
| {.name = "ip", .offset = 1},
| {.name = "cs", .offset = 1},
| {.name = "flags", .offset = 1},
| {.name = "sp", .offset = 1},
| {.name = "ss", .offset = 1},
| {.name = ((void *)0), .offset = 0},
|};
|int regs_query_register_offset(const char *name)
|{
| const struct pt_regs_offset *roff;
| for (roff = regoffset_table; roff->name != ((void *)0); roff++)
|  if (!strcmp(roff->name, name))
|   return roff->offset;
| return -22;
|}
|const char *regs_query_register_name(unsigned int offset)
|{
| const struct pt_regs_offset *roff;
| for (roff = regoffset_table; roff->name != ((void *)0); roff++)
|  if (roff->offset == offset)
|   return roff->name;
| return ((void *)0);
|}
|
|static const int arg_offs_table[] = {
|
|
|
|
|
| [0] = 1,
| [1] = 1,
| [2] = 1,
| [3] = 1,
| [4] = 1,
| [5] = 1
|
|};
|static inline bool invalid_selector(u16 value)
|{
| return value != 0 && (value & 0x3) != 0x3;
|}
|static unsigned long *pt_regs_access(struct pt_regs *regs, unsigned long offset)
|{
| ((void)(sizeof(struct { int:-!!(1 != 0); })));
| return ®s->r15 + (offset / sizeof(regs->r15));
|}
|
|static u16 get_segment_reg(struct task_struct *task, unsigned long offset)
|{
|
|
|
| unsigned int seg;
|
| switch (offset) {
| case 1:
|  if (task == get_current()) {
|
|   asm("movl %%fs,%0" : "=r" (seg));
|   return seg;
|  }
|  return task->thread.fsindex;
| case 1:
|  if (task == get_current()) {
|   asm("movl %%gs,%0" : "=r" (seg));
|   return seg;
|  }
|  return task->thread.gsindex;
| case 1:
|  if (task == get_current()) {
|   asm("movl %%ds,%0" : "=r" (seg));
|   return seg;
|  }
|  return task->thread.ds;
| case 1:
|  if (task == get_current()) {
|   asm("movl %%es,%0" : "=r" (seg));
|   return seg;
|  }
|  return task->thread.es;
|
| case 1:
| case 1:
|  break;
| }
| return *pt_regs_access(((struct pt_regs *)(task)->thread.sp0 - 1), offset);
|}
|
|static int set_segment_reg(struct task_struct *task,
|      unsigned long offset, u16 value)
|{
|
|
|
| if (invalid_selector(value))
|  return -5;
|
| switch (offset) {
| case 1:
|
|
|
|
|  if ((value == ((12 +0)*8 + 3) && task->thread.fsindex == 0 &&
|       task->thread.fs != 0) ||
|      (value == 0 && task->thread.fsindex == ((12 +0)*8 + 3) &&
|       task->thread.fs == 0))
|   break;
|  task->thread.fsindex = value;
|  if (task == get_current())
|   do { unsigned short __val = (task->thread.fsindex); asm volatile("						\n" "1:	movl %k0,%%" "fs" "		\n" ".section .fixup,\"ax\"			\n" "2:	xorl %k0,%k0			\n" "		jmp 1b				\n" ".previous					\n" " .section __ex_table,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " "1b" "," "2b" "\n" " .previous\n" : "+r" (__val) : : "memory"); } while (0);
|  break;
| case 1:
|
|
|
|
|  if ((value == ((12 +1)*8 + 3) && task->thread.gsindex == 0 &&
|       task->thread.gs != 0) ||
|      (value == 0 && task->thread.gsindex == ((12 +1)*8 + 3) &&
|       task->thread.gs == 0))
|   break;
|  task->thread.gsindex = value;
|  if (task == get_current())
|   load_gs_index(task->thread.gsindex);
|  break;
| case 1:
|  task->thread.ds = value;
|  if (task == get_current())
|   do { unsigned short __val = (task->thread.ds); asm volatile("						\n" "1:	movl %k0,%%" "ds" "		\n" ".section .fixup,\"ax\"			\n" "2:	xorl %k0,%k0			\n" "		jmp 1b				\n" ".previous					\n" " .section __ex_table,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " "1b" "," "2b" "\n" " .previous\n" : "+r" (__val) : : "memory"); } while (0);
|  break;
| case 1:
|  task->thread.es = value;
|  if (task == get_current())
|   do { unsigned short __val = (task->thread.es); asm volatile("						\n" "1:	movl %k0,%%" "es" "		\n" ".section .fixup,\"ax\"			\n" "2:	xorl %k0,%k0			\n" "		jmp 1b				\n" ".previous					\n" " .section __ex_table,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " "1b" "," "2b" "\n" " .previous\n" : "+r" (__val) : : "memory"); } while (0);
|  break;
|
|
|
|
| case 1:
|  if (value == 0)
|   return -5;
|
|  if (test_tsk_thread_flag(task, 17))
|   ((struct pt_regs *)(task)->thread.sp0 - 1)->cs = value;
|
|  break;
| case 1:
|  if (value == 0)
|   return -5;
|
|  if (test_tsk_thread_flag(task, 17))
|   ((struct pt_regs *)(task)->thread.sp0 - 1)->ss = value;
|
|  break;
| }
|
| return 0;
|}
|
|
|
|static unsigned long get_flags(struct task_struct *task)
|{
| unsigned long retval = ((struct pt_regs *)(task)->thread.sp0 - 1)->flags;
|
|
|
|
| if (test_tsk_thread_flag(task, 24))
|  retval &= ~0x00000100;
|
| return retval;
|}
|
|static int set_flags(struct task_struct *task, unsigned long value)
|{
| struct pt_regs *regs = ((struct pt_regs *)(task)->thread.sp0 - 1);
|
|
|
|
|
|
| if (value & 0x00000100)
|  clear_tsk_thread_flag(task, 24);
| else if (test_tsk_thread_flag(task, 24))
|  value |= 0x00000100;
|
| regs->flags = (regs->flags & ~(((unsigned long) (0x00000001 | 0x00000004 | 0x00000010 | 0x00000040 | 0x00000080 | 0x00000100 | 0x00000400 | 0x00000800 | 0x00010000 | 0x00040000)) | 0x00004000)) | (value & (((unsigned long) (0x00000001 | 0x00000004 | 0x00000010 | 0x00000040 | 0x00000080 | 0x00000100 | 0x00000400 | 0x00000800 | 0x00010000 | 0x00040000)) | 0x00004000));
|
| return 0;
|}
|
|static int putreg(struct task_struct *child,
|    unsigned long offset, unsigned long value)
|{
| switch (offset) {
| case 1:
| case 1:
| case 1:
| case 1:
| case 1:
| case 1:
|  return set_segment_reg(child, offset, value);
|
| case 1:
|  return set_flags(child, value);
|
|
| case 1:
|  if (value >= ((test_tsk_thread_flag(child, 17)) ? ((get_current()->personality & ADDR_LIMIT_3GB) ? 0xc0000000 : 0xFFFFe000) : ((1UL << 47) - ((1UL) << 12))))
|   return -5;
|
|
|
|
|
|  if (child->thread.fs != value)
|   return do_arch_prctl(child, 0x1002, value);
|  return 0;
| case 1:
|
|
|
|  if (value >= ((test_tsk_thread_flag(child, 17)) ? ((get_current()->personality & ADDR_LIMIT_3GB) ? 0xc0000000 : 0xFFFFe000) : ((1UL << 47) - ((1UL) << 12))))
|   return -5;
|  if (child->thread.gs != value)
|   return do_arch_prctl(child, 0x1001, value);
|  return 0;
|
| }
|
| *pt_regs_access(((struct pt_regs *)(child)->thread.sp0 - 1), offset) = value;
| return 0;
|}
|
|static unsigned long getreg(struct task_struct *task, unsigned long offset)
|{
| switch (offset) {
| case 1:
| case 1:
| case 1:
| case 1:
| case 1:
| case 1:
|  return get_segment_reg(task, offset);
|
| case 1:
|  return get_flags(task);
|
|
| case 1: {
|
|
|
|
|
|  unsigned int seg = task->thread.fsindex;
|  if (task->thread.fs != 0)
|   return task->thread.fs;
|  if (task == get_current())
|   asm("movl %%fs,%0" : "=r" (seg));
|  if (seg != ((12 +0)*8 + 3))
|   return 0;
|  return get_desc_base(&task->thread.tls_array[0]);
| }
| case 1: {
|
|
|
|  unsigned int seg = task->thread.gsindex;
|  if (task->thread.gs != 0)
|   return task->thread.gs;
|  if (task == get_current())
|   asm("movl %%gs,%0" : "=r" (seg));
|  if (seg != ((12 +1)*8 + 3))
|   return 0;
|  return get_desc_base(&task->thread.tls_array[1]);
| }
|
| }
|
| return *pt_regs_access(((struct pt_regs *)(task)->thread.sp0 - 1), offset);
|}
|
|static int genregs_get(struct task_struct *target,
|         const struct user_regset *regset,
|         unsigned int pos, unsigned int count,
|         void *kbuf, void *ubuf)
|{
| if (kbuf) {
|  unsigned long *k = kbuf;
|  while (count >= sizeof(*k)) {
|   *k++ = getreg(target, pos);
|   count -= sizeof(*k);
|   pos += sizeof(*k);
|  }
| } else {
|  unsigned long *u = ubuf;
|  while (count >= sizeof(*u)) {
|   if (({ int __pu_err; do { __pu_err = 0; (void)0; switch ((sizeof(*(u++)))) { case 1: asm volatile("1:	mov""b"" %""b""1,%2\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	mov %3,%0\n" "	jmp 2b\n" ".previous\n" " .section __ex_table,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " "1b" "," "3b" "\n" " .previous\n" : "=r"(__pu_err) : "iq"(((__typeof__(*(u++)))(getreg(target, pos)))), "m" ((*(struct __large_struct *)(((u++))))), "i" (-14), "0" (__pu_err)); break; case 2: asm volatile("1:	mov""w"" %""w""1,%2\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	mov %3,%0\n" "	jmp 2b\n" ".previous\n" " .section __ex_table,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " "1b" "," "3b" "\n" " .previous\n" : "=r"(__pu_err) : "ir"(((__typeof__(*(u++)))(getreg(target, pos)))), "m" ((*(struct __large_struct *)(((u++))))), "i" (-14), "0" (__pu_err)); break; case 4: asm volatile("1:	mov""l"" %""k""1,%2\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	mov %3,%0\n" "	jmp 2b\n" ".previous\n" " .section __ex_table,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " "1b" "," "3b" "\n" " .previous\n" : "=r"(__pu_err) : "ir"(((__typeof__(*(u++)))(getreg(target, pos)))), "m" ((*(struct __large_struct *)(((u++))))), "i" (-14), "0" (__pu_err)); break; case 8: asm volatile("1:	mov""q"" %""""1,%2\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	mov %3,%0\n" "	jmp 2b\n" ".previous\n" " .section __ex_table,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " "1b" "," "3b" "\n" " .previous\n" : "=r"(__pu_err) : "er"((__typeof__(*((u++))))(((__typeof__(*(u++)))(getreg(target, pos))))), "m" ((*(struct __large_struct *)(((u++))))), "i" (-14), "0" (__pu_err)); break; default: __put_user_bad(); } } while (0); __pu_err; }))
|    return -14;
|   count -= sizeof(*u);
|   pos += sizeof(*u);
|  }
| }
|
| return 0;
|}
|
|static int genregs_set(struct task_struct *target,
|         const struct user_regset *regset,
|         unsigned int pos, unsigned int count,
|         const void *kbuf, const void *ubuf)
|{
| int ret = 0;
| if (kbuf) {
|  const unsigned long *k = kbuf;
|  while (count >= sizeof(*k) && !ret) {
|   ret = putreg(target, pos, *k++);
|   count -= sizeof(*k);
|   pos += sizeof(*k);
|  }
| } else {
|  const unsigned long *u = ubuf;
|  while (count >= sizeof(*u) && !ret) {
|   unsigned long word;
|   ret = ({ int __gu_err; unsigned long __gu_val; do { __gu_err = 0; (void)0; switch ((sizeof(*(u++)))) { case 1: asm volatile("1:	mov""b"" %2,%""b""1\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	mov %3,%0\n" "	xor""b"" %""b""1,%""b""1\n" "	jmp 2b\n" ".previous\n" " .section __ex_table,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " "1b" "," "3b" "\n" " .previous\n" : "=r" (__gu_err), "=q"(__gu_val) : "m" ((*(struct __large_struct *)(((u++))))), "i" (-14), "0" (__gu_err)); break; case 2: asm volatile("1:	mov""w"" %2,%""w""1\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	mov %3,%0\n" "	xor""w"" %""w""1,%""w""1\n" "	jmp 2b\n" ".previous\n" " .section __ex_table,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " "1b" "," "3b" "\n" " .previous\n" : "=r" (__gu_err), "=r"(__gu_val) : "m" ((*(struct __large_struct *)(((u++))))), "i" (-14), "0" (__gu_err)); break; case 4: asm volatile("1:	mov""l"" %2,%""k""1\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	mov %3,%0\n" "	xor""l"" %""k""1,%""k""1\n" "	jmp 2b\n" ".previous\n" " .section __ex_table,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " "1b" "," "3b" "\n" " .previous\n" : "=r" (__gu_err), "=r"(__gu_val) : "m" ((*(struct __large_struct *)(((u++))))), "i" (-14), "0" (__gu_err)); break; case 8: asm volatile("1:	mov""q"" %2,%""""1\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	mov %3,%0\n" "	xor""q"" %""""1,%""""1\n" "	jmp 2b\n" ".previous\n" " .section __ex_table,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " "1b" "," "3b" "\n" " .previous\n" : "=r" (__gu_err), "=r"(__gu_val) : "m" ((*(struct __large_struct *)(((u++))))), "i" (-14), "0" (__gu_err)); break; default: (__gu_val) = __get_user_bad(); } } while (0); ((word)) = ( __typeof__(*((u++))))__gu_val; __gu_err; });
|   if (ret)
|    break;
|   ret = putreg(target, pos, word);
|   count -= sizeof(*u);
|   pos += sizeof(*u);
|  }
| }
| return ret;
|}
|
|static void ptrace_triggered(struct perf_event *bp, int nmi,
|        struct perf_sample_data *data,
|        struct pt_regs *regs)
|{
| int i;
| struct thread_struct *thread = &(get_current()->thread);
|
|
|
|
|
| for (i = 0; i < 4; i++) {
|  if (thread->ptrace_bps[i] == bp)
|   break;
| }
|
| thread->debugreg6 |= ((0x1) << i);
|}
|
|
|
|
|
|
|static unsigned long ptrace_get_dr7(struct perf_event *bp[])
|{
| int i;
| int dr7 = 0;
| struct arch_hw_breakpoint *info;
|
| for (i = 0; i < 4; i++) {
|  if (bp[i] && !bp[i]->attr.disabled) {
|   info = counter_arch_bp(bp[i]);
|   dr7 |= encode_dr7(i, info->len, info->type);
|  }
| }
|
| return dr7;
|}
|
|static int
|ptrace_modify_breakpoint(struct perf_event *bp, int len, int type,
|    struct task_struct *tsk, int disabled)
|{
| int err;
| int gen_len, gen_type;
| struct perf_event_attr attr;
|
|
|
|
|
|
| if (!bp)
|  return -22;
|
| err = arch_bp_generic_fields(len, type, &gen_len, &gen_type);
| if (err)
|  return err;
|
| attr = bp->attr;
| attr.bp_len = gen_len;
| attr.bp_type = gen_type;
| attr.disabled = disabled;
|
| return modify_user_hw_breakpoint(bp, &attr);
|}
|
|
|
|
|static int ptrace_write_dr7(struct task_struct *tsk, unsigned long data)
|{
| struct thread_struct *thread = &(tsk->thread);
| unsigned long old_dr7;
| int i, orig_ret = 0, rc = 0;
| int enabled, second_pass = 0;
| unsigned len, type;
| struct perf_event *bp;
|
| data &= ~(0xFFFFFFFF0000FC00UL);
| old_dr7 = ptrace_get_dr7(thread->ptrace_bps);
|restore:
|
|
|
|
| for (i = 0; i < 4; i++) {
|  enabled = decode_dr7(data, i, &len, &type);
|  bp = thread->ptrace_bps[i];
|
|  if (!enabled) {
|   if (bp) {
|
|
|
|
|
|
|
|    if (!second_pass)
|     continue;
|
|    rc = ptrace_modify_breakpoint(bp, len, type,
|             tsk, 1);
|    if (rc)
|     break;
|   }
|   continue;
|  }
|
|  rc = ptrace_modify_breakpoint(bp, len, type, tsk, 0);
|  if (rc)
|   break;
| }
|
|
|
|
| if (!second_pass) {
|  second_pass = 1;
|  if (rc < 0) {
|   orig_ret = rc;
|   data = old_dr7;
|  }
|  goto restore;
| }
| return ((orig_ret < 0) ? orig_ret : rc);
|}
|
|
|
|
|static unsigned long ptrace_get_debugreg(struct task_struct *tsk, int n)
|{
| struct thread_struct *thread = &(tsk->thread);
| unsigned long val = 0;
|
| if (n < 4) {
|  struct perf_event *bp;
|  bp = thread->ptrace_bps[n];
|  if (!bp)
|   return 0;
|  val = bp->hw.info.address;
| } else if (n == 6) {
|  val = thread->debugreg6;
|  } else if (n == 7) {
|  val = thread->ptrace_dr7;
| }
| return val;
|}
|
|static int ptrace_set_breakpoint_addr(struct task_struct *tsk, int nr,
|          unsigned long addr)
|{
| struct perf_event *bp;
| struct thread_struct *t = &tsk->thread;
| struct perf_event_attr attr;
|
| if (!t->ptrace_bps[nr]) {
|  ptrace_breakpoint_init(&attr);
|
|
|
|
|  attr.bp_addr = addr;
|  attr.bp_len = HW_BREAKPOINT_LEN_1;
|  attr.bp_type = HW_BREAKPOINT_W;
|  attr.disabled = 1;
|
|  bp = register_user_hw_breakpoint(&attr, ptrace_triggered, tsk);
|  if (IS_ERR(bp))
|   return PTR_ERR(bp);
|
|  t->ptrace_bps[nr] = bp;
| } else {
|  int err;
|
|  bp = t->ptrace_bps[nr];
|
|  attr = bp->attr;
|  attr.bp_addr = addr;
|  err = modify_user_hw_breakpoint(bp, &attr);
|  if (err)
|   return err;
| }
|
|
| return 0;
|}
|
|
|
|
|int ptrace_set_debugreg(struct task_struct *tsk, int n, unsigned long val)
|{
| struct thread_struct *thread = &(tsk->thread);
| int rc = 0;
|
|
| if (n == 4 || n == 5)
|  return -5;
|
| if (n == 6) {
|  thread->debugreg6 = val;
|  goto ret_path;
| }
| if (n < 4) {
|  rc = ptrace_set_breakpoint_addr(tsk, n, val);
|  if (rc)
|   return rc;
| }
|
| if (n == 7) {
|  rc = ptrace_write_dr7(tsk, val);
|  if (!rc)
|   thread->ptrace_dr7 = val;
| }
|
|ret_path:
| return rc;
|}
|
|
|
|
|
|static int ioperm_active(struct task_struct *target,
|    const struct user_regset *regset)
|{
| return target->thread.io_bitmap_max / regset->size;
|}
|
|static int ioperm_get(struct task_struct *target,
|        const struct user_regset *regset,
|        unsigned int pos, unsigned int count,
|        void *kbuf, void *ubuf)
|{
| if (!target->thread.io_bitmap_ptr)
|  return -6;
|
| return user_regset_copyout(&pos, &count, &kbuf, &ubuf,
|       target->thread.io_bitmap_ptr,
|       0, (65536/8));
|}
|
|
|
|
|
|
|void ptrace_disable(struct task_struct *child)
|{
| user_disable_single_step(child);
|
| clear_tsk_thread_flag(child, 6);
|
|}
|
|
|static const struct user_regset_view user_x86_32_view;
|
|
|long arch_ptrace(struct task_struct *child, long request,
|   unsigned long addr, unsigned long data)
|{
| int ret;
| unsigned long *datap = (unsigned long *)data;
|
| switch (request) {
|
| case 3: {
|  unsigned long tmp;
|
|  ret = -5;
|  if ((addr & (sizeof(data) - 1)) || addr >= sizeof(struct user))
|   break;
|
|  tmp = 0;
|  if (addr < sizeof(struct user_regs_struct))
|   tmp = getreg(child, addr);
|  else if (addr >= 1 &&
|    addr <= 1) {
|   addr -= 1;
|   tmp = ptrace_get_debugreg(child, addr / sizeof(data));
|  }
|  ret = __st_put_user_st__(tmp, datap);
|  break;
| }
|
| case 6:
|  ret = -5;
|  if ((addr & (sizeof(data) - 1)) || addr >= sizeof(struct user))
|   break;
|
|  if (addr < sizeof(struct user_regs_struct))
|   ret = putreg(child, addr, data);
|  else if (addr >= 1 &&
|    addr <= 1) {
|   addr -= 1;
|   ret = ptrace_set_debugreg(child,
|        addr / sizeof(data), data);
|  }
|  break;
|
| case 12:
|  return copy_regset_to_user(child,
|        task_user_regset_view(get_current()),
|        REGSET_GENERAL,
|        0, sizeof(struct user_regs_struct),
|        datap);
|
| case 13:
|  return copy_regset_from_user(child,
|          task_user_regset_view(get_current()),
|          REGSET_GENERAL,
|          0, sizeof(struct user_regs_struct),
|          datap);
|
| case 14:
|  return copy_regset_to_user(child,
|        task_user_regset_view(get_current()),
|        REGSET_FP,
|        0, sizeof(struct user_i387_struct),
|        datap);
|
| case 15:
|  return copy_regset_from_user(child,
|          task_user_regset_view(get_current()),
|          REGSET_FP,
|          0, sizeof(struct user_i387_struct),
|          datap);
| case 25:
|  if ((int) addr < 0)
|   return -5;
|  ret = do_get_thread_area(child, addr,
|     (struct user_desc *)data);
|  break;
|
| case 26:
|  if ((int) addr < 0)
|   return -5;
|  ret = do_set_thread_area(child, addr,
|     (struct user_desc *)data, 0);
|  break;
|
|
|
|
|
|
| case 30:
|  ret = do_arch_prctl(child, data, addr);
|  break;
|
|
| default:
|  ret = ptrace_request(child, request, addr, data);
|  break;
| }
|
| return ret;
|}
|
|
|
|struct __kernel_sockaddr_storage {
| unsigned short ss_family;
|
| char __data[128 - sizeof(unsigned short)];
|
|
|} ;
|
|
|
|
|
|
|
|
|
|
|struct pid;
|struct cred;
|
|
|
|
|
|
|struct seq_file;
|extern void socket_seq_show(struct seq_file *seq);
|
|
|
|typedef unsigned short sa_family_t;
|
|
|
|
|
|struct sockaddr {
| sa_family_t sa_family;
| char sa_data[14];
|};
|
|struct linger {
| int l_onoff;
| int l_linger;
|};
|struct msghdr {
| void * msg_name;
| int msg_namelen;
| struct iovec * msg_iov;
| __kernel_size_t msg_iovlen;
| void * msg_control;
| __kernel_size_t msg_controllen;
| unsigned msg_flags;
|};
|
|
|struct mmsghdr {
| struct msghdr msg_hdr;
| unsigned msg_len;
|};
|
|
|
|
|
|
|
|struct cmsghdr {
| __kernel_size_t cmsg_len;
|        int cmsg_level;
|        int cmsg_type;
|};
|static inline struct cmsghdr * __cmsg_nxthdr(void *__ctl, __kernel_size_t __size,
|            struct cmsghdr *__cmsg)
|{
| struct cmsghdr * __ptr;
|
| __ptr = (struct cmsghdr*)(((unsigned char *) __cmsg) + ( ((__cmsg->cmsg_len)+sizeof(long)-1) & ~(sizeof(long)-1) ));
| if ((unsigned long)((char*)(__ptr+1) - (char *) __ctl) > __size)
|  return (struct cmsghdr *)0;
|
| return __ptr;
|}
|
|static inline struct cmsghdr * cmsg_nxthdr (struct msghdr *__msg, struct cmsghdr *__cmsg)
|{
| return __cmsg_nxthdr(__msg->msg_control, __msg->msg_controllen, __cmsg);
|}
|
|
|
|
|
|
|
|struct ucred {
| __u32 pid;
| __u32 uid;
| __u32 gid;
|};
|extern void cred_to_ucred(struct pid *pid, const struct cred *cred, struct ucred *ucred);
|
|extern int memcpy_fromiovec(unsigned char *kdata, struct iovec *iov, int len);
|extern int memcpy_fromiovecend(unsigned char *kdata, const struct iovec *iov,
|          int offset, int len);
|extern int csum_partial_copy_fromiovecend(unsigned char *kdata,
|       struct iovec *iov,
|       int offset,
|       unsigned int len, __wsum *csump);
|
|extern int verify_iovec(struct msghdr *m, struct iovec *iov, struct sockaddr *address, int mode);
|extern int memcpy_toiovec(struct iovec *v, unsigned char *kdata, int len);
|extern int memcpy_toiovecend(const struct iovec *v, unsigned char *kdata,
|        int offset, int len);
|extern int move_addr_to_kernel(void *uaddr, int ulen, struct sockaddr *kaddr);
|extern int put_cmsg(struct msghdr*, int level, int type, int len, void *data);
|
|struct timespec;
|
|extern int __sys_recvmmsg(int fd, struct mmsghdr *mmsg, unsigned int vlen,
|     unsigned int flags, struct timespec *timeout);
|typedef struct {
| unsigned int clock_rate;
| unsigned int clock_type;
| unsigned short loopback;
|} sync_serial_settings;
|
|typedef struct {
| unsigned int clock_rate;
| unsigned int clock_type;
| unsigned short loopback;
| unsigned int slot_map;
|} te1_settings;
|
|typedef struct {
| unsigned short encoding;
| unsigned short parity;
|} raw_hdlc_proto;
|
|typedef struct {
| unsigned int t391;
| unsigned int t392;
| unsigned int n391;
| unsigned int n392;
| unsigned int n393;
| unsigned short lmi;
| unsigned short dce;
|} fr_proto;
|
|typedef struct {
| unsigned int dlci;
|} fr_proto_pvc;
|
|typedef struct {
| unsigned int dlci;
| char master[16];
|}fr_proto_pvc_info;
|
|typedef struct {
|    unsigned int interval;
|    unsigned int timeout;
|} cisco_proto;
|enum {
| IF_OPER_UNKNOWN,
| IF_OPER_NOTPRESENT,
| IF_OPER_DOWN,
| IF_OPER_LOWERLAYERDOWN,
| IF_OPER_TESTING,
| IF_OPER_DORMANT,
| IF_OPER_UP,
|};
|
|
|enum {
| IF_LINK_MODE_DEFAULT,
| IF_LINK_MODE_DORMANT,
|};
|struct ifmap {
| unsigned long mem_start;
| unsigned long mem_end;
| unsigned short base_addr;
| unsigned char irq;
| unsigned char dma;
| unsigned char port;
|
|};
|
|struct if_settings {
| unsigned int type;
| unsigned int size;
| union {
|
|  raw_hdlc_proto *raw_hdlc;
|  cisco_proto *cisco;
|  fr_proto *fr;
|  fr_proto_pvc *fr_pvc;
|  fr_proto_pvc_info *fr_pvc_info;
|
|
|  sync_serial_settings *sync;
|  te1_settings *te1;
| } ifs_ifsu;
|};
|struct ifreq {
|
| union
| {
|  char ifrn_name[16];
| } ifr_ifrn;
|
| union {
|  struct sockaddr ifru_addr;
|  struct sockaddr ifru_dstaddr;
|  struct sockaddr ifru_broadaddr;
|  struct sockaddr ifru_netmask;
|  struct sockaddr ifru_hwaddr;
|  short ifru_flags;
|  int ifru_ivalue;
|  int ifru_mtu;
|  struct ifmap ifru_map;
|  char ifru_slave[16];
|  char ifru_newname[16];
|  void * ifru_data;
|  struct if_settings ifru_settings;
| } ifr_ifru;
|};
|struct ifconf {
| int ifc_len;
| union {
|  char *ifcu_buf;
|  struct ifreq *ifcu_req;
| } ifc_ifcu;
|};
|
|
|
|
|
|
|
|struct user_i387_ia32_struct {
| u32 cwd;
| u32 swd;
| u32 twd;
| u32 fip;
| u32 fcs;
| u32 foo;
| u32 fos;
| u32 st_space[20];
|};
|
|
|struct user32_fxsr_struct {
| unsigned short cwd;
| unsigned short swd;
| unsigned short twd;
| unsigned short fop;
| int fip;
| int fcs;
| int foo;
| int fos;
| int mxcsr;
| int reserved;
| int st_space[32];
| int xmm_space[32];
| int padding[56];
|};
|
|struct user_regs_struct32 {
| __u32 ebx, ecx, edx, esi, edi, ebp, eax;
| unsigned short ds, __ds, es, __es;
| unsigned short fs, __fs, gs, __gs;
| __u32 orig_eax, eip;
| unsigned short cs, __cs;
| __u32 eflags, esp;
| unsigned short ss, __ss;
|};
|
|struct user32 {
|  struct user_regs_struct32 regs;
|  int u_fpvalid;
|
|  struct user_i387_ia32_struct i387;
|
|  __u32 u_tsize;
|  __u32 u_dsize;
|  __u32 u_ssize;
|  __u32 start_code;
|  __u32 start_stack;
|
|
|
|  __u32 signal;
|  int reserved;
|  __u32 u_ar0;
|
|  __u32 u_fpstate;
|  __u32 magic;
|  char u_comm[32];
|  int u_debugreg[8];
|};
|
|
|
|
|typedef u32 compat_size_t;
|typedef s32 compat_ssize_t;
|typedef s32 compat_time_t;
|typedef s32 compat_clock_t;
|typedef s32 compat_pid_t;
|typedef u16 __compat_uid_t;
|typedef u16 __compat_gid_t;
|typedef u32 __compat_uid32_t;
|typedef u32 __compat_gid32_t;
|typedef u16 compat_mode_t;
|typedef u32 compat_ino_t;
|typedef u16 compat_dev_t;
|typedef s32 compat_off_t;
|typedef s64 compat_loff_t;
|typedef u16 compat_nlink_t;
|typedef u16 compat_ipc_pid_t;
|typedef s32 compat_daddr_t;
|typedef u32 compat_caddr_t;
|typedef __kernel_fsid_t compat_fsid_t;
|typedef s32 compat_timer_t;
|typedef s32 compat_key_t;
|
|typedef s32 compat_int_t;
|typedef s32 compat_long_t;
|typedef s64 compat_s64;
|typedef u32 compat_uint_t;
|typedef u32 compat_ulong_t;
|typedef u64 compat_u64;
|
|struct compat_timespec {
| compat_time_t tv_sec;
| s32 tv_nsec;
|};
|
|struct compat_timeval {
| compat_time_t tv_sec;
| s32 tv_usec;
|};
|
|struct compat_stat {
| compat_dev_t st_dev;
| u16 __pad1;
| compat_ino_t st_ino;
| compat_mode_t st_mode;
| compat_nlink_t st_nlink;
| __compat_uid_t st_uid;
| __compat_gid_t st_gid;
| compat_dev_t st_rdev;
| u16 __pad2;
| u32 st_size;
| u32 st_blksize;
| u32 st_blocks;
| u32 st_atime;
| u32 st_atime_nsec;
| u32 st_mtime;
| u32 st_mtime_nsec;
| u32 st_ctime;
| u32 st_ctime_nsec;
| u32 __unused4;
| u32 __unused5;
|};
|
|struct compat_flock {
| short l_type;
| short l_whence;
| compat_off_t l_start;
| compat_off_t l_len;
| compat_pid_t l_pid;
|};
|struct compat_flock64 {
| short l_type;
| short l_whence;
| compat_loff_t l_start;
| compat_loff_t l_len;
| compat_pid_t l_pid;
|} ;
|
|struct compat_statfs {
| int f_type;
| int f_bsize;
| int f_blocks;
| int f_bfree;
| int f_bavail;
| int f_files;
| int f_ffree;
| compat_fsid_t f_fsid;
| int f_namelen;
| int f_frsize;
| int f_spare[5];
|};
|
|
|
|
|typedef u32 compat_old_sigset_t;
|
|
|
|
|typedef u32 compat_sigset_word;
|
|
|
|
|struct compat_ipc64_perm {
| compat_key_t key;
| __compat_uid32_t uid;
| __compat_gid32_t gid;
| __compat_uid32_t cuid;
| __compat_gid32_t cgid;
| unsigned short mode;
| unsigned short __pad1;
| unsigned short seq;
| unsigned short __pad2;
| compat_ulong_t unused1;
| compat_ulong_t unused2;
|};
|
|struct compat_semid64_ds {
| struct compat_ipc64_perm sem_perm;
| compat_time_t sem_otime;
| compat_ulong_t __unused1;
| compat_time_t sem_ctime;
| compat_ulong_t __unused2;
| compat_ulong_t sem_nsems;
| compat_ulong_t __unused3;
| compat_ulong_t __unused4;
|};
|
|struct compat_msqid64_ds {
| struct compat_ipc64_perm msg_perm;
| compat_time_t msg_stime;
| compat_ulong_t __unused1;
| compat_time_t msg_rtime;
| compat_ulong_t __unused2;
| compat_time_t msg_ctime;
| compat_ulong_t __unused3;
| compat_ulong_t msg_cbytes;
| compat_ulong_t msg_qnum;
| compat_ulong_t msg_qbytes;
| compat_pid_t msg_lspid;
| compat_pid_t msg_lrpid;
| compat_ulong_t __unused4;
| compat_ulong_t __unused5;
|};
|
|struct compat_shmid64_ds {
| struct compat_ipc64_perm shm_perm;
| compat_size_t shm_segsz;
| compat_time_t shm_atime;
| compat_ulong_t __unused1;
| compat_time_t shm_dtime;
| compat_ulong_t __unused2;
| compat_time_t shm_ctime;
| compat_ulong_t __unused3;
| compat_pid_t shm_cpid;
| compat_pid_t shm_lpid;
| compat_ulong_t shm_nattch;
| compat_ulong_t __unused4;
| compat_ulong_t __unused5;
|};
|
|
|
|
|typedef struct user_regs_struct32 compat_elf_gregset_t;
|
|
|
|
|
|
|
|typedef u32 compat_uptr_t;
|
|static inline void *compat_ptr(compat_uptr_t uptr)
|{
| return (void *)(unsigned long)uptr;
|}
|
|static inline compat_uptr_t ptr_to_compat(void *uptr)
|{
| return (u32)(unsigned long)uptr;
|}
|
|static inline void *arch_compat_alloc_user_space(long len)
|{
| struct pt_regs *regs = ((struct pt_regs *)(get_current())->thread.sp0 - 1);
| return (void *)regs->sp - len;
|}
|
|static inline int is_compat_task(void)
|{
| return current_thread_info()->status & 0x0002;
|}
|
|
|
|
|
|
|typedef __compat_uid32_t compat_uid_t;
|typedef __compat_gid32_t compat_gid_t;
|
|struct compat_sel_arg_struct;
|struct rusage;
|
|struct compat_itimerspec {
| struct compat_timespec it_interval;
| struct compat_timespec it_value;
|};
|
|struct compat_utimbuf {
| compat_time_t actime;
| compat_time_t modtime;
|};
|
|struct compat_itimerval {
| struct compat_timeval it_interval;
| struct compat_timeval it_value;
|};
|
|struct compat_tms {
| compat_clock_t tms_utime;
| compat_clock_t tms_stime;
| compat_clock_t tms_cutime;
| compat_clock_t tms_cstime;
|};
|
|struct compat_timex {
| compat_uint_t modes;
| compat_long_t offset;
| compat_long_t freq;
| compat_long_t maxerror;
| compat_long_t esterror;
| compat_int_t status;
| compat_long_t constant;
| compat_long_t precision;
| compat_long_t tolerance;
| struct compat_timeval time;
| compat_long_t tick;
| compat_long_t ppsfreq;
| compat_long_t jitter;
| compat_int_t shift;
| compat_long_t stabil;
| compat_long_t jitcnt;
| compat_long_t calcnt;
| compat_long_t errcnt;
| compat_long_t stbcnt;
| compat_int_t tai;
|
| compat_int_t :32; compat_int_t :32; compat_int_t :32; compat_int_t :32;
| compat_int_t :32; compat_int_t :32; compat_int_t :32; compat_int_t :32;
| compat_int_t :32; compat_int_t :32; compat_int_t :32;
|};
|
|
|
|typedef struct {
| compat_sigset_word sig[(64 / 32)];
|} compat_sigset_t;
|
|extern int get_compat_timespec(struct timespec *, const struct compat_timespec *);
|extern int put_compat_timespec(const struct timespec *, struct compat_timespec *);
|
|struct compat_iovec {
| compat_uptr_t iov_base;
| compat_size_t iov_len;
|};
|
|struct compat_rlimit {
| compat_ulong_t rlim_cur;
| compat_ulong_t rlim_max;
|};
|
|struct compat_rusage {
| struct compat_timeval ru_utime;
| struct compat_timeval ru_stime;
| compat_long_t ru_maxrss;
| compat_long_t ru_ixrss;
| compat_long_t ru_idrss;
| compat_long_t ru_isrss;
| compat_long_t ru_minflt;
| compat_long_t ru_majflt;
| compat_long_t ru_nswap;
| compat_long_t ru_inblock;
| compat_long_t ru_oublock;
| compat_long_t ru_msgsnd;
| compat_long_t ru_msgrcv;
| compat_long_t ru_nsignals;
| compat_long_t ru_nvcsw;
| compat_long_t ru_nivcsw;
|};
|
|extern int put_compat_rusage(const struct rusage *, struct compat_rusage *);
|
|struct compat_siginfo;
|
|extern long compat_sys_waitid(int, compat_pid_t,
|  struct compat_siginfo *, int,
|  struct compat_rusage *);
|
|struct compat_dirent {
| u32 d_ino;
| compat_off_t d_off;
| u16 d_reclen;
| char d_name[256];
|};
|
|struct compat_ustat {
| compat_daddr_t f_tfree;
| compat_ino_t f_tinode;
| char f_fname[6];
| char f_fpack[6];
|};
|
|typedef union compat_sigval {
| compat_int_t sival_int;
| compat_uptr_t sival_ptr;
|} compat_sigval_t;
|
|
|
|typedef struct compat_sigevent {
| compat_sigval_t sigev_value;
| compat_int_t sigev_signo;
| compat_int_t sigev_notify;
| union {
|  compat_int_t _pad[((64/sizeof(int)) - 3)];
|  compat_int_t _tid;
|
|  struct {
|   compat_uptr_t _function;
|   compat_uptr_t _attribute;
|  } _sigev_thread;
| } _sigev_un;
|} compat_sigevent_t;
|
|struct compat_ifmap {
| compat_ulong_t mem_start;
| compat_ulong_t mem_end;
| unsigned short base_addr;
| unsigned char irq;
| unsigned char dma;
| unsigned char port;
|};
|
|struct compat_if_settings
|{
| unsigned int type;
| unsigned int size;
| compat_uptr_t ifs_ifsu;
|};
|
|struct compat_ifreq {
| union {
|  char ifrn_name[16];
| } ifr_ifrn;
| union {
|  struct sockaddr ifru_addr;
|  struct sockaddr ifru_dstaddr;
|  struct sockaddr ifru_broadaddr;
|  struct sockaddr ifru_netmask;
|  struct sockaddr ifru_hwaddr;
|  short ifru_flags;
|  compat_int_t ifru_ivalue;
|  compat_int_t ifru_mtu;
|  struct compat_ifmap ifru_map;
|  char ifru_slave[16];
|  char ifru_newname[16];
|  compat_caddr_t ifru_data;
|  struct compat_if_settings ifru_settings;
| } ifr_ifru;
|};
|
|struct compat_ifconf {
|        compat_int_t ifc_len;
|        compat_caddr_t ifcbuf;
|};
|
|struct compat_robust_list {
| compat_uptr_t next;
|};
|
|struct compat_robust_list_head {
| struct compat_robust_list list;
| compat_long_t futex_offset;
| compat_uptr_t list_op_pending;
|};
|
|extern void compat_exit_robust_list(struct task_struct *curr);
|
| long
|compat_sys_set_robust_list(struct compat_robust_list_head *head,
|      compat_size_t len);
| long
|compat_sys_get_robust_list(int pid, compat_uptr_t *head_ptr,
|      compat_size_t *len_ptr);
|
|long compat_sys_semctl(int first, int second, int third, void *uptr);
|long compat_sys_msgsnd(int first, int second, int third, void *uptr);
|long compat_sys_msgrcv(int first, int second, int msgtyp, int third,
|  int version, void *uptr);
|long compat_sys_msgctl(int first, int second, void *uptr);
|long compat_sys_shmat(int first, int second, compat_uptr_t third, int version,
|  void *uptr);
|long compat_sys_shmctl(int first, int second, void *uptr);
|long compat_sys_semtimedop(int semid, struct sembuf *tsems,
|  unsigned nsems, const struct compat_timespec *timeout);
| long compat_sys_keyctl(u32 option,
|         u32 arg2, u32 arg3, u32 arg4, u32 arg5);
| long compat_sys_ustat(unsigned dev, struct compat_ustat *u32);
|
| ssize_t compat_sys_readv(unsigned long fd,
|  const struct compat_iovec *vec, unsigned long vlen);
| ssize_t compat_sys_writev(unsigned long fd,
|  const struct compat_iovec *vec, unsigned long vlen);
| ssize_t compat_sys_preadv(unsigned long fd,
|  const struct compat_iovec *vec,
|  unsigned long vlen, u32 pos_low, u32 pos_high);
| ssize_t compat_sys_pwritev(unsigned long fd,
|  const struct compat_iovec *vec,
|  unsigned long vlen, u32 pos_low, u32 pos_high);
|
|int compat_do_execve(char * filename, compat_uptr_t *argv,
|         compat_uptr_t *envp, struct pt_regs * regs);
|
| long compat_sys_select(int n, compat_ulong_t *inp,
|  compat_ulong_t *outp, compat_ulong_t *exp,
|  struct compat_timeval *tvp);
|
| long compat_sys_old_select(struct compat_sel_arg_struct *arg);
|
| long compat_sys_wait4(compat_pid_t pid,
|     compat_uint_t *stat_addr, int options,
|     struct compat_rusage *ru);
|
|
|
|
|
|
|long compat_get_bitmap(unsigned long *mask, const compat_ulong_t *umask,
|         unsigned long bitmap_size);
|long compat_put_bitmap(compat_ulong_t *umask, unsigned long *mask,
|         unsigned long bitmap_size);
|int copy_siginfo_from_user32(siginfo_t *to, struct compat_siginfo *from);
|int copy_siginfo_to_user32(struct compat_siginfo *to, siginfo_t *from);
|int get_compat_sigevent(struct sigevent *event,
|  const struct compat_sigevent *u_event);
|long compat_sys_rt_tgsigqueueinfo(compat_pid_t tgid, compat_pid_t pid, int sig,
|      struct compat_siginfo *uinfo);
|
|static inline int compat_timeval_compare(struct compat_timeval *lhs,
|     struct compat_timeval *rhs)
|{
| if (lhs->tv_sec < rhs->tv_sec)
|  return -1;
| if (lhs->tv_sec > rhs->tv_sec)
|  return 1;
| return lhs->tv_usec - rhs->tv_usec;
|}
|
|static inline int compat_timespec_compare(struct compat_timespec *lhs,
|     struct compat_timespec *rhs)
|{
| if (lhs->tv_sec < rhs->tv_sec)
|  return -1;
| if (lhs->tv_sec > rhs->tv_sec)
|  return 1;
| return lhs->tv_nsec - rhs->tv_nsec;
|}
|
|extern int get_compat_itimerspec(struct itimerspec *dst,
|     const struct compat_itimerspec *src);
|extern int put_compat_itimerspec(struct compat_itimerspec *dst,
|     const struct itimerspec *src);
|
| long compat_sys_gettimeofday(struct compat_timeval *tv,
|  struct timezone *tz);
| long compat_sys_settimeofday(struct compat_timeval *tv,
|  struct timezone *tz);
|
| long compat_sys_adjtimex(struct compat_timex *utp);
|
|extern int compat_printk(const char *fmt, ...);
|extern void sigset_from_compat(sigset_t *set, compat_sigset_t *compat);
|
| long compat_sys_migrate_pages(compat_pid_t pid,
|  compat_ulong_t maxnode, const compat_ulong_t *old_nodes,
|  const compat_ulong_t *new_nodes);
|
|extern int compat_ptrace_request(struct task_struct *child,
|     compat_long_t request,
|     compat_ulong_t addr, compat_ulong_t data);
|
|extern long compat_arch_ptrace(struct task_struct *child, compat_long_t request,
|          compat_ulong_t addr, compat_ulong_t data);
| long compat_sys_ptrace(compat_long_t request, compat_long_t pid,
|      compat_long_t addr, compat_long_t data);
|
|
|
|
|struct epoll_event;
|
| long compat_sys_epoll_pwait(int epfd,
|   struct epoll_event *events,
|   int maxevents, int timeout,
|   const compat_sigset_t *sigmask,
|   compat_size_t sigsetsize);
|
| long compat_sys_utimensat(unsigned int dfd, const char *filename,
|    struct compat_timespec *t, int flags);
|
| long compat_sys_signalfd(int ufd,
|    const compat_sigset_t *sigmask,
|                                compat_size_t sigsetsize);
| long compat_sys_timerfd_settime(int ufd, int flags,
|       const struct compat_itimerspec *utmr,
|       struct compat_itimerspec *otmr);
| long compat_sys_timerfd_gettime(int ufd,
|       struct compat_itimerspec *otmr);
|
| long compat_sys_move_pages(pid_t pid, unsigned long nr_page,
|          __u32 *pages,
|          const int *nodes,
|          int *status,
|          int flags);
| long compat_sys_futimesat(unsigned int dfd, const char *filename,
|         struct compat_timeval *t);
| long compat_sys_newfstatat(unsigned int dfd, const char * filename,
|          struct compat_stat *statbuf,
|          int flag);
| long compat_sys_openat(unsigned int dfd, const char *filename,
|      int flags, int mode);
|
|extern ssize_t compat_rw_copy_check_uvector(int type,
|  const struct compat_iovec *uvector, unsigned long nr_segs,
|  unsigned long fast_segs, struct iovec *fast_pointer,
|  struct iovec **ret_pointer);
|
|extern void *compat_alloc_user_space(unsigned long len);
|struct epoll_event;
|struct iattr;
|struct inode;
|struct iocb;
|struct io_event;
|struct iovec;
|struct itimerspec;
|struct itimerval;
|struct kexec_segment;
|struct linux_dirent;
|struct linux_dirent64;
|struct list_head;
|struct mmap_arg_struct;
|struct msgbuf;
|struct msghdr;
|struct mmsghdr;
|struct msqid_ds;
|struct new_utsname;
|struct nfsctl_arg;
|struct __old_kernel_stat;
|struct oldold_utsname;
|struct old_utsname;
|struct pollfd;
|struct rlimit;
|struct rlimit64;
|struct rusage;
|struct sched_param;
|struct sel_arg_struct;
|struct semaphore;
|struct sembuf;
|struct shmid_ds;
|struct sockaddr;
|struct stat;
|struct stat64;
|struct statfs;
|struct statfs64;
|struct __sysctl_args;
|struct sysinfo;
|struct timespec;
|struct timeval;
|struct timex;
|struct timezone;
|struct tms;
|struct utimbuf;
|struct mq_attr;
|struct compat_stat;
|struct compat_timeval;
|struct robust_list_head;
|struct getcpu_cache;
|struct old_linux_dirent;
|struct perf_event_attr;
|
|
|
|struct syscall_metadata {
| const char *name;
| int syscall_nr;
| int nb_args;
| const char **types;
| const char **args;
| struct list_head enter_fields;
|
| struct ftrace_event_call *enter_event;
| struct ftrace_event_call *exit_event;
|};
|
|
|extern unsigned long arch_syscall_addr(int nr);
|extern int init_syscall_trace(struct ftrace_event_call *call);
|
|extern int reg_event_syscall_enter(struct ftrace_event_call *call);
|extern void unreg_event_syscall_enter(struct ftrace_event_call *call);
|extern int reg_event_syscall_exit(struct ftrace_event_call *call);
|extern void unreg_event_syscall_exit(struct ftrace_event_call *call);
|extern int
|ftrace_format_syscall(struct ftrace_event_call *call, struct trace_seq *s);
|enum print_line_t print_syscall_enter(struct trace_iterator *iter, int flags,
|          struct trace_event *event);
|enum print_line_t print_syscall_exit(struct trace_iterator *iter, int flags,
|         struct trace_event *event);
|
|
|
|int perf_sysenter_enable(struct ftrace_event_call *call);
|void perf_sysenter_disable(struct ftrace_event_call *call);
|int perf_sysexit_enable(struct ftrace_event_call *call);
|void perf_sysexit_disable(struct ftrace_event_call *call);
|extern struct ftrace_event_class event_class_syscall_enter;
|extern struct ftrace_event_class event_class_syscall_exit;
|extern struct trace_event_functions enter_syscall_print_funcs;
|extern struct trace_event_functions exit_syscall_print_funcs;
| long sys_time(time_t *tloc);
| long sys_stime(time_t *tptr);
| long sys_gettimeofday(struct timeval *tv,
|    struct timezone *tz);
| long sys_settimeofday(struct timeval *tv,
|    struct timezone *tz);
| long sys_adjtimex(struct timex *txc_p);
|
| long sys_times(struct tms *tbuf);
|
| long sys_gettid(void);
| long sys_nanosleep(struct timespec *rqtp, struct timespec *rmtp);
| long sys_alarm(unsigned int seconds);
| long sys_getpid(void);
| long sys_getppid(void);
| long sys_getuid(void);
| long sys_geteuid(void);
| long sys_getgid(void);
| long sys_getegid(void);
| long sys_getresuid(uid_t *ruid, uid_t *euid, uid_t *suid);
| long sys_getresgid(gid_t *rgid, gid_t *egid, gid_t *sgid);
| long sys_getpgid(pid_t pid);
| long sys_getpgrp(void);
| long sys_getsid(pid_t pid);
| long sys_getgroups(int gidsetsize, gid_t *grouplist);
|
| long sys_setregid(gid_t rgid, gid_t egid);
| long sys_setgid(gid_t gid);
| long sys_setreuid(uid_t ruid, uid_t euid);
| long sys_setuid(uid_t uid);
| long sys_setresuid(uid_t ruid, uid_t euid, uid_t suid);
| long sys_setresgid(gid_t rgid, gid_t egid, gid_t sgid);
| long sys_setfsuid(uid_t uid);
| long sys_setfsgid(gid_t gid);
| long sys_setpgid(pid_t pid, pid_t pgid);
| long sys_setsid(void);
| long sys_setgroups(int gidsetsize, gid_t *grouplist);
|
| long sys_acct(const char *name);
| long sys_capget(cap_user_header_t header,
|    cap_user_data_t dataptr);
| long sys_capset(cap_user_header_t header,
|    const cap_user_data_t data);
| long sys_personality(unsigned int personality);
|
| long sys_sigpending(old_sigset_t *set);
| long sys_sigprocmask(int how, old_sigset_t *set,
|    old_sigset_t *oset);
| long sys_getitimer(int which, struct itimerval *value);
| long sys_setitimer(int which,
|    struct itimerval *value,
|    struct itimerval *ovalue);
| long sys_timer_create(clockid_t which_clock,
|     struct sigevent *timer_event_spec,
|     timer_t * created_timer_id);
| long sys_timer_gettime(timer_t timer_id,
|    struct itimerspec *setting);
| long sys_timer_getoverrun(timer_t timer_id);
| long sys_timer_settime(timer_t timer_id, int flags,
|    const struct itimerspec *new_setting,
|    struct itimerspec *old_setting);
| long sys_timer_delete(timer_t timer_id);
| long sys_clock_settime(clockid_t which_clock,
|    const struct timespec *tp);
| long sys_clock_gettime(clockid_t which_clock,
|    struct timespec *tp);
| long sys_clock_getres(clockid_t which_clock,
|    struct timespec *tp);
| long sys_clock_nanosleep(clockid_t which_clock, int flags,
|    const struct timespec *rqtp,
|    struct timespec *rmtp);
|
| long sys_nice(int increment);
| long sys_sched_setscheduler(pid_t pid, int policy,
|     struct sched_param *param);
| long sys_sched_setparam(pid_t pid,
|     struct sched_param *param);
| long sys_sched_getscheduler(pid_t pid);
| long sys_sched_getparam(pid_t pid,
|     struct sched_param *param);
| long sys_sched_setaffinity(pid_t pid, unsigned int len,
|     unsigned long *user_mask_ptr);
| long sys_sched_getaffinity(pid_t pid, unsigned int len,
|     unsigned long *user_mask_ptr);
| long sys_sched_yield(void);
| long sys_sched_get_priority_max(int policy);
| long sys_sched_get_priority_min(int policy);
| long sys_sched_rr_get_interval(pid_t pid,
|     struct timespec *interval);
| long sys_setpriority(int which, int who, int niceval);
| long sys_getpriority(int which, int who);
|
| long sys_shutdown(int, int);
| long sys_reboot(int magic1, int magic2, unsigned int cmd,
|    void *arg);
| long sys_restart_syscall(void);
| long sys_kexec_load(unsigned long entry, unsigned long nr_segments,
|    struct kexec_segment *segments,
|    unsigned long flags);
|
| long sys_exit(int error_code);
| long sys_exit_group(int error_code);
| long sys_wait4(pid_t pid, int *stat_addr,
|    int options, struct rusage *ru);
| long sys_waitid(int which, pid_t pid,
|      struct siginfo *infop,
|      int options, struct rusage *ru);
| long sys_waitpid(pid_t pid, int *stat_addr, int options);
| long sys_set_tid_address(int *tidptr);
| long sys_futex(u32 *uaddr, int op, u32 val,
|   struct timespec *utime, u32 *uaddr2,
|   u32 val3);
|
| long sys_init_module(void *umod, unsigned long len,
|    const char *uargs);
| long sys_delete_module(const char *name_user,
|    unsigned int flags);
|
| long sys_rt_sigprocmask(int how, sigset_t *set,
|    sigset_t *oset, size_t sigsetsize);
| long sys_rt_sigpending(sigset_t *set, size_t sigsetsize);
| long sys_rt_sigtimedwait(const sigset_t *uthese,
|    siginfo_t *uinfo,
|    const struct timespec *uts,
|    size_t sigsetsize);
| long sys_rt_tgsigqueueinfo(pid_t tgid, pid_t pid, int sig,
|  siginfo_t *uinfo);
| long sys_kill(int pid, int sig);
| long sys_tgkill(int tgid, int pid, int sig);
| long sys_tkill(int pid, int sig);
| long sys_rt_sigqueueinfo(int pid, int sig, siginfo_t *uinfo);
| long sys_sgetmask(void);
| long sys_ssetmask(int newmask);
| long sys_signal(int sig, __sighandler_t handler);
| long sys_pause(void);
|
| long sys_sync(void);
| long sys_fsync(unsigned int fd);
| long sys_fdatasync(unsigned int fd);
| long sys_bdflush(int func, long data);
| long sys_mount(char *dev_name, char *dir_name,
|    char *type, unsigned long flags,
|    void *data);
| long sys_umount(char *name, int flags);
| long sys_oldumount(char *name);
| long sys_truncate(const char *path, long length);
| long sys_ftruncate(unsigned int fd, unsigned long length);
| long sys_stat(const char *filename,
|   struct __old_kernel_stat *statbuf);
| long sys_statfs(const char * path,
|    struct statfs *buf);
| long sys_statfs64(const char *path, size_t sz,
|    struct statfs64 *buf);
| long sys_fstatfs(unsigned int fd, struct statfs *buf);
| long sys_fstatfs64(unsigned int fd, size_t sz,
|    struct statfs64 *buf);
| long sys_lstat(const char *filename,
|   struct __old_kernel_stat *statbuf);
| long sys_fstat(unsigned int fd,
|   struct __old_kernel_stat *statbuf);
| long sys_newstat(const char *filename,
|    struct stat *statbuf);
| long sys_newlstat(const char *filename,
|    struct stat *statbuf);
| long sys_newfstat(unsigned int fd, struct stat *statbuf);
| long sys_ustat(unsigned dev, struct ustat *ubuf);
| long sys_setxattr(const char *path, const char *name,
|        const void *value, size_t size, int flags);
| long sys_lsetxattr(const char *path, const char *name,
|         const void *value, size_t size, int flags);
| long sys_fsetxattr(int fd, const char *name,
|         const void *value, size_t size, int flags);
| long sys_getxattr(const char *path, const char *name,
|        void *value, size_t size);
| long sys_lgetxattr(const char *path, const char *name,
|         void *value, size_t size);
| long sys_fgetxattr(int fd, const char *name,
|         void *value, size_t size);
| long sys_listxattr(const char *path, char *list,
|         size_t size);
| long sys_llistxattr(const char *path, char *list,
|          size_t size);
| long sys_flistxattr(int fd, char *list, size_t size);
| long sys_removexattr(const char *path,
|    const char *name);
| long sys_lremovexattr(const char *path,
|     const char *name);
| long sys_fremovexattr(int fd, const char *name);
|
| long sys_brk(unsigned long brk);
| long sys_mprotect(unsigned long start, size_t len,
|    unsigned long prot);
| long sys_mremap(unsigned long addr,
|      unsigned long old_len, unsigned long new_len,
|      unsigned long flags, unsigned long new_addr);
| long sys_remap_file_pages(unsigned long start, unsigned long size,
|   unsigned long prot, unsigned long pgoff,
|   unsigned long flags);
| long sys_msync(unsigned long start, size_t len, int flags);
| long sys_fadvise64(int fd, loff_t offset, size_t len, int advice);
| long sys_fadvise64_64(int fd, loff_t offset, loff_t len, int advice);
| long sys_munmap(unsigned long addr, size_t len);
| long sys_mlock(unsigned long start, size_t len);
| long sys_munlock(unsigned long start, size_t len);
| long sys_mlockall(int flags);
| long sys_munlockall(void);
| long sys_madvise(unsigned long start, size_t len, int behavior);
| long sys_mincore(unsigned long start, size_t len,
|    unsigned char * vec);
|
| long sys_pivot_root(const char *new_root,
|    const char *put_old);
| long sys_chroot(const char *filename);
| long sys_mknod(const char *filename, int mode,
|    unsigned dev);
| long sys_link(const char *oldname,
|    const char *newname);
| long sys_symlink(const char *old, const char *new);
| long sys_unlink(const char *pathname);
| long sys_rename(const char *oldname,
|    const char *newname);
| long sys_chmod(const char *filename, mode_t mode);
| long sys_fchmod(unsigned int fd, mode_t mode);
|
| long sys_fcntl(unsigned int fd, unsigned int cmd, unsigned long arg);
|
|
|
|
| long sys_pipe(int *fildes);
| long sys_pipe2(int *fildes, int flags);
| long sys_dup(unsigned int fildes);
| long sys_dup2(unsigned int oldfd, unsigned int newfd);
| long sys_dup3(unsigned int oldfd, unsigned int newfd, int flags);
| long sys_ioperm(unsigned long from, unsigned long num, int on);
| long sys_ioctl(unsigned int fd, unsigned int cmd,
|    unsigned long arg);
| long sys_flock(unsigned int fd, unsigned int cmd);
| long sys_io_setup(unsigned nr_reqs, aio_context_t *ctx);
| long sys_io_destroy(aio_context_t ctx);
| long sys_io_getevents(aio_context_t ctx_id,
|    long min_nr,
|    long nr,
|    struct io_event *events,
|    struct timespec *timeout);
| long sys_io_submit(aio_context_t, long,
|    struct iocb * *);
| long sys_io_cancel(aio_context_t ctx_id, struct iocb *iocb,
|         struct io_event *result);
| long sys_sendfile(int out_fd, int in_fd,
|        off_t *offset, size_t count);
| long sys_sendfile64(int out_fd, int in_fd,
|          loff_t *offset, size_t count);
| long sys_readlink(const char *path,
|    char *buf, int bufsiz);
| long sys_creat(const char *pathname, int mode);
| long sys_open(const char *filename,
|    int flags, int mode);
| long sys_close(unsigned int fd);
| long sys_access(const char *filename, int mode);
| long sys_vhangup(void);
| long sys_chown(const char *filename,
|    uid_t user, gid_t group);
| long sys_lchown(const char *filename,
|    uid_t user, gid_t group);
| long sys_fchown(unsigned int fd, uid_t user, gid_t group);
|
| long sys_chown16(const char *filename,
|    old_uid_t user, old_gid_t group);
| long sys_lchown16(const char *filename,
|    old_uid_t user, old_gid_t group);
| long sys_fchown16(unsigned int fd, old_uid_t user, old_gid_t group);
| long sys_setregid16(old_gid_t rgid, old_gid_t egid);
| long sys_setgid16(old_gid_t gid);
| long sys_setreuid16(old_uid_t ruid, old_uid_t euid);
| long sys_setuid16(old_uid_t uid);
| long sys_setresuid16(old_uid_t ruid, old_uid_t euid, old_uid_t suid);
| long sys_getresuid16(old_uid_t *ruid,
|    old_uid_t *euid, old_uid_t *suid);
| long sys_setresgid16(old_gid_t rgid, old_gid_t egid, old_gid_t sgid);
| long sys_getresgid16(old_gid_t *rgid,
|    old_gid_t *egid, old_gid_t *sgid);
| long sys_setfsuid16(old_uid_t uid);
| long sys_setfsgid16(old_gid_t gid);
| long sys_getgroups16(int gidsetsize, old_gid_t *grouplist);
| long sys_setgroups16(int gidsetsize, old_gid_t *grouplist);
| long sys_getuid16(void);
| long sys_geteuid16(void);
| long sys_getgid16(void);
| long sys_getegid16(void);
|
|
| long sys_utime(char *filename,
|    struct utimbuf *times);
| long sys_utimes(char *filename,
|    struct timeval *utimes);
| long sys_lseek(unsigned int fd, off_t offset,
|     unsigned int origin);
| long sys_llseek(unsigned int fd, unsigned long offset_high,
|   unsigned long offset_low, loff_t *result,
|   unsigned int origin);
| long sys_read(unsigned int fd, char *buf, size_t count);
| long sys_readahead(int fd, loff_t offset, size_t count);
| long sys_readv(unsigned long fd,
|     const struct iovec *vec,
|     unsigned long vlen);
| long sys_write(unsigned int fd, const char *buf,
|     size_t count);
| long sys_writev(unsigned long fd,
|      const struct iovec *vec,
|      unsigned long vlen);
| long sys_pread64(unsigned int fd, char *buf,
|       size_t count, loff_t pos);
| long sys_pwrite64(unsigned int fd, const char *buf,
|        size_t count, loff_t pos);
| long sys_preadv(unsigned long fd, const struct iovec *vec,
|      unsigned long vlen, unsigned long pos_l, unsigned long pos_h);
| long sys_pwritev(unsigned long fd, const struct iovec *vec,
|       unsigned long vlen, unsigned long pos_l, unsigned long pos_h);
| long sys_getcwd(char *buf, unsigned long size);
| long sys_mkdir(const char *pathname, int mode);
| long sys_chdir(const char *filename);
| long sys_fchdir(unsigned int fd);
| long sys_rmdir(const char *pathname);
| long sys_lookup_dcookie(u64 cookie64, char *buf, size_t len);
| long sys_quotactl(unsigned int cmd, const char *special,
|    qid_t id, void *addr);
| long sys_getdents(unsigned int fd,
|    struct linux_dirent *dirent,
|    unsigned int count);
| long sys_getdents64(unsigned int fd,
|    struct linux_dirent64 *dirent,
|    unsigned int count);
|
| long sys_setsockopt(int fd, int level, int optname,
|    char *optval, int optlen);
| long sys_getsockopt(int fd, int level, int optname,
|    char *optval, int *optlen);
| long sys_bind(int, struct sockaddr *, int);
| long sys_connect(int, struct sockaddr *, int);
| long sys_accept(int, struct sockaddr *, int *);
| long sys_accept4(int, struct sockaddr *, int *, int);
| long sys_getsockname(int, struct sockaddr *, int *);
| long sys_getpeername(int, struct sockaddr *, int *);
| long sys_send(int, void *, size_t, unsigned);
| long sys_sendto(int, void *, size_t, unsigned,
|    struct sockaddr *, int);
| long sys_sendmsg(int fd, struct msghdr *msg, unsigned flags);
| long sys_recv(int, void *, size_t, unsigned);
| long sys_recvfrom(int, void *, size_t, unsigned,
|    struct sockaddr *, int *);
| long sys_recvmsg(int fd, struct msghdr *msg, unsigned flags);
| long sys_recvmmsg(int fd, struct mmsghdr *msg,
|        unsigned int vlen, unsigned flags,
|        struct timespec *timeout);
| long sys_socket(int, int, int);
| long sys_socketpair(int, int, int, int *);
| long sys_socketcall(int call, unsigned long *args);
| long sys_listen(int, int);
| long sys_poll(struct pollfd *ufds, unsigned int nfds,
|    long timeout);
| long sys_select(int n, fd_set *inp, fd_set *outp,
|   fd_set *exp, struct timeval *tvp);
| long sys_old_select(struct sel_arg_struct *arg);
| long sys_epoll_create(int size);
| long sys_epoll_create1(int flags);
| long sys_epoll_ctl(int epfd, int op, int fd,
|    struct epoll_event *event);
| long sys_epoll_wait(int epfd, struct epoll_event *events,
|    int maxevents, int timeout);
| long sys_epoll_pwait(int epfd, struct epoll_event *events,
|    int maxevents, int timeout,
|    const sigset_t *sigmask,
|    size_t sigsetsize);
| long sys_gethostname(char *name, int len);
| long sys_sethostname(char *name, int len);
| long sys_setdomainname(char *name, int len);
| long sys_newuname(struct new_utsname *name);
| long sys_uname(struct old_utsname *);
| long sys_olduname(struct oldold_utsname *);
|
| long sys_getrlimit(unsigned int resource,
|    struct rlimit *rlim);
|
| long sys_old_getrlimit(unsigned int resource, struct rlimit *rlim);
|
| long sys_setrlimit(unsigned int resource,
|    struct rlimit *rlim);
| long sys_prlimit64(pid_t pid, unsigned int resource,
|    const struct rlimit64 *new_rlim,
|    struct rlimit64 *old_rlim);
| long sys_getrusage(int who, struct rusage *ru);
| long sys_umask(int mask);
|
| long sys_msgget(key_t key, int msgflg);
| long sys_msgsnd(int msqid, struct msgbuf *msgp,
|    size_t msgsz, int msgflg);
| long sys_msgrcv(int msqid, struct msgbuf *msgp,
|    size_t msgsz, long msgtyp, int msgflg);
| long sys_msgctl(int msqid, int cmd, struct msqid_ds *buf);
|
| long sys_semget(key_t key, int nsems, int semflg);
| long sys_semop(int semid, struct sembuf *sops,
|    unsigned nsops);
| long sys_semctl(int semid, int semnum, int cmd, union semun arg);
| long sys_semtimedop(int semid, struct sembuf *sops,
|    unsigned nsops,
|    const struct timespec *timeout);
| long sys_shmat(int shmid, char *shmaddr, int shmflg);
| long sys_shmget(key_t key, size_t size, int flag);
| long sys_shmdt(char *shmaddr);
| long sys_shmctl(int shmid, int cmd, struct shmid_ds *buf);
| long sys_ipc(unsigned int call, int first, unsigned long second,
|  unsigned long third, void *ptr, long fifth);
|
| long sys_mq_open(const char *name, int oflag, mode_t mode, struct mq_attr *attr);
| long sys_mq_unlink(const char *name);
| long sys_mq_timedsend(mqd_t mqdes, const char *msg_ptr, size_t msg_len, unsigned int msg_prio, const struct timespec *abs_timeout);
| long sys_mq_timedreceive(mqd_t mqdes, char *msg_ptr, size_t msg_len, unsigned int *msg_prio, const struct timespec *abs_timeout);
| long sys_mq_notify(mqd_t mqdes, const struct sigevent *notification);
| long sys_mq_getsetattr(mqd_t mqdes, const struct mq_attr *mqstat, struct mq_attr *omqstat);
|
| long sys_pciconfig_iobase(long which, unsigned long bus, unsigned long devfn);
| long sys_pciconfig_read(unsigned long bus, unsigned long dfn,
|    unsigned long off, unsigned long len,
|    void *buf);
| long sys_pciconfig_write(unsigned long bus, unsigned long dfn,
|    unsigned long off, unsigned long len,
|    void *buf);
|
| long sys_prctl(int option, unsigned long arg2, unsigned long arg3,
|   unsigned long arg4, unsigned long arg5);
| long sys_swapon(const char *specialfile, int swap_flags);
| long sys_swapoff(const char *specialfile);
| long sys_sysctl(struct __sysctl_args *args);
| long sys_sysinfo(struct sysinfo *info);
| long sys_sysfs(int option,
|    unsigned long arg1, unsigned long arg2);
| long sys_nfsservctl(int cmd,
|    struct nfsctl_arg *arg,
|    void *res);
| long sys_syslog(int type, char *buf, int len);
| long sys_uselib(const char *library);
| long sys_ni_syscall(void);
| long sys_ptrace(long request, long pid, unsigned long addr,
|      unsigned long data);
|
| long sys_add_key(const char *_type,
|       const char *_description,
|       const void *_payload,
|       size_t plen,
|       key_serial_t destringid);
|
| long sys_request_key(const char *_type,
|    const char *_description,
|    const char *_callout_info,
|    key_serial_t destringid);
|
| long sys_keyctl(int cmd, unsigned long arg2, unsigned long arg3,
|      unsigned long arg4, unsigned long arg5);
|
| long sys_ioprio_set(int which, int who, int ioprio);
| long sys_ioprio_get(int which, int who);
| long sys_set_mempolicy(int mode, unsigned long *nmask,
|    unsigned long maxnode);
| long sys_migrate_pages(pid_t pid, unsigned long maxnode,
|    const unsigned long *from,
|    const unsigned long *to);
| long sys_move_pages(pid_t pid, unsigned long nr_pages,
|    const void * *pages,
|    const int *nodes,
|    int *status,
|    int flags);
| long sys_mbind(unsigned long start, unsigned long len,
|    unsigned long mode,
|    unsigned long *nmask,
|    unsigned long maxnode,
|    unsigned flags);
| long sys_get_mempolicy(int *policy,
|    unsigned long *nmask,
|    unsigned long maxnode,
|    unsigned long addr, unsigned long flags);
|
| long sys_inotify_init(void);
| long sys_inotify_init1(int flags);
| long sys_inotify_add_watch(int fd, const char *path,
|     u32 mask);
| long sys_inotify_rm_watch(int fd, __s32 wd);
|
| long sys_spu_run(int fd, __u32 *unpc,
|     __u32 *ustatus);
| long sys_spu_create(const char *name,
|  unsigned int flags, mode_t mode, int fd);
|
| long sys_mknodat(int dfd, const char * filename, int mode,
|       unsigned dev);
| long sys_mkdirat(int dfd, const char * pathname, int mode);
| long sys_unlinkat(int dfd, const char * pathname, int flag);
| long sys_symlinkat(const char * oldname,
|         int newdfd, const char * newname);
| long sys_linkat(int olddfd, const char *oldname,
|      int newdfd, const char *newname, int flags);
| long sys_renameat(int olddfd, const char * oldname,
|        int newdfd, const char * newname);
| long sys_futimesat(int dfd, const char *filename,
|         struct timeval *utimes);
| long sys_faccessat(int dfd, const char *filename, int mode);
| long sys_fchmodat(int dfd, const char * filename,
|        mode_t mode);
| long sys_fchownat(int dfd, const char *filename, uid_t user,
|        gid_t group, int flag);
| long sys_openat(int dfd, const char *filename, int flags,
|      int mode);
| long sys_newfstatat(int dfd, const char *filename,
|          struct stat *statbuf, int flag);
| long sys_fstatat64(int dfd, const char *filename,
|          struct stat64 *statbuf, int flag);
| long sys_readlinkat(int dfd, const char *path, char *buf,
|          int bufsiz);
| long sys_utimensat(int dfd, const char *filename,
|    struct timespec *utimes, int flags);
| long sys_unshare(unsigned long unshare_flags);
|
| long sys_splice(int fd_in, loff_t *off_in,
|      int fd_out, loff_t *off_out,
|      size_t len, unsigned int flags);
|
| long sys_vmsplice(int fd, const struct iovec *iov,
|        unsigned long nr_segs, unsigned int flags);
|
| long sys_tee(int fdin, int fdout, size_t len, unsigned int flags);
|
| long sys_sync_file_range(int fd, loff_t offset, loff_t nbytes,
|     unsigned int flags);
| long sys_sync_file_range2(int fd, unsigned int flags,
|         loff_t offset, loff_t nbytes);
| long sys_get_robust_list(int pid,
|        struct robust_list_head * *head_ptr,
|        size_t *len_ptr);
| long sys_set_robust_list(struct robust_list_head *head,
|        size_t len);
| long sys_getcpu(unsigned *cpu, unsigned *node, struct getcpu_cache *cache);
| long sys_signalfd(int ufd, sigset_t *user_mask, size_t sizemask);
| long sys_signalfd4(int ufd, sigset_t *user_mask, size_t sizemask, int flags);
| long sys_timerfd_create(int clockid, int flags);
| long sys_timerfd_settime(int ufd, int flags,
|        const struct itimerspec *utmr,
|        struct itimerspec *otmr);
| long sys_timerfd_gettime(int ufd, struct itimerspec *otmr);
| long sys_eventfd(unsigned int count);
| long sys_eventfd2(unsigned int count, int flags);
| long sys_fallocate(int fd, int mode, loff_t offset, loff_t len);
| long sys_old_readdir(unsigned int, struct old_linux_dirent *, unsigned int);
| long sys_pselect6(int, fd_set *, fd_set *,
|        fd_set *, struct timespec *,
|        void *);
| long sys_ppoll(struct pollfd *, unsigned int,
|     struct timespec *, const sigset_t *,
|     size_t);
| long sys_fanotify_init(unsigned int flags, unsigned int event_f_flags);
| long sys_fanotify_mark(int fanotify_fd, unsigned int flags,
|      u64 mask, int fd,
|      const char *pathname);
|
|int kernel_execve(const char *filename, const char *const argv[], const char *const envp[]);
|
|
| long sys_perf_event_open(
|  struct perf_event_attr *attr_uptr,
|  pid_t pid, int cpu, int group_fd, unsigned long flags);
|
| long sys_mmap_pgoff(unsigned long addr, unsigned long len,
|   unsigned long prot, unsigned long flags,
|   unsigned long fd, unsigned long pgoff);
| long sys_old_mmap(struct mmap_arg_struct *arg);
|struct _fpreg {
| unsigned short significand[4];
| unsigned short exponent;
|};
|
|struct _fpxreg {
| unsigned short significand[4];
| unsigned short exponent;
| unsigned short padding[3];
|};
|
|struct _xmmreg {
| __u32 element[4];
|};
|
|
|struct _fpstate_ia32 {
|
| __u32 cw;
| __u32 sw;
| __u32 tag;
| __u32 ipoff;
| __u32 cssel;
| __u32 dataoff;
| __u32 datasel;
| struct _fpreg _st[8];
| unsigned short status;
| unsigned short magic;
|
|
| __u32 _fxsr_env[6];
| __u32 mxcsr;
| __u32 reserved;
| struct _fpxreg _fxsr_st[8];
| struct _xmmreg _xmm[8];
| __u32 padding[44];
| union {
|  __u32 padding2[12];
|  struct _fpx_sw_bytes sw_reserved;
| };
|};
|
|struct sigcontext_ia32 {
|       unsigned short gs, __gsh;
|       unsigned short fs, __fsh;
|       unsigned short es, __esh;
|       unsigned short ds, __dsh;
|       unsigned int di;
|       unsigned int si;
|       unsigned int bp;
|       unsigned int sp;
|       unsigned int bx;
|       unsigned int dx;
|       unsigned int cx;
|       unsigned int ax;
|       unsigned int trapno;
|       unsigned int err;
|       unsigned int ip;
|       unsigned short cs, __csh;
|       unsigned int flags;
|       unsigned int sp_at_signal;
|       unsigned short ss, __ssh;
|       unsigned int fpstate;
|       unsigned int oldmask;
|       unsigned int cr2;
|};
|
|
|struct sigaction32 {
| unsigned int sa_handler;
|
| unsigned int sa_flags;
| unsigned int sa_restorer;
| compat_sigset_t sa_mask;
|};
|
|struct old_sigaction32 {
| unsigned int sa_handler;
|
| compat_old_sigset_t sa_mask;
| unsigned int sa_flags;
| unsigned int sa_restorer;
|};
|
|typedef struct sigaltstack_ia32 {
| unsigned int ss_sp;
| int ss_flags;
| unsigned int ss_size;
|} stack_ia32_t;
|
|struct ucontext_ia32 {
| unsigned int uc_flags;
| unsigned int uc_link;
| stack_ia32_t uc_stack;
| struct sigcontext_ia32 uc_mcontext;
| compat_sigset_t uc_sigmask;
|};
|
|
|
|
|struct stat64 {
| unsigned long long st_dev;
| unsigned char __pad0[4];
|
|
| unsigned int __st_ino;
|
| unsigned int st_mode;
| unsigned int st_nlink;
|
| unsigned int st_uid;
| unsigned int st_gid;
|
| unsigned long long st_rdev;
| unsigned char __pad3[4];
|
| long long st_size;
| unsigned int st_blksize;
|
| long long st_blocks;
|
| unsigned st_atime;
| unsigned st_atime_nsec;
| unsigned st_mtime;
| unsigned st_mtime_nsec;
| unsigned st_ctime;
| unsigned st_ctime_nsec;
|
| unsigned long long st_ino;
|} ;
|
|typedef struct compat_siginfo {
| int si_signo;
| int si_errno;
| int si_code;
|
| union {
|  int _pad[((128 / sizeof(int)) - 3)];
|
|
|  struct {
|   unsigned int _pid;
|   unsigned int _uid;
|  } _kill;
|
|
|  struct {
|   compat_timer_t _tid;
|   int _overrun;
|   compat_sigval_t _sigval;
|   int _sys_private;
|   int _overrun_incr;
|  } _timer;
|
|
|  struct {
|   unsigned int _pid;
|   unsigned int _uid;
|   compat_sigval_t _sigval;
|  } _rt;
|
|
|  struct {
|   unsigned int _pid;
|   unsigned int _uid;
|   int _status;
|   compat_clock_t _utime;
|   compat_clock_t _stime;
|  } _sigchld;
|
|
|  struct {
|   unsigned int _addr;
|  } _sigfault;
|
|
|  struct {
|   int _band;
|   int _fd;
|  } _sigpoll;
| } _sifields;
|} compat_siginfo_t;
|
|
|
|
|struct linux_binprm;
|extern int ia32_setup_arg_pages(struct linux_binprm *bprm,
|    unsigned long stack_top, int exec_stack);
|struct mm_struct;
|extern void ia32_pick_mmap_layout(struct mm_struct *mm);
|static int putreg32(struct task_struct *child, unsigned regno, u32 value)
|{
| struct pt_regs *regs = ((struct pt_regs *)(child)->thread.sp0 - 1);
|
| switch (regno) {
|
| case 1: return set_segment_reg(child, 1, value); break;
     |This node is unreachable prev next
| case 1: return set_segment_reg(child, 1, value); break;
| case 1: return set_segment_reg(child, 1, value); break;
| case 1: return set_segment_reg(child, 1, value); break;
| case 1: return set_segment_reg(child, 1, value); break;
| case 1: return set_segment_reg(child, 1, value); break;
|
| case 1: regs->bx = value; break;
| case 1: regs->cx = value; break;
| case 1: regs->dx = value; break;
| case 1: regs->di = value; break;
| case 1: regs->si = value; break;
| case 1: regs->bp = value; break;
| case 1: regs->ax = value; break;
| case 1: regs->ip = value; break;
| case 1: regs->sp = value; break;
|
| case 1:
|
|
|
|
|
|
|
|  regs->orig_ax = value;
|  if (syscall_get_nr(child, regs) >= 0)
|   ((struct thread_info *)(child)->stack)->status |= 0x0002;
|  break;
|
| case 1:
|  return set_flags(child, value);
|
| case 1 ...
|  1:
|  regno -= 1;
|  return ptrace_set_debugreg(child, regno / 4, value);
|
| default:
|  if (regno > sizeof(struct user32) || (regno & 3))
|   return -5;
|
|
|
|
|
|  break;
| }
| return 0;
|}
|static int getreg32(struct task_struct *child, unsigned regno, u32 *val)
|{
| struct pt_regs *regs = ((struct pt_regs *)(child)->thread.sp0 - 1);
|
| switch (regno) {
|
| case 1: *val = get_segment_reg(child, 1); break;
| case 1: *val = get_segment_reg(child, 1); break;
| case 1: *val = get_segment_reg(child, 1); break;
| case 1: *val = get_segment_reg(child, 1); break;
|
| case 1: *val = regs->cs; break;
| case 1: *val = regs->ss; break;
| case 1: *val = regs->bx; break;
| case 1: *val = regs->cx; break;
| case 1: *val = regs->dx; break;
| case 1: *val = regs->di; break;
| case 1: *val = regs->si; break;
| case 1: *val = regs->bp; break;
| case 1: *val = regs->ax; break;
| case 1: *val = regs->orig_ax; break;
| case 1: *val = regs->ip; break;
| case 1: *val = regs->sp; break;
|
| case 1:
|  *val = get_flags(child);
|  break;
|
| case 1 ...
|  1:
|  regno -= 1;
|  *val = ptrace_get_debugreg(child, regno / 4);
|  break;
|
| default:
|  if (regno > sizeof(struct user32) || (regno & 3))
|   return -5;
|
|
|
|
|
|  *val = 0;
|  break;
| }
| return 0;
|}
|
|
|
|
|static int genregs32_get(struct task_struct *target,
|    const struct user_regset *regset,
|    unsigned int pos, unsigned int count,
|    void *kbuf, void *ubuf)
|{
| if (kbuf) {
|  compat_ulong_t *k = kbuf;
|  while (count >= sizeof(*k)) {
|   getreg32(target, pos, k++);
|   count -= sizeof(*k);
|   pos += sizeof(*k);
|  }
| } else {
|  compat_ulong_t *u = ubuf;
|  while (count >= sizeof(*u)) {
|   compat_ulong_t word;
|   getreg32(target, pos, &word);
|   if (({ int __pu_err; do { __pu_err = 0; (void)0; switch ((sizeof(*(u++)))) { case 1: asm volatile("1:	mov""b"" %""b""1,%2\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	mov %3,%0\n" "	jmp 2b\n" ".previous\n" " .section __ex_table,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " "1b" "," "3b" "\n" " .previous\n" : "=r"(__pu_err) : "iq"(((__typeof__(*(u++)))(word))), "m" ((*(struct __large_struct *)(((u++))))), "i" (-14), "0" (__pu_err)); break; case 2: asm volatile("1:	mov""w"" %""w""1,%2\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	mov %3,%0\n" "	jmp 2b\n" ".previous\n" " .section __ex_table,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " "1b" "," "3b" "\n" " .previous\n" : "=r"(__pu_err) : "ir"(((__typeof__(*(u++)))(word))), "m" ((*(struct __large_struct *)(((u++))))), "i" (-14), "0" (__pu_err)); break; case 4: asm volatile("1:	mov""l"" %""k""1,%2\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	mov %3,%0\n" "	jmp 2b\n" ".previous\n" " .section __ex_table,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " "1b" "," "3b" "\n" " .previous\n" : "=r"(__pu_err) : "ir"(((__typeof__(*(u++)))(word))), "m" ((*(struct __large_struct *)(((u++))))), "i" (-14), "0" (__pu_err)); break; case 8: asm volatile("1:	mov""q"" %""""1,%2\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	mov %3,%0\n" "	jmp 2b\n" ".previous\n" " .section __ex_table,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " "1b" "," "3b" "\n" " .previous\n" : "=r"(__pu_err) : "er"((__typeof__(*((u++))))(((__typeof__(*(u++)))(word)))), "m" ((*(struct __large_struct *)(((u++))))), "i" (-14), "0" (__pu_err)); break; default: __put_user_bad(); } } while (0); __pu_err; }))
|    return -14;
|   count -= sizeof(*u);
|   pos += sizeof(*u);
|  }
| }
|
| return 0;
|}
|
|static int genregs32_set(struct task_struct *target,
|    const struct user_regset *regset,
|    unsigned int pos, unsigned int count,
|    const void *kbuf, const void *ubuf)
|{
| int ret = 0;
| if (kbuf) {
|  const compat_ulong_t *k = kbuf;
|  while (count >= sizeof(*k) && !ret) {
|   ret = putreg32(target, pos, *k++);
|   count -= sizeof(*k);
|   pos += sizeof(*k);
|  }
| } else {
|  const compat_ulong_t *u = ubuf;
|  while (count >= sizeof(*u) && !ret) {
|   compat_ulong_t word;
|   ret = ({ int __gu_err; unsigned long __gu_val; do { __gu_err = 0; (void)0; switch ((sizeof(*(u++)))) { case 1: asm volatile("1:	mov""b"" %2,%""b""1\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	mov %3,%0\n" "	xor""b"" %""b""1,%""b""1\n" "	jmp 2b\n" ".previous\n" " .section __ex_table,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " "1b" "," "3b" "\n" " .previous\n" : "=r" (__gu_err), "=q"(__gu_val) : "m" ((*(struct __large_struct *)(((u++))))), "i" (-14), "0" (__gu_err)); break; case 2: asm volatile("1:	mov""w"" %2,%""w""1\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	mov %3,%0\n" "	xor""w"" %""w""1,%""w""1\n" "	jmp 2b\n" ".previous\n" " .section __ex_table,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " "1b" "," "3b" "\n" " .previous\n" : "=r" (__gu_err), "=r"(__gu_val) : "m" ((*(struct __large_struct *)(((u++))))), "i" (-14), "0" (__gu_err)); break; case 4: asm volatile("1:	mov""l"" %2,%""k""1\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	mov %3,%0\n" "	xor""l"" %""k""1,%""k""1\n" "	jmp 2b\n" ".previous\n" " .section __ex_table,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " "1b" "," "3b" "\n" " .previous\n" : "=r" (__gu_err), "=r"(__gu_val) : "m" ((*(struct __large_struct *)(((u++))))), "i" (-14), "0" (__gu_err)); break; case 8: asm volatile("1:	mov""q"" %2,%""""1\n" "2:\n" ".section .fixup,\"ax\"\n" "3:	mov %3,%0\n" "	xor""q"" %""""1,%""""1\n" "	jmp 2b\n" ".previous\n" " .section __ex_table,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " "1b" "," "3b" "\n" " .previous\n" : "=r" (__gu_err), "=r"(__gu_val) : "m" ((*(struct __large_struct *)(((u++))))), "i" (-14), "0" (__gu_err)); break; default: (__gu_val) = __get_user_bad(); } } while (0); ((word)) = ( __typeof__(*((u++))))__gu_val; __gu_err; });
|   if (ret)
|    break;
|   ret = putreg32(target, pos, word);
|   count -= sizeof(*u);
|   pos += sizeof(*u);
|  }
| }
| return ret;
|}
|
|long compat_arch_ptrace(struct task_struct *child, compat_long_t request,
|   compat_ulong_t caddr, compat_ulong_t cdata)
|{
| unsigned long addr = caddr;
| unsigned long data = cdata;
| void *datap = compat_ptr(data);
| int ret;
| __u32 val;
|
| switch (request) {
| case 3:
|  ret = getreg32(child, addr, &val);
|  if (ret == 0)
|   ret = __st_put_user_st__(val, (__u32 *)datap);
|  break;
|
| case 6:
|  ret = putreg32(child, addr, data);
|  break;
|
| case 12:
|  return copy_regset_to_user(child, &user_x86_32_view,
|        REGSET_GENERAL,
|        0, sizeof(struct user_regs_struct32),
|        datap);
|
| case 13:
|  return copy_regset_from_user(child, &user_x86_32_view,
|          REGSET_GENERAL, 0,
|          sizeof(struct user_regs_struct32),
|          datap);
|
| case 14:
|  return copy_regset_to_user(child, &user_x86_32_view,
|        REGSET_FP, 0,
|        sizeof(struct user_i387_ia32_struct),
|        datap);
|
| case 15:
|  return copy_regset_from_user(
|   child, &user_x86_32_view, REGSET_FP,
|   0, sizeof(struct user_i387_ia32_struct), datap);
|
| case 18:
|  return copy_regset_to_user(child, &user_x86_32_view,
|        REGSET_XFP, 0,
|        sizeof(struct user32_fxsr_struct),
|        datap);
|
| case 19:
|  return copy_regset_from_user(child, &user_x86_32_view,
|          REGSET_XFP, 0,
|          sizeof(struct user32_fxsr_struct),
|          datap);
|
| case 25:
| case 26:
|  return arch_ptrace(child, request, addr, data);
|
| default:
|  return compat_ptrace_request(child, request, addr, data);
| }
|
| return ret;
|}
|
|
|
|
|
|static struct user_regset x86_64_regsets[] = {
| [REGSET_GENERAL] = {
|  .core_note_type = 1,
|  .n = sizeof(struct user_regs_struct) / sizeof(long),
|  .size = sizeof(long), .align = sizeof(long),
|  .get = genregs_get, .set = genregs_set
| },
| [REGSET_FP] = {
|  .core_note_type = 2,
|  .n = sizeof(struct user_i387_struct) / sizeof(long),
|  .size = sizeof(long), .align = sizeof(long),
|  .active = xfpregs_active, .get = xfpregs_get, .set = xfpregs_set
| },
| [REGSET_XSTATE] = {
|  .core_note_type = 0x202,
|  .size = sizeof(u64), .align = sizeof(u64),
|  .active = fpregs_active, .get = xstateregs_get,
|  .set = xstateregs_set
| },
| [REGSET_IOPERM64] = {
|  .core_note_type = 0x201,
|  .n = ((65536/8)/sizeof(long)),
|  .size = sizeof(long), .align = sizeof(long),
|  .active = ioperm_active, .get = ioperm_get
| },
|};
|
|static const struct user_regset_view user_x86_64_view = {
| .name = "x86_64", .e_machine = 62,
| .regsets = x86_64_regsets, .n = (sizeof(x86_64_regsets) / sizeof((x86_64_regsets)[0]) + (sizeof(struct { int:-!!(0); })))
|};
|static struct user_regset x86_32_regsets[] = {
| [REGSET_GENERAL] = {
|  .core_note_type = 1,
|  .n = sizeof(struct user_regs_struct32) / sizeof(u32),
|  .size = sizeof(u32), .align = sizeof(u32),
|  .get = genregs32_get, .set = genregs32_set
| },
| [REGSET_FP] = {
|  .core_note_type = 2,
|  .n = sizeof(struct user_i387_ia32_struct) / sizeof(u32),
|  .size = sizeof(u32), .align = sizeof(u32),
|  .active = fpregs_active, .get = fpregs_get, .set = fpregs_set
| },
| [REGSET_XFP] = {
|  .core_note_type = 0x46e62b7f,
|  .n = sizeof(struct user32_fxsr_struct) / sizeof(u32),
|  .size = sizeof(u32), .align = sizeof(u32),
|  .active = xfpregs_active, .get = xfpregs_get, .set = xfpregs_set
| },
| [REGSET_XSTATE] = {
|  .core_note_type = 0x202,
|  .size = sizeof(u64), .align = sizeof(u64),
|  .active = fpregs_active, .get = xstateregs_get,
|  .set = xstateregs_set
| },
| [REGSET_TLS] = {
|  .core_note_type = 0x200,
|  .n = 3, .bias = 12,
|  .size = sizeof(struct user_desc),
|  .align = sizeof(struct user_desc),
|  .active = regset_tls_active,
|  .get = regset_tls_get, .set = regset_tls_set
| },
| [REGSET_IOPERM32] = {
|  .core_note_type = 0x201,
|  .n = (65536/8) / sizeof(u32),
|  .size = sizeof(u32), .align = sizeof(u32),
|  .active = ioperm_active, .get = ioperm_get
| },
|};
|
|static const struct user_regset_view user_x86_32_view = {
| .name = "i386", .e_machine = 3,
| .regsets = x86_32_regsets, .n = (sizeof(x86_32_regsets) / sizeof((x86_32_regsets)[0]) + (sizeof(struct { int:-!!(0); })))
|};
|
|
|
|
|
|
|u64 xstate_fx_sw_bytes[6];
|
|void update_regset_xstate_info(unsigned int size, u64 xstate_mask)
|{
|
| x86_64_regsets[REGSET_XSTATE].n = size / sizeof(u64);
|
|
| x86_32_regsets[REGSET_XSTATE].n = size / sizeof(u64);
|
| xstate_fx_sw_bytes[0] = xstate_mask;
|}
|
|const struct user_regset_view *task_user_regset_view(struct task_struct *task)
|{
|
| if (test_tsk_thread_flag(task, 17))
|
|
|  return &user_x86_32_view;
|
|
| return &user_x86_64_view;
|
|}
|
|static void fill_sigtrap_info(struct task_struct *tsk,
|    struct pt_regs *regs,
|    int error_code, int si_code,
|    struct siginfo *info)
|{
| tsk->thread.trap_no = 1;
| tsk->thread.error_code = error_code;
|
| __st_memset_st__(info, 0, sizeof(*info));
| info->si_signo = 5;
| info->si_code = si_code;
| info->_sifields._sigfault._addr = user_mode_vm(regs) ? (void *)regs->ip : ((void *)0);
|}
|
|void user_single_step_siginfo(struct task_struct *tsk,
|    struct pt_regs *regs,
|    struct siginfo *info)
|{
| fill_sigtrap_info(tsk, regs, 0, ((3 << 16)|1), info);
|}
|
|void send_sigtrap(struct task_struct *tsk, struct pt_regs *regs,
|      int error_code, int si_code)
|{
| struct siginfo info;
|
| fill_sigtrap_info(tsk, regs, error_code, si_code, &info);
|
| force_sig_info(5, &info, tsk);
|}
| long syscall_trace_enter(struct pt_regs *regs)
|{
| long ret = 0;
| if (test_ti_thread_flag(current_thread_info(), 4))
|  regs->flags |= 0x00000100;
|
|
| secure_computing(regs->orig_ax);
|
| if (test_ti_thread_flag(current_thread_info(), 6))
|  ret = -1L;
|
| if ((ret || test_ti_thread_flag(current_thread_info(), 0)) &&
|     tracehook_report_syscall_entry(regs))
|  ret = -1L;
|
| if (test_ti_thread_flag(current_thread_info(), 28))
|  trace_sys_enter(regs, regs->orig_ax);
|
| if (get_current()->audit_context) {
|  if (is_compat_task())
|   audit_syscall_entry((3|0x40000000),
|         regs->orig_ax,
|         regs->bx, regs->cx,
|         regs->dx, regs->si);
|
|  else
|   audit_syscall_entry((62|0x80000000|0x40000000),
|         regs->orig_ax,
|         regs->di, regs->si,
|         regs->dx, regs->r10);
|
| }
|
| return ret ?: regs->orig_ax;
|}
|
| void syscall_trace_leave(struct pt_regs *regs)
|{
| bool step;
|
| if (get_current()->audit_context)
|  audit_syscall_exit(( ((long)(regs->ax))<0?2:1 ), regs->ax);
|
| if (test_ti_thread_flag(current_thread_info(), 28))
|  trace_sys_exit(regs, regs->ax);
|
|
|
|
|
|
|
| step = test_ti_thread_flag(current_thread_info(), 4) &&
|   !test_ti_thread_flag(current_thread_info(), 6);
| if (step || test_ti_thread_flag(current_thread_info(), 0))
|  tracehook_report_syscall_exit(regs, step);
|}