PageRenderTime 73ms CodeModel.GetById 12ms app.highlight 55ms RepoModel.GetById 2ms app.codeStats 0ms

/arch/parisc/kernel/signal32.c

https://bitbucket.org/evzijst/gittest
C | 400 lines | 273 code | 71 blank | 56 comment | 29 complexity | 072b63d42eef3025321260a51eb5946b MD5 | raw file
  1/*    Signal support for 32-bit kernel builds
  2 *
  3 *    Copyright (C) 2001 Matthew Wilcox <willy at parisc-linux.org>
  4 *    Code was mostly borrowed from kernel/signal.c.
  5 *    See kernel/signal.c for additional Copyrights.
  6 *
  7 *
  8 *    This program is free software; you can redistribute it and/or modify
  9 *    it under the terms of the GNU General Public License as published by
 10 *    the Free Software Foundation; either version 2 of the License, or
 11 *    (at your option) any later version.
 12 *
 13 *    This program is distributed in the hope that it will be useful,
 14 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 15 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 16 *    GNU General Public License for more details.
 17 *
 18 *    You should have received a copy of the GNU General Public License
 19 *    along with this program; if not, write to the Free Software
 20 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 21 */
 22
 23#include <linux/compat.h>
 24#include <linux/slab.h>
 25#include <linux/module.h>
 26#include <linux/unistd.h>
 27#include <linux/smp_lock.h>
 28#include <linux/init.h>
 29#include <linux/sched.h>
 30#include <linux/syscalls.h>
 31#include <linux/types.h>
 32#include <linux/errno.h>
 33
 34#include <asm/compat_signal.h>
 35#include <asm/uaccess.h>
 36
 37#include "signal32.h"
 38#include "sys32.h"
 39
 40#define DEBUG_COMPAT_SIG 0 
 41#define DEBUG_COMPAT_SIG_LEVEL 2
 42
 43#if DEBUG_COMPAT_SIG
 44#define DBG(LEVEL, ...) \
 45	((DEBUG_COMPAT_SIG_LEVEL >= LEVEL) \
 46	? printk(__VA_ARGS__) : (void) 0)
 47#else
 48#define DBG(LEVEL, ...)
 49#endif
 50
 51#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
 52
 53inline void
 54sigset_32to64(sigset_t *s64, compat_sigset_t *s32)
 55{
 56	s64->sig[0] = s32->sig[0] | ((unsigned long)s32->sig[1] << 32);
 57}
 58
 59inline void
 60sigset_64to32(compat_sigset_t *s32, sigset_t *s64)
 61{
 62	s32->sig[0] = s64->sig[0] & 0xffffffffUL;
 63	s32->sig[1] = (s64->sig[0] >> 32) & 0xffffffffUL;
 64}
 65
 66static int
 67put_sigset32(compat_sigset_t __user *up, sigset_t *set, size_t sz)
 68{
 69	compat_sigset_t s;
 70
 71	if (sz != sizeof *set) panic("put_sigset32()");
 72	sigset_64to32(&s, set);
 73
 74	return copy_to_user(up, &s, sizeof s);
 75}
 76
 77static int
 78get_sigset32(compat_sigset_t __user *up, sigset_t *set, size_t sz)
 79{
 80	compat_sigset_t s;
 81	int r;
 82
 83	if (sz != sizeof *set) panic("put_sigset32()");
 84
 85	if ((r = copy_from_user(&s, up, sz)) == 0) {
 86		sigset_32to64(set, &s);
 87	}
 88
 89	return r;
 90}
 91
 92int sys32_rt_sigprocmask(int how, compat_sigset_t __user *set, compat_sigset_t __user *oset,
 93				    unsigned int sigsetsize)
 94{
 95	sigset_t old_set, new_set;
 96	int ret;
 97
 98	if (set && get_sigset32(set, &new_set, sigsetsize))
 99		return -EFAULT;
100	
101	KERNEL_SYSCALL(ret, sys_rt_sigprocmask, how, set ? (sigset_t __user *)&new_set : NULL,
102				 oset ? (sigset_t __user *)&old_set : NULL, sigsetsize);
103
104	if (!ret && oset && put_sigset32(oset, &old_set, sigsetsize))
105		return -EFAULT;
106
107	return ret;
108}
109
110
111int sys32_rt_sigpending(compat_sigset_t __user *uset, unsigned int sigsetsize)
112{
113	int ret;
114	sigset_t set;
115
116	KERNEL_SYSCALL(ret, sys_rt_sigpending, (sigset_t __user *)&set, sigsetsize);
117
118	if (!ret && put_sigset32(uset, &set, sigsetsize))
119		return -EFAULT;
120
121	return ret;
122}
123
124long
125sys32_rt_sigaction(int sig, const struct sigaction32 __user *act, struct sigaction32 __user *oact,
126                 size_t sigsetsize)
127{
128	struct k_sigaction32 new_sa32, old_sa32;
129	struct k_sigaction new_sa, old_sa;
130	int ret = -EINVAL;
131
132	if (act) {
133		if (copy_from_user(&new_sa32.sa, act, sizeof new_sa32.sa))
134			return -EFAULT;
135		new_sa.sa.sa_handler = (__sighandler_t)(unsigned long)new_sa32.sa.sa_handler;
136		new_sa.sa.sa_flags = new_sa32.sa.sa_flags;
137		sigset_32to64(&new_sa.sa.sa_mask, &new_sa32.sa.sa_mask);
138	}
139
140	ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
141
142	if (!ret && oact) {
143		sigset_64to32(&old_sa32.sa.sa_mask, &old_sa.sa.sa_mask);
144		old_sa32.sa.sa_flags = old_sa.sa.sa_flags;
145		old_sa32.sa.sa_handler = (__sighandler_t32)(unsigned long)old_sa.sa.sa_handler;
146		if (copy_to_user(oact, &old_sa32.sa, sizeof old_sa32.sa))
147			return -EFAULT;
148	}
149	return ret;
150}
151
152int 
153do_sigaltstack32 (const compat_stack_t __user *uss32, compat_stack_t __user *uoss32, unsigned long sp)
154{
155	compat_stack_t ss32, oss32;
156	stack_t ss, oss;
157	stack_t *ssp = NULL, *ossp = NULL;
158	int ret;
159
160	if (uss32) {
161		if (copy_from_user(&ss32, uss32, sizeof ss32))
162			return -EFAULT;
163
164		ss.ss_sp = (void __user *)(unsigned long)ss32.ss_sp;
165		ss.ss_flags = ss32.ss_flags;
166		ss.ss_size = ss32.ss_size;
167
168		ssp = &ss;
169	}
170
171	if (uoss32)
172		ossp = &oss;
173
174	KERNEL_SYSCALL(ret, do_sigaltstack, (const stack_t __user *)ssp, (stack_t __user *)ossp, sp);
175
176	if (!ret && uoss32) {
177		oss32.ss_sp = (unsigned int)(unsigned long)oss.ss_sp;
178		oss32.ss_flags = oss.ss_flags;
179		oss32.ss_size = oss.ss_size;
180		if (copy_to_user(uoss32, &oss32, sizeof *uoss32))
181			return -EFAULT;
182	}
183
184	return ret;
185}
186
187long
188restore_sigcontext32(struct compat_sigcontext __user *sc, struct compat_regfile __user * rf,
189		struct pt_regs *regs)
190{
191	long err = 0;
192	compat_uint_t compat_reg;
193	compat_uint_t compat_regt;
194	int regn;
195	
196	/* When loading 32-bit values into 64-bit registers make
197	   sure to clear the upper 32-bits */
198	DBG(2,"restore_sigcontext32: PER_LINUX32 process\n");
199	DBG(2,"restore_sigcontext32: sc = 0x%p, rf = 0x%p, regs = 0x%p\n", sc, rf, regs);
200	DBG(2,"restore_sigcontext32: compat_sigcontext is %#lx bytes\n", sizeof(*sc));
201	for(regn=0; regn < 32; regn++){
202		err |= __get_user(compat_reg,&sc->sc_gr[regn]);
203		regs->gr[regn] = compat_reg;
204		/* Load upper half */
205		err |= __get_user(compat_regt,&rf->rf_gr[regn]);
206		regs->gr[regn] = ((u64)compat_regt << 32) | (u64)compat_reg;
207		DBG(3,"restore_sigcontext32: gr%02d = %#lx (%#x / %#x)\n", 
208				regn, regs->gr[regn], compat_regt, compat_reg);
209	}
210	DBG(2,"restore_sigcontext32: sc->sc_fr = 0x%p (%#lx)\n",sc->sc_fr, sizeof(sc->sc_fr));
211	/* XXX: BE WARNED FR's are 64-BIT! */
212	err |= __copy_from_user(regs->fr, sc->sc_fr, sizeof(regs->fr));
213		
214	/* Better safe than sorry, pass __get_user two things of
215	   the same size and let gcc do the upward conversion to 
216	   64-bits */		
217	err |= __get_user(compat_reg, &sc->sc_iaoq[0]);
218	/* Load upper half */
219	err |= __get_user(compat_regt, &rf->rf_iaoq[0]);
220	regs->iaoq[0] = ((u64)compat_regt << 32) | (u64)compat_reg;
221	DBG(2,"restore_sigcontext32: upper half of iaoq[0] = %#lx\n", compat_regt);
222	DBG(2,"restore_sigcontext32: sc->sc_iaoq[0] = %p => %#x\n", 
223			&sc->sc_iaoq[0], compat_reg);
224
225	err |= __get_user(compat_reg, &sc->sc_iaoq[1]);
226	/* Load upper half */
227	err |= __get_user(compat_regt, &rf->rf_iaoq[1]);
228	regs->iaoq[1] = ((u64)compat_regt << 32) | (u64)compat_reg;
229	DBG(2,"restore_sigcontext32: upper half of iaoq[1] = %#lx\n", compat_regt);
230	DBG(2,"restore_sigcontext32: sc->sc_iaoq[1] = %p => %#x\n", 
231			&sc->sc_iaoq[1],compat_reg);	
232	DBG(2,"restore_sigcontext32: iaoq is %#lx / %#lx\n", 
233			regs->iaoq[0],regs->iaoq[1]);		
234		
235	err |= __get_user(compat_reg, &sc->sc_iasq[0]);
236	/* Load the upper half for iasq */
237	err |= __get_user(compat_regt, &rf->rf_iasq[0]);
238	regs->iasq[0] = ((u64)compat_regt << 32) | (u64)compat_reg;
239	DBG(2,"restore_sigcontext32: upper half of iasq[0] = %#lx\n", compat_regt);
240	
241	err |= __get_user(compat_reg, &sc->sc_iasq[1]);
242	/* Load the upper half for iasq */
243	err |= __get_user(compat_regt, &rf->rf_iasq[1]);
244	regs->iasq[1] = ((u64)compat_regt << 32) | (u64)compat_reg;
245	DBG(2,"restore_sigcontext32: upper half of iasq[1] = %#lx\n", compat_regt);
246	DBG(2,"restore_sigcontext32: iasq is %#lx / %#lx\n", 
247		regs->iasq[0],regs->iasq[1]);		
248
249	err |= __get_user(compat_reg, &sc->sc_sar);
250	/* Load the upper half for sar */
251	err |= __get_user(compat_regt, &rf->rf_sar);
252	regs->sar = ((u64)compat_regt << 32) | (u64)compat_reg;	
253	DBG(2,"restore_sigcontext32: upper_half & sar = %#lx\n", compat_regt);	
254	DBG(2,"restore_sigcontext32: sar is %#lx\n", regs->sar);		
255	DBG(2,"restore_sigcontext32: r28 is %ld\n", regs->gr[28]);
256	
257	return err;
258}
259
260/*
261 * Set up the sigcontext structure for this process.
262 * This is not an easy task if the kernel is 64-bit, it will require
263 * that we examine the process personality to determine if we need to
264 * truncate for a 32-bit userspace.
265 */
266long
267setup_sigcontext32(struct compat_sigcontext __user *sc, struct compat_regfile __user * rf, 
268		struct pt_regs *regs, int in_syscall)		 
269{
270	compat_int_t flags = 0;
271	long err = 0;
272	compat_uint_t compat_reg;
273	compat_uint_t compat_regb;
274	int regn;
275	
276	if (on_sig_stack((unsigned long) sc))
277		flags |= PARISC_SC_FLAG_ONSTACK;
278	
279	if (in_syscall) {
280		
281		DBG(1,"setup_sigcontext32: in_syscall\n");
282		
283		flags |= PARISC_SC_FLAG_IN_SYSCALL;
284		/* Truncate gr31 */
285		compat_reg = (compat_uint_t)(regs->gr[31]);
286		/* regs->iaoq is undefined in the syscall return path */
287		err |= __put_user(compat_reg, &sc->sc_iaoq[0]);
288		DBG(2,"setup_sigcontext32: sc->sc_iaoq[0] = %p <= %#x\n",
289				&sc->sc_iaoq[0], compat_reg);
290		
291		/* Store upper half */
292		compat_reg = (compat_uint_t)(regs->gr[32] >> 32);
293		err |= __put_user(compat_reg, &rf->rf_iaoq[0]);
294		DBG(2,"setup_sigcontext32: upper half iaoq[0] = %#x\n", compat_reg);
295		
296		
297		compat_reg = (compat_uint_t)(regs->gr[31]+4);
298		err |= __put_user(compat_reg, &sc->sc_iaoq[1]);
299		DBG(2,"setup_sigcontext32: sc->sc_iaoq[1] = %p <= %#x\n",
300				&sc->sc_iaoq[1], compat_reg);
301		/* Store upper half */
302		compat_reg = (compat_uint_t)((regs->gr[32]+4) >> 32);
303		err |= __put_user(compat_reg, &rf->rf_iaoq[1]);
304		DBG(2,"setup_sigcontext32: upper half iaoq[1] = %#x\n", compat_reg);
305		
306		/* Truncate sr3 */
307		compat_reg = (compat_uint_t)(regs->sr[3]);
308		err |= __put_user(compat_reg, &sc->sc_iasq[0]);
309		err |= __put_user(compat_reg, &sc->sc_iasq[1]);		
310		
311		/* Store upper half */
312		compat_reg = (compat_uint_t)(regs->sr[3] >> 32);
313		err |= __put_user(compat_reg, &rf->rf_iasq[0]);
314		err |= __put_user(compat_reg, &rf->rf_iasq[1]);		
315		
316		DBG(2,"setup_sigcontext32: upper half iasq[0] = %#x\n", compat_reg);
317		DBG(2,"setup_sigcontext32: upper half iasq[1] = %#x\n", compat_reg);		
318		DBG(1,"setup_sigcontext32: iaoq %#lx / %#lx\n",				
319			regs->gr[31], regs->gr[31]+4);
320		
321	} else {
322		
323		compat_reg = (compat_uint_t)(regs->iaoq[0]);
324		err |= __put_user(compat_reg, &sc->sc_iaoq[0]);
325		DBG(2,"setup_sigcontext32: sc->sc_iaoq[0] = %p <= %#x\n",
326				&sc->sc_iaoq[0], compat_reg);
327		/* Store upper half */
328		compat_reg = (compat_uint_t)(regs->iaoq[0] >> 32);
329		err |= __put_user(compat_reg, &rf->rf_iaoq[0]);	
330		DBG(2,"setup_sigcontext32: upper half iaoq[0] = %#x\n", compat_reg);
331		
332		compat_reg = (compat_uint_t)(regs->iaoq[1]);
333		err |= __put_user(compat_reg, &sc->sc_iaoq[1]);
334		DBG(2,"setup_sigcontext32: sc->sc_iaoq[1] = %p <= %#x\n",
335				&sc->sc_iaoq[1], compat_reg);
336		/* Store upper half */
337		compat_reg = (compat_uint_t)(regs->iaoq[1] >> 32);
338		err |= __put_user(compat_reg, &rf->rf_iaoq[1]);
339		DBG(2,"setup_sigcontext32: upper half iaoq[1] = %#x\n", compat_reg);
340		
341		
342		compat_reg = (compat_uint_t)(regs->iasq[0]);
343		err |= __put_user(compat_reg, &sc->sc_iasq[0]);
344		DBG(2,"setup_sigcontext32: sc->sc_iasq[0] = %p <= %#x\n",
345				&sc->sc_iasq[0], compat_reg);
346		/* Store upper half */
347		compat_reg = (compat_uint_t)(regs->iasq[0] >> 32);
348		err |= __put_user(compat_reg, &rf->rf_iasq[0]);
349		DBG(2,"setup_sigcontext32: upper half iasq[0] = %#x\n", compat_reg);
350		
351		
352		compat_reg = (compat_uint_t)(regs->iasq[1]);
353		err |= __put_user(compat_reg, &sc->sc_iasq[1]);
354		DBG(2,"setup_sigcontext32: sc->sc_iasq[1] = %p <= %#x\n",
355				&sc->sc_iasq[1], compat_reg);
356		/* Store upper half */
357		compat_reg = (compat_uint_t)(regs->iasq[1] >> 32);
358		err |= __put_user(compat_reg, &rf->rf_iasq[1]);
359		DBG(2,"setup_sigcontext32: upper half iasq[1] = %#x\n", compat_reg);
360
361		/* Print out the IAOQ for debugging */		
362		DBG(1,"setup_sigcontext32: ia0q %#lx / %#lx\n", 
363			regs->iaoq[0], regs->iaoq[1]);
364	}
365
366	err |= __put_user(flags, &sc->sc_flags);
367	
368	DBG(1,"setup_sigcontext32: Truncating general registers.\n");
369	
370	for(regn=0; regn < 32; regn++){
371		/* Truncate a general register */
372		compat_reg = (compat_uint_t)(regs->gr[regn]);
373		err |= __put_user(compat_reg, &sc->sc_gr[regn]);
374		/* Store upper half */
375		compat_regb = (compat_uint_t)(regs->gr[regn] >> 32);
376		err |= __put_user(compat_regb, &rf->rf_gr[regn]);
377
378		/* DEBUG: Write out the "upper / lower" register data */
379		DBG(2,"setup_sigcontext32: gr%02d = %#x / %#x\n", regn, 
380				compat_regb, compat_reg);
381	}
382	
383	/* Copy the floating point registers (same size)
384	   XXX: BE WARNED FR's are 64-BIT! */	
385	DBG(1,"setup_sigcontext32: Copying from regs to sc, "
386	      "sc->sc_fr size = %#lx, regs->fr size = %#lx\n",
387		sizeof(regs->fr), sizeof(sc->sc_fr));
388	err |= __copy_to_user(sc->sc_fr, regs->fr, sizeof(regs->fr));
389
390	compat_reg = (compat_uint_t)(regs->sar);
391	err |= __put_user(compat_reg, &sc->sc_sar);
392	DBG(2,"setup_sigcontext32: sar is %#x\n", compat_reg);
393	/* Store upper half */
394	compat_reg = (compat_uint_t)(regs->sar >> 32);
395	err |= __put_user(compat_reg, &rf->rf_sar);	
396	DBG(2,"setup_sigcontext32: upper half sar = %#x\n", compat_reg);
397	DBG(1,"setup_sigcontext32: r28 is %ld\n", regs->gr[28]);
398
399	return err;
400}