[PATCH] elf: Always define elf_addr_t in linux/elf.h
[linux-2.6.git] / 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 = task_pt_regs(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/elfcore.h>
139 #include <linux/binfmts.h>
140 #include <linux/compat.h>
141
142 #define elf_prstatus elf_prstatus32
143 struct elf_prstatus32
144 {
145         struct elf_siginfo pr_info;     /* Info associated with signal */
146         short   pr_cursig;              /* Current signal */
147         u32     pr_sigpend;     /* Set of pending signals */
148         u32     pr_sighold;     /* Set of held signals */
149         pid_t   pr_pid;
150         pid_t   pr_ppid;
151         pid_t   pr_pgrp;
152         pid_t   pr_sid;
153         struct compat_timeval pr_utime; /* User time */
154         struct compat_timeval pr_stime; /* System time */
155         struct compat_timeval pr_cutime;        /* Cumulative user time */
156         struct compat_timeval pr_cstime;        /* Cumulative system time */
157         elf_gregset_t pr_reg;   /* GP registers */
158         int pr_fpvalid;         /* True if math co-processor being used.  */
159 };
160
161 #define elf_prpsinfo elf_prpsinfo32
162 struct elf_prpsinfo32
163 {
164         char    pr_state;       /* numeric process state */
165         char    pr_sname;       /* char for pr_state */
166         char    pr_zomb;        /* zombie */
167         char    pr_nice;        /* nice val */
168         u32     pr_flag;        /* flags */
169         u16     pr_uid;
170         u16     pr_gid;
171         pid_t   pr_pid, pr_ppid, pr_pgrp, pr_sid;
172         /* Lots missing */
173         char    pr_fname[16];   /* filename of executable */
174         char    pr_psargs[ELF_PRARGSZ]; /* initial part of arg list */
175 };
176
177 #include <linux/highuid.h>
178
179 /*
180 #define init_elf_binfmt init_elf32_binfmt
181 */
182
183 #undef start_thread
184 #define start_thread                    start_thread31 
185
186 MODULE_DESCRIPTION("Binary format loader for compatibility with 32bit Linux for S390 binaries,"
187                    " Copyright 2000 IBM Corporation"); 
188 MODULE_AUTHOR("Gerhard Tonn <ton@de.ibm.com>");
189
190 #undef MODULE_DESCRIPTION
191 #undef MODULE_AUTHOR
192
193 #undef cputime_to_timeval
194 #define cputime_to_timeval cputime_to_compat_timeval
195 static __inline__ void
196 cputime_to_compat_timeval(const cputime_t cputime, struct compat_timeval *value)
197 {
198         value->tv_usec = cputime % 1000000;
199         value->tv_sec = cputime / 1000000;
200 }
201
202 #include "../../../fs/binfmt_elf.c"
203