Quelle  ptrace_32.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/* ptrace.c: Sparc process tracing support.
 *
 * Copyright (C) 1996, 2008 David S. Miller (davem@davemloft.net)
 *
 * Based upon code written by Ross Biro, Linus Torvalds, Bob Manson,
 * and David Mosberger.
 *
 * Added Linux support -miguel (weird, eh?, the original code was meant
 * to emulate SunOS).
 */

#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/mm.h>
#include <linux/errno.h>
#include <linux/ptrace.h>
#include <linux/user.h>
#include <linux/smp.h>
#include <linux/security.h>
#include <linux/signal.h>
#include <linux/regset.h>
#include <linux/elf.h>

#include <linux/uaccess.h>
#include <asm/cacheflush.h>

#include "kernel.h"

/* #define ALLOW_INIT_TRACING */

/*
 * Called by kernel/ptrace.c when detaching..
 *
 * Make sure single step bits etc are not set.
 */
void ptrace_disable(struct task_struct *child)
{
 /* nothing to do */
}

enum sparc_regset {
 REGSET_GENERAL,
 REGSET_FP,
};

static int regwindow32_get(struct task_struct *target,
      const struct pt_regs *regs,
      u32 *uregs)
{
 unsigned long reg_window = regs->u_regs[UREG_I6];
 int size = 16 * sizeof(u32);

 if (target == current) {
  if (copy_from_user(uregs, (void __user *)reg_window, size))
   return -EFAULT;
 } else {
  if (access_process_vm(target, reg_window, uregs, size,
          FOLL_FORCE) != size)
   return -EFAULT;
 }
 return 0;
}

static int regwindow32_set(struct task_struct *target,
      const struct pt_regs *regs,
      u32 *uregs)
{
 unsigned long reg_window = regs->u_regs[UREG_I6];
 int size = 16 * sizeof(u32);

 if (target == current) {
  if (copy_to_user((void __user *)reg_window, uregs, size))
   return -EFAULT;
 } else {
  if (access_process_vm(target, reg_window, uregs, size,
          FOLL_FORCE | FOLL_WRITE) != size)
   return -EFAULT;
 }
 return 0;
}

static int genregs32_get(struct task_struct *target,
    const struct user_regset *regset,
    struct membuf to)
{
 const struct pt_regs *regs = target->thread.kregs;
 u32 uregs[16];

 if (target == current)
  flush_user_windows();

 membuf_write(&to, regs->u_regs, 16 * sizeof(u32));
 if (!to.left)
  return 0;
 if (regwindow32_get(target, regs, uregs))
  return -EFAULT;
 membuf_write(&to, uregs, 16 * sizeof(u32));
 membuf_store(&to, regs->psr);
 membuf_store(&to, regs->pc);
 membuf_store(&to, regs->npc);
 membuf_store(&to, regs->y);
 return membuf_zero(&to, 2 * sizeof(u32));
}

static int genregs32_set(struct task_struct *target,
    const struct user_regset *regset,
    unsigned int pos, unsigned int count,
    const void *kbuf, const void __user *ubuf)
{
 struct pt_regs *regs = target->thread.kregs;
 u32 uregs[16];
 u32 psr;
 int ret;

 if (target == current)
  flush_user_windows();

 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
     regs->u_regs,
     0, 16 * sizeof(u32));
 if (ret || !count)
  return ret;

 if (regwindow32_get(target, regs, uregs))
  return -EFAULT;
 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
     uregs,
     16 * sizeof(u32), 32 * sizeof(u32));
 if (ret)
  return ret;
 if (regwindow32_set(target, regs, uregs))
  return -EFAULT;
 if (!count)
  return 0;

 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
     &psr,
     32 * sizeof(u32), 33 * sizeof(u32));
 if (ret)
  return ret;
 regs->psr = (regs->psr & ~(PSR_ICC | PSR_SYSCALL)) |
      (psr & (PSR_ICC | PSR_SYSCALL));
 if (!count)
  return 0;
 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
     ®s->pc,
     33 * sizeof(u32), 34 * sizeof(u32));
 if (ret || !count)
  return ret;
 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
     ®s->npc,
     34 * sizeof(u32), 35 * sizeof(u32));
 if (ret || !count)
  return ret;
 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
     ®s->y,
     35 * sizeof(u32), 36 * sizeof(u32));
 if (ret || !count)
  return ret;
 user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf, 36 * sizeof(u32),
      38 * sizeof(u32));
 return 0;
}

