Quelle  ptrace.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0

#include <linux/sched.h>
#include <linux/elf.h>
#include <linux/regset.h>
#include <asm/user32.h>
#include <asm/sigcontext.h>

#ifdef CONFIG_X86_32
/*
 * FPU tag word conversions.
 */

static inline unsigned short twd_i387_to_fxsr(unsigned short twd)
{
 unsigned int tmp; /* to avoid 16 bit prefixes in the code */

 /* Transform each pair of bits into 01 (valid) or 00 (empty) */
 tmp = ~twd;
 tmp = (tmp | (tmp>>1)) & 0x5555; /* 0V0V0V0V0V0V0V0V */
 /* and move the valid bits to the lower byte. */
 tmp = (tmp | (tmp >> 1)) & 0x3333; /* 00VV00VV00VV00VV */
 tmp = (tmp | (tmp >> 2)) & 0x0f0f; /* 0000VVVV0000VVVV */
 tmp = (tmp | (tmp >> 4)) & 0x00ff; /* 00000000VVVVVVVV */
 return tmp;
}

static inline unsigned long
twd_fxsr_to_i387(const struct user_fxsr_struct *fxsave)
{
 struct _fpxreg *st = NULL;
 unsigned long twd = (unsigned long) fxsave->twd;
 unsigned long tag;
 unsigned long ret = 0xffff0000;
 int i;

#define FPREG_ADDR(f, n) ((char *)&(f)->st_space + (n) * 16)

 for (i = 0; i < 8; i++) {
  if (twd & 0x1) {
   st = (struct _fpxreg *) FPREG_ADDR(fxsave, i);

   switch (st->exponent & 0x7fff) {
   case 0x7fff:
    tag = 2;  /* Special */
    break;
   case 0x0000:
    if (!st->significand[0] &&
        !st->significand[1] &&
        !st->significand[2] &&
        !st->significand[3]) {
     tag = 1; /* Zero */
    } else {
     tag = 2; /* Special */
    }
    break;
   default:
    if (st->significand[3] & 0x8000)
     tag = 0; /* Valid */
    else
     tag = 2; /* Special */
    break;
   }
  } else {
   tag = 3;   /* Empty */
  }
  ret |= (tag << (2 * i));
  twd = twd >> 1;
 }
 return ret;
}

/*
 * Get/set the old 32bit i387 registers (pre-FPX)
 *
 * We provide simple wrappers for mcontext.c, they are only defined locally
 * because mcontext.c is userspace facing and needs to a different definition
 * of the structures.
 */
static int _um_i387_from_fxsr(struct membuf to,
         const struct user_fxsr_struct *fxsave)
{
 int i;

 membuf_store(&to, (unsigned long)fxsave->cwd | 0xffff0000ul);
 membuf_store(&to, (unsigned long)fxsave->swd | 0xffff0000ul);
 membuf_store(&to, twd_fxsr_to_i387(fxsave));
 membuf_store(&to, fxsave->fip);
 membuf_store(&to, fxsave->fcs | ((unsigned long)fxsave->fop << 16));
 membuf_store(&to, fxsave->foo);
 membuf_store(&to, fxsave->fos);

 for (i = 0; i < 8; i++)
  membuf_write(&to, (void *)fxsave->st_space + i * 16, 10);

 return 0;
}

int um_i387_from_fxsr(struct user_i387_struct *i387,
        const struct user_fxsr_struct *fxsave);

int um_i387_from_fxsr(struct user_i387_struct *i387,
        const struct user_fxsr_struct *fxsave)
{
 struct membuf to = {
  .p = i387,
  .left = sizeof(*i387),
 };

 return _um_i387_from_fxsr(to, fxsave);
}

static int fpregs_legacy_get(struct task_struct *target,
        const struct user_regset *regset,
        struct membuf to)
{
 struct user_fxsr_struct *fxsave = (void *)target->thread.regs.regs.fp;

 return _um_i387_from_fxsr(to, fxsave);
}

int um_fxsr_from_i387(struct user_fxsr_struct *fxsave,
        const struct user_i387_struct *from);

int um_fxsr_from_i387(struct user_fxsr_struct *fxsave,
        const struct user_i387_struct *from)
{
 int i;

 fxsave->cwd = (unsigned short)(from->cwd & 0xffff);
 fxsave->swd = (unsigned short)(from->swd & 0xffff);
 fxsave->twd = twd_i387_to_fxsr((unsigned short)(from->twd & 0xffff));
 fxsave->fip = from->fip;
 fxsave->fop = (unsigned short)((from->fcs & 0xffff0000ul) >> 16);
 fxsave->fcs = (from->fcs & 0xffff);
 fxsave->foo = from->foo;
 fxsave->fos = from->fos;

 for (i = 0; i < 8; i++) {
  memcpy((void *)fxsave->st_space + i * 16,
         (void *)from->st_space + i * 10, 10);
 }

 return 0;
}

