arch/s390/kernel/binfmt_elf32.c

   1 /*
   2  * Support for 32-bit Linux for S390 ELF binaries.
   3  *
   4  * Copyright (C) 2000 IBM Deutschland Entwicklung GmbH, IBM Corporation
   5  * Author(s): Gerhard Tonn (ton@de.ibm.com)
   6  *
   7  * Heavily inspired by the 32-bit Sparc compat code which is
   8  * Copyright (C) 1995, 1996, 1997, 1998 David S. Miller (davem@redhat.com)
   9  * Copyright (C) 1995, 1996, 1997, 1998 Jakub Jelinek   (jj@ultra.linux.cz)
  10  */
  11
  12 #define __ASMS390_ELF_H
  13
  14 #include <linux/time.h>
  15
  16 /*
  17  * These are used to set parameters in the core dumps.
  18  */
  19 #define ELF_CLASS       ELFCLASS32
  20 #define ELF_DATA        ELFDATA2MSB
  21 #define ELF_ARCH        EM_S390
  22
  23 /*
  24  * This is used to ensure we don't load something for the wrong architecture.
  25  */
  26 #define elf_check_arch(x) \
  27         (((x)->e_machine == EM_S390 || (x)->e_machine == EM_S390_OLD) \
  28          && (x)->e_ident[EI_CLASS] == ELF_CLASS)
  29
  30 /* ELF register definitions */
  31 #define NUM_GPRS      16
  32 #define NUM_FPRS      16
  33 #define NUM_ACRS      16
  34
  35 /* For SVR4/S390 the function pointer to be registered with `atexit` is
  36    passed in R14. */
  37 #define ELF_PLAT_INIT(_r, load_addr) \
  38         do { \
  39                 _r->gprs[14] = 0; \
  40         } while(0)
  41
  42 #define USE_ELF_CORE_DUMP
  43 #define ELF_EXEC_PAGESIZE       4096
  44
  45 /* This is the location that an ET_DYN program is loaded if exec'ed.  Typical
  46    use of this is to invoke "./ld.so someprog" to test out a new version of
  47    the loader.  We need to make sure that it is out of the way of the program
  48    that it will "exec", and that there is sufficient room for the brk.  */
  49
  50 #define ELF_ET_DYN_BASE         (TASK_SIZE / 3 * 2)
  51
  52 /* Wow, the "main" arch needs arch dependent functions too.. :) */
  53
  54 /* regs is struct pt_regs, pr_reg is elf_gregset_t (which is
  55    now struct_user_regs, they are different) */
  56
  57 #define ELF_CORE_COPY_REGS(pr_reg, regs) dump_regs32(regs, &pr_reg);
  58
  59 #define ELF_CORE_COPY_TASK_REGS(tsk, regs) dump_task_regs32(tsk, regs)
  60
  61 #define ELF_CORE_COPY_FPREGS(tsk, fpregs) dump_task_fpu(tsk, fpregs)
  62
  63 /* This yields a mask that user programs can use to figure out what
  64    instruction set this CPU supports. */
  65
  66 #define ELF_HWCAP (0)
  67
  68 /* This yields a string that ld.so will use to load implementation
  69    specific libraries for optimization.  This is more specific in
  70    intent than poking at uname or /proc/cpuinfo.
  71
  72    For the moment, we have only optimizations for the Intel generations,
  73    but that could change... */
  74
  75 #define ELF_PLATFORM (NULL)
  76
  77 #define SET_PERSONALITY(ex, ibcs2)                      \
  78 do {                                                    \
  79         if (ibcs2)                                      \
  80                 set_personality(PER_SVR4);              \
  81         else if (current->personality != PER_LINUX32)   \
  82                 set_personality(PER_LINUX);             \
  83         set_thread_flag(TIF_31BIT);                     \
  84 } while (0)
  85
  86 #include "compat_linux.h"
  87
  88 typedef _s390_fp_regs32 elf_fpregset_t;
  89
  90 typedef struct
  91 {
  92
  93         _psw_t32        psw;
  94         __u32           gprs[__NUM_GPRS];
  95         __u32           acrs[__NUM_ACRS];
  96         __u32           orig_gpr2;
  97 } s390_regs32;
  98 typedef s390_regs32 elf_gregset_t;
  99
 100 static inline int dump_regs32(struct pt_regs *ptregs, elf_gregset_t *regs)
 101 {
 102         int i;
 103
 104         memcpy(&regs->psw.mask, &ptregs->psw.mask, 4);
 105         memcpy(&regs->psw.addr, (char *)&ptregs->psw.addr + 4, 4);
 106         for (i = 0; i < NUM_GPRS; i++)
 107                 regs->gprs[i] = ptregs->gprs[i];
 108         save_access_regs(regs->acrs);
 109         regs->orig_gpr2 = ptregs->orig_gpr2;
 110         return 1;
 111 }
 112
 113 static inline int dump_task_regs32(struct task_struct *tsk, elf_gregset_t *regs)
 114 {
 115         struct pt_regs *ptregs = __KSTK_PTREGS(tsk);
 116         int i;
 117
 118         memcpy(&regs->psw.mask, &ptregs->psw.mask, 4);
 119         memcpy(&regs->psw.addr, (char *)&ptregs->psw.addr + 4, 4);
 120         for (i = 0; i < NUM_GPRS; i++)
 121                 regs->gprs[i] = ptregs->gprs[i];
 122         memcpy(regs->acrs, tsk->thread.acrs, sizeof(regs->acrs));
 123         regs->orig_gpr2 = ptregs->orig_gpr2;
 124         return 1;
 125 }
 126
 127 static inline int dump_task_fpu(struct task_struct *tsk, elf_fpregset_t *fpregs)
 128 {
 129         if (tsk == current)
 130                 save_fp_regs((s390_fp_regs *)fpregs);
 131         else
 132                 memcpy(fpregs, &tsk->thread.fp_regs, sizeof(elf_fpregset_t));
 133         return 1;
 134 }
 135
 136 #include <asm/processor.h>
 137 #include <linux/module.h>
 138 #include <linux/config.h>
 139 #include <linux/elfcore.h>
 140 #include <linux/binfmts.h>
 141 #include <linux/compat.h>
 142
 143 int setup_arg_pages32(struct linux_binprm *bprm, int executable_stack);
 144
 145 #define elf_prstatus elf_prstatus32
 146 struct elf_prstatus32
 147 {
 148         struct elf_siginfo pr_info;     /* Info associated with signal */
 149         short   pr_cursig;              /* Current signal */
 150         u32     pr_sigpend;     /* Set of pending signals */
 151         u32     pr_sighold;     /* Set of held signals */
 152         pid_t   pr_pid;
 153         pid_t   pr_ppid;
 154         pid_t   pr_pgrp;
 155         pid_t   pr_sid;
 156         struct compat_timeval pr_utime; /* User time */
 157         struct compat_timeval pr_stime; /* System time */
 158         struct compat_timeval pr_cutime;        /* Cumulative user time */
 159         struct compat_timeval pr_cstime;        /* Cumulative system time */
 160         elf_gregset_t pr_reg;   /* GP registers */
 161         int pr_fpvalid;         /* True if math co-processor being used.  */
 162 };
 163
 164 #define elf_prpsinfo elf_prpsinfo32
 165 struct elf_prpsinfo32
 166 {
 167         char    pr_state;       /* numeric process state */
 168         char    pr_sname;       /* char for pr_state */
 169         char    pr_zomb;        /* zombie */
 170         char    pr_nice;        /* nice val */
 171         u32     pr_flag;        /* flags */
 172         u16     pr_uid;
 173         u16     pr_gid;
 174         pid_t   pr_pid, pr_ppid, pr_pgrp, pr_sid;
 175         /* Lots missing */
 176         char    pr_fname[16];   /* filename of executable */
 177         char    pr_psargs[ELF_PRARGSZ]; /* initial part of arg list */
 178 };
 179
 180 #include <linux/highuid.h>
 181
 182 #undef NEW_TO_OLD_UID
 183 #undef NEW_TO_OLD_GID
 184 #define NEW_TO_OLD_UID(uid) ((uid) > 65535) ? (u16)overflowuid : (u16)(uid)
 185 #define NEW_TO_OLD_GID(gid) ((gid) > 65535) ? (u16)overflowgid : (u16)(gid)
 186
 187 #define elf_addr_t      u32
 188 /*
 189 #define init_elf_binfmt init_elf32_binfmt
 190 */
 191
 192 #undef start_thread
 193 #define start_thread                    start_thread31
 194 #define setup_arg_pages(bprm, exec)     setup_arg_pages32(bprm, exec)
 195
 196 MODULE_DESCRIPTION("Binary format loader for compatibility with 32bit Linux for S390 binaries,"
 197                    " Copyright 2000 IBM Corporation");
 198 MODULE_AUTHOR("Gerhard Tonn <ton@de.ibm.com>");
 199
 200 #undef MODULE_DESCRIPTION
 201 #undef MODULE_AUTHOR
 202
 203 #define jiffies_to_timeval jiffies_to_compat_timeval
 204 static __inline__ void
 205 jiffies_to_compat_timeval(unsigned long jiffies, struct compat_timeval *value)
 206 {
 207         value->tv_usec = (jiffies % HZ) * (1000000L / HZ);
 208         value->tv_sec = jiffies / HZ;
 209 }
 210
 211 #include "../../../fs/binfmt_elf.c"
 212