static int fpregs32_get(struct task_struct *target,
   const struct user_regset *regset,
   struct membuf to)
{
#if 0
 if (target == current)
  save_and_clear_fpu();
#endif

 membuf_write(&to, target->thread.float_regs, 32 * sizeof(u32));
 membuf_zero(&to, sizeof(u32));
 membuf_write(&to, &target->thread.fsr, sizeof(u32));
 membuf_store(&to, (u32)((1 << 8) | (8 << 16)));
 return membuf_zero(&to, 64 * sizeof(u32));
}

static int fpregs32_set(struct task_struct *target,
   const struct user_regset *regset,
   unsigned int pos, unsigned int count,
   const void *kbuf, const void __user *ubuf)
{
 unsigned long *fpregs = target->thread.float_regs;
 int ret;

#if 0
 if (target == current)
  save_and_clear_fpu();
#endif
 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
     fpregs,
     0, 32 * sizeof(u32));
 if (!ret)
  user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf,
       32 * sizeof(u32),
       33 * sizeof(u32));
 if (!ret)
  ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
      &target->thread.fsr,
      33 * sizeof(u32),
      34 * sizeof(u32));
 if (!ret)
  user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf,
       34 * sizeof(u32), -1);
 return ret;
}

static const struct user_regset sparc32_regsets[] = {
 /* Format is:
 *  G0 --> G7
 * O0 --> O7
 * L0 --> L7
 * I0 --> I7
 * PSR, PC, nPC, Y, WIM, TBR
 */
 [REGSET_GENERAL] = {
  USER_REGSET_NOTE_TYPE(PRSTATUS),
  .n = 38,
  .size = sizeof(u32), .align = sizeof(u32),
  .regset_get = genregs32_get, .set = genregs32_set
 },
 /* Format is:
 * F0 --> F31
 * empty 32-bit word
 * FSR (32--bit word)
 * FPU QUEUE COUNT (8-bit char)
 * FPU QUEUE ENTRYSIZE (8-bit char)
 * FPU ENABLED (8-bit char)
 * empty 8-bit char
 * FPU QUEUE (64 32-bit ints)
 */
 [REGSET_FP] = {
  USER_REGSET_NOTE_TYPE(PRFPREG),
  .n = 99,
  .size = sizeof(u32), .align = sizeof(u32),
  .regset_get = fpregs32_get, .set = fpregs32_set
 },
};

static int getregs_get(struct task_struct *target,
    const struct user_regset *regset,
    struct membuf to)
{
 const struct pt_regs *regs = target->thread.kregs;

 if (target == current)
  flush_user_windows();

 membuf_store(&to, regs->psr);
 membuf_store(&to, regs->pc);
 membuf_store(&to, regs->npc);
 membuf_store(&to, regs->y);
 return membuf_write(&to, regs->u_regs + 1, 15 * sizeof(u32));
}

static int setregs_set(struct task_struct *target,
    const struct user_regset *regset,
    unsigned int pos, unsigned int count,
    const void *kbuf, const void __user *ubuf)
{
 struct pt_regs *regs = target->thread.kregs;
 u32 v[4];
 int ret;

 if (target == current)
  flush_user_windows();

 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
     v,
     0, 4 * sizeof(u32));
 if (ret)
  return ret;
 regs->psr = (regs->psr & ~(PSR_ICC | PSR_SYSCALL)) |
      (v[0] & (PSR_ICC | PSR_SYSCALL));
 regs->pc = v[1];
 regs->npc = v[2];
 regs->y = v[3];
 return user_regset_copyin(&pos, &count, &kbuf, &ubuf,
     regs->u_regs + 1,
     4 * sizeof(u32) , 19 * sizeof(u32));
}

static int getfpregs_get(struct task_struct *target,
   const struct user_regset *regset,
   struct membuf to)
{
#if 0
 if (target == current)
  save_and_clear_fpu();
#endif
 membuf_write(&to, &target->thread.float_regs, 32 * sizeof(u32));
 membuf_write(&to, &target->thread.fsr, sizeof(u32));
 return membuf_zero(&to, 35 * sizeof(u32));
}