static int fpregs_legacy_set(struct task_struct *target,
        const struct user_regset *regset,
        unsigned int pos, unsigned int count,
        const void *kbuf, const void __user *ubuf)
{
 struct user_fxsr_struct *fxsave = (void *)target->thread.regs.regs.fp;
 const struct user_i387_struct *from;
 struct user_i387_struct buf;

 if (ubuf) {
  if (copy_from_user(&buf, ubuf, sizeof(buf)))
   return -EFAULT;
  from = &buf;
 } else {
  from = kbuf;
 }

 return um_fxsr_from_i387(fxsave, from);
}
#endif

static int genregs_get(struct task_struct *target,
         const struct user_regset *regset,
         struct membuf to)
{
 int reg;

 for (reg = 0; to.left; reg++)
  membuf_store(&to, getreg(target, reg * sizeof(unsigned long)));
 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 __user *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  __user *u = ubuf;

  while (count >= sizeof(*u) && !ret) {
   unsigned long word;

   ret = __get_user(word, u++);
   if (ret)
    break;
   ret = putreg(target, pos, word);
   count -= sizeof(*u);
   pos += sizeof(*u);
  }
 }
 return ret;
}

static int generic_fpregs_active(struct task_struct *target, const struct user_regset *regset)
{
 return regset->n;
}

static int generic_fpregs_get(struct task_struct *target,
         const struct user_regset *regset,
         struct membuf to)
{
 void *fpregs = task_pt_regs(target)->regs.fp;

 membuf_write(&to, fpregs, regset->size * regset->n);
 return 0;
}

static int generic_fpregs_set(struct task_struct *target,
         const struct user_regset *regset,
         unsigned int pos, unsigned int count,
         const void *kbuf, const void __user *ubuf)
{
 void *fpregs = task_pt_regs(target)->regs.fp;

 return user_regset_copyin(&pos, &count, &kbuf, &ubuf,
      fpregs, 0, regset->size * regset->n);
}

static struct user_regset uml_regsets[] __ro_after_init = {
 [REGSET_GENERAL] = {
  USER_REGSET_NOTE_TYPE(PRSTATUS),
  .n  = sizeof(struct user_regs_struct) / sizeof(long),
  .size  = sizeof(long),
  .align  = sizeof(long),
  .regset_get = genregs_get,
  .set  = genregs_set
 },
#ifdef CONFIG_X86_32
 /* Old FP registers, they are needed in signal frames */
 [REGSET_FP_LEGACY] = {
  USER_REGSET_NOTE_TYPE(PRFPREG),
  .n  = sizeof(struct user_i387_ia32_struct) / sizeof(long),
  .size  = sizeof(long),
  .align  = sizeof(long),
  .active  = generic_fpregs_active,
  .regset_get = fpregs_legacy_get,
  .set  = fpregs_legacy_set,
 },
#endif
 [REGSET_FP] = {
#ifdef CONFIG_X86_32
  USER_REGSET_NOTE_TYPE(PRXFPREG),
  .n  = sizeof(struct user32_fxsr_struct) / sizeof(long),
#else
  USER_REGSET_NOTE_TYPE(PRFPREG),
  .n  = sizeof(struct user_i387_struct) / sizeof(long),
#endif
  .size  = sizeof(long),
  .align  = sizeof(long),
  .active  = generic_fpregs_active,
  .regset_get = generic_fpregs_get,
  .set  = generic_fpregs_set,
 },
 [REGSET_XSTATE] = {
  USER_REGSET_NOTE_TYPE(X86_XSTATE),
  .size  = sizeof(long),
  .align  = sizeof(long),
  .active  = generic_fpregs_active,
  .regset_get = generic_fpregs_get,
  .set  = generic_fpregs_set,
 },
 /* TODO: Add TLS regset for 32bit */
};

static const struct user_regset_view user_uml_view = {
#ifdef CONFIG_X86_32
 .name = "i386", .e_machine = EM_386,
#else
 .name = "x86_64", .e_machine = EM_X86_64,
#endif
 .regsets = uml_regsets, .n = ARRAY_SIZE(uml_regsets)
};

const struct user_regset_view *
task_user_regset_view(struct task_struct *tsk)
{
 return &user_uml_view;
}

static int __init init_regset_xstate_info(void)
{
 uml_regsets[REGSET_XSTATE].n =
  host_fp_size / uml_regsets[REGSET_XSTATE].size;

 return 0;
}
arch_initcall(init_regset_xstate_info);