static int setfpregs_set(struct task_struct *target,
   const struct user_regset *regset,
   unsigned int pos, unsigned int count,
   const void *kbuf, const void __user *ubuf)
{
 unsigned long *fpregs = target->thread.float_regs;
 int ret;

#if 0
 if (target == current)
  save_and_clear_fpu();
#endif
 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
     fpregs,
     0, 32 * sizeof(u32));
 if (ret)
  return ret;
 return user_regset_copyin(&pos, &count, &kbuf, &ubuf,
     &target->thread.fsr,
     32 * sizeof(u32),
     33 * sizeof(u32));
}

static const struct user_regset ptrace32_regsets[] = {
 [REGSET_GENERAL] = {
  .n = 19, .size = sizeof(u32),
  .regset_get = getregs_get, .set = setregs_set,
 },
 [REGSET_FP] = {
  .n = 68, .size = sizeof(u32),
  .regset_get = getfpregs_get, .set = setfpregs_set,
 },
};

static const struct user_regset_view ptrace32_view = {
 .regsets = ptrace32_regsets, .n = ARRAY_SIZE(ptrace32_regsets)
};

static const struct user_regset_view user_sparc32_view = {
 .name = "sparc", .e_machine = EM_SPARC,
 .regsets = sparc32_regsets, .n = ARRAY_SIZE(sparc32_regsets)
};

const struct user_regset_view *task_user_regset_view(struct task_struct *task)
{
 return &user_sparc32_view;
}

struct fps {
 unsigned long regs[32];
 unsigned long fsr;
 unsigned long flags;
 unsigned long extra;
 unsigned long fpqd;
 struct fq {
  unsigned long *insnaddr;
  unsigned long insn;
 } fpq[16];
};

long arch_ptrace(struct task_struct *child, long request,
   unsigned long addr, unsigned long data)
{
 unsigned long addr2 = current->thread.kregs->u_regs[UREG_I4];
 void __user *addr2p;
 struct pt_regs __user *pregs;
 struct fps __user *fps;
 int ret;

 addr2p = (void __user *) addr2;
 pregs = (struct pt_regs __user *) addr;
 fps = (struct fps __user *) addr;

 switch(request) {
 case PTRACE_GETREGS: {
  ret = copy_regset_to_user(child, &ptrace32_view,
       REGSET_GENERAL, 0,
       19 * sizeof(u32),
       pregs);
  break;
 }

 case PTRACE_SETREGS: {
  ret = copy_regset_from_user(child, &ptrace32_view,
         REGSET_GENERAL, 0,
         19 * sizeof(u32),
         pregs);
  break;
 }

 case PTRACE_GETFPREGS: {
  ret = copy_regset_to_user(child, &ptrace32_view,
       REGSET_FP, 0,
       68 * sizeof(u32),
       fps);
  break;
 }

 case PTRACE_SETFPREGS: {
  ret = copy_regset_from_user(child, &ptrace32_view,
       REGSET_FP, 0,
       33 * sizeof(u32),
       fps);
  break;
 }

 case PTRACE_READTEXT:
 case PTRACE_READDATA:
  ret = ptrace_readdata(child, addr, addr2p, data);

  if (ret == data)
   ret = 0;
  else if (ret >= 0)
   ret = -EIO;
  break;

 case PTRACE_WRITETEXT:
 case PTRACE_WRITEDATA:
  ret = ptrace_writedata(child, addr2p, addr, data);

  if (ret == data)
   ret = 0;
  else if (ret >= 0)
   ret = -EIO;
  break;

 default:
  if (request == PTRACE_SPARC_DETACH)
   request = PTRACE_DETACH;
  ret = ptrace_request(child, request, addr, data);
  break;
 }

 return ret;
}

asmlinkage int syscall_trace(struct pt_regs *regs, int syscall_exit_p)
{
 int ret = 0;

 if (test_thread_flag(TIF_SYSCALL_TRACE)) {
  if (syscall_exit_p)
   ptrace_report_syscall_exit(regs, 0);
  else
   ret = ptrace_report_syscall_entry(regs);
 }

 return ret;
}