?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
initial commit with v2.6.9
[linux-2.6.9-moxart.git] / arch / ia64 / ia32 / ia32_signal.c
blob7f2fc27045e9af296af5cde259ed41fcae615193
1 /*
2 * IA32 Architecture-specific signal handling support.
3 *
4 * Copyright (C) 1999, 2001-2002 Hewlett-Packard Co
5 * David Mosberger-Tang <davidm@hpl.hp.com>
6 * Copyright (C) 1999 Arun Sharma <arun.sharma@intel.com>
7 * Copyright (C) 2000 VA Linux Co
8 * Copyright (C) 2000 Don Dugger <n0ano@valinux.com>
9 *
10 * Derived from i386 and Alpha versions.
11 */
12
13 #include <linux/errno.h>
14 #include <linux/kernel.h>
15 #include <linux/mm.h>
16 #include <linux/personality.h>
17 #include <linux/ptrace.h>
18 #include <linux/sched.h>
19 #include <linux/signal.h>
20 #include <linux/smp.h>
21 #include <linux/smp_lock.h>
22 #include <linux/stddef.h>
23 #include <linux/syscalls.h>
24 #include <linux/unistd.h>
25 #include <linux/wait.h>
26 #include <linux/compat.h>
27
28 #include <asm/intrinsics.h>
29 #include <asm/uaccess.h>
30 #include <asm/rse.h>
31 #include <asm/sigcontext.h>
32 #include <asm/segment.h>
33
34 #include "ia32priv.h"
35
36 #include "../kernel/sigframe.h"
37
38 #define A(__x) ((unsigned long)(__x))
39
40 #define DEBUG_SIG 0
41 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
42
43 #define __IA32_NR_sigreturn 119
44 #define __IA32_NR_rt_sigreturn 173
45
46 struct sigframe_ia32
47 {
48 int pretcode;
49 int sig;
50 struct sigcontext_ia32 sc;
51 struct _fpstate_ia32 fpstate;
52 unsigned int extramask[_COMPAT_NSIG_WORDS-1];
53 char retcode[8];
54 };
55
56 struct rt_sigframe_ia32
57 {
58 int pretcode;
59 int sig;
60 int pinfo;
61 int puc;
62 siginfo_t32 info;
63 struct ucontext_ia32 uc;
64 struct _fpstate_ia32 fpstate;
65 char retcode[8];
66 };
67
68 int
69 copy_siginfo_from_user32 (siginfo_t *to, siginfo_t32 __user *from)
70 {
71 unsigned long tmp;
72 int err;
73
74 if (!access_ok(VERIFY_READ, from, sizeof(siginfo_t32)))
75 return -EFAULT;
76
77 err = __get_user(to->si_signo, &from->si_signo);
78 err |= __get_user(to->si_errno, &from->si_errno);
79 err |= __get_user(to->si_code, &from->si_code);
80
81 if (to->si_code < 0)
82 err |= __copy_from_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
83 else {
84 switch (to->si_code >> 16) {
85 case __SI_CHLD >> 16:
86 err |= __get_user(to->si_utime, &from->si_utime);
87 err |= __get_user(to->si_stime, &from->si_stime);
88 err |= __get_user(to->si_status, &from->si_status);
89 default:
90 err |= __get_user(to->si_pid, &from->si_pid);
91 err |= __get_user(to->si_uid, &from->si_uid);
92 break;
93 case __SI_FAULT >> 16:
94 err |= __get_user(tmp, &from->si_addr);
95 to->si_addr = (void __user *) tmp;
96 break;
97 case __SI_POLL >> 16:
98 err |= __get_user(to->si_band, &from->si_band);
99 err |= __get_user(to->si_fd, &from->si_fd);
100 break;
101 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
102 case __SI_MESGQ >> 16:
103 err |= __get_user(to->si_pid, &from->si_pid);
104 err |= __get_user(to->si_uid, &from->si_uid);
105 err |= __get_user(to->si_int, &from->si_int);
106 break;
107 }
108 }
109 return err;
110 }
111
112 int
113 copy_siginfo_to_user32 (siginfo_t32 __user *to, siginfo_t *from)
114 {
115 unsigned int addr;
116 int err;
117
118 if (!access_ok(VERIFY_WRITE, to, sizeof(siginfo_t32)))
119 return -EFAULT;
120
121 /* If you change siginfo_t structure, please be sure
122 this code is fixed accordingly.
123 It should never copy any pad contained in the structure
124 to avoid security leaks, but must copy the generic
125 3 ints plus the relevant union member.
126 This routine must convert siginfo from 64bit to 32bit as well
127 at the same time. */
128 err = __put_user(from->si_signo, &to->si_signo);
129 err |= __put_user(from->si_errno, &to->si_errno);
130 err |= __put_user((short)from->si_code, &to->si_code);
131 if (from->si_code < 0)
132 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
133 else {
134 switch (from->si_code >> 16) {
135 case __SI_CHLD >> 16:
136 err |= __put_user(from->si_utime, &to->si_utime);
137 err |= __put_user(from->si_stime, &to->si_stime);
138 err |= __put_user(from->si_status, &to->si_status);
139 default:
140 err |= __put_user(from->si_pid, &to->si_pid);
141 err |= __put_user(from->si_uid, &to->si_uid);
142 break;
143 case __SI_FAULT >> 16:
144 /* avoid type-checking warnings by copying _pad[0] in lieu of si_addr... */
145 err |= __put_user(from->_sifields._pad[0], &to->si_addr);
146 break;
147 case __SI_POLL >> 16:
148 err |= __put_user(from->si_band, &to->si_band);
149 err |= __put_user(from->si_fd, &to->si_fd);
150 break;
151 case __SI_TIMER >> 16:
152 err |= __put_user(from->si_tid, &to->si_tid);
153 err |= __put_user(from->si_overrun, &to->si_overrun);
154 addr = (unsigned long) from->si_ptr;
155 err |= __put_user(addr, &to->si_ptr);
156 break;
157 case __SI_RT >> 16: /* Not generated by the kernel as of now. */
158 case __SI_MESGQ >> 16:
159 err |= __put_user(from->si_uid, &to->si_uid);
160 err |= __put_user(from->si_pid, &to->si_pid);
161 addr = (unsigned long) from->si_ptr;
162 err |= __put_user(addr, &to->si_ptr);
163 break;
164 }
165 }
166 return err;
167 }
168
169
170 /*
171 * SAVE and RESTORE of ia32 fpstate info, from ia64 current state
172 * Used in exception handler to pass the fpstate to the user, and restore
173 * the fpstate while returning from the exception handler.
174 *
175 * fpstate info and their mapping to IA64 regs:
176 * fpstate REG(BITS) Attribute Comments
177 * cw ar.fcr(0:12) with bits 7 and 6 not used
178 * sw ar.fsr(0:15)
179 * tag ar.fsr(16:31) with odd numbered bits not used
180 * (read returns 0, writes ignored)
181 * ipoff ar.fir(0:31)
182 * cssel ar.fir(32:47)
183 * dataoff ar.fdr(0:31)
184 * datasel ar.fdr(32:47)
185 *
186 * _st[(0+TOS)%8] f8
187 * _st[(1+TOS)%8] f9
188 * _st[(2+TOS)%8] f10
189 * _st[(3+TOS)%8] f11 (f8..f11 from ptregs)
190 * : : : (f12..f15 from live reg)
191 * : : :
192 * _st[(7+TOS)%8] f15 TOS=sw.top(bits11:13)
193 *
194 * status Same as sw RO
195 * magic 0 as X86_FXSR_MAGIC in ia32
196 * mxcsr Bits(7:15)=ar.fcr(39:47)
197 * Bits(0:5) =ar.fsr(32:37) with bit 6 reserved
198 * _xmm[0..7] f16..f31 (live registers)
199 * with _xmm[0]
200 * Bit(64:127)=f17(0:63)
201 * Bit(0:63)=f16(0:63)
202 * All other fields unused...
203 */
204
205 static int
206 save_ia32_fpstate_live (struct _fpstate_ia32 __user *save)
207 {
208 struct task_struct *tsk = current;
209 struct pt_regs *ptp;
210 struct _fpreg_ia32 *fpregp;
211 char buf[32];
212 unsigned long fsr, fcr, fir, fdr;
213 unsigned long new_fsr;
214 unsigned long num128[2];
215 unsigned long mxcsr=0;
216 int fp_tos, fr8_st_map;
217
218 if (!access_ok(VERIFY_WRITE, save, sizeof(*save)))
219 return -EFAULT;
220
221 /* Read in fsr, fcr, fir, fdr and copy onto fpstate */
222 fsr = ia64_getreg(_IA64_REG_AR_FSR);
223 fcr = ia64_getreg(_IA64_REG_AR_FCR);
224 fir = ia64_getreg(_IA64_REG_AR_FIR);
225 fdr = ia64_getreg(_IA64_REG_AR_FDR);
226
227 /*
228 * We need to clear the exception state before calling the signal handler. Clear
229 * the bits 15, bits 0-7 in fp status word. Similar to the functionality of fnclex
230 * instruction.
231 */
232 new_fsr = fsr & ~0x80ff;
233 ia64_setreg(_IA64_REG_AR_FSR, new_fsr);
234
235 __put_user(fcr & 0xffff, &save->cw);
236 __put_user(fsr & 0xffff, &save->sw);
237 __put_user((fsr>>16) & 0xffff, &save->tag);
238 __put_user(fir, &save->ipoff);
239 __put_user((fir>>32) & 0xffff, &save->cssel);
240 __put_user(fdr, &save->dataoff);
241 __put_user((fdr>>32) & 0xffff, &save->datasel);
242 __put_user(fsr & 0xffff, &save->status);
243
244 mxcsr = ((fcr>>32) & 0xff80) | ((fsr>>32) & 0x3f);
245 __put_user(mxcsr & 0xffff, &save->mxcsr);
246 __put_user( 0, &save->magic); //#define X86_FXSR_MAGIC 0x0000
247
248 /*
249 * save f8..f11 from pt_regs
250 * save f12..f15 from live register set
251 */
252 /*
253 * Find the location where f8 has to go in fp reg stack. This depends on
254 * TOP(11:13) field of sw. Other f reg continue sequentially from where f8 maps
255 * to.
256 */
257 fp_tos = (fsr>>11)&0x7;
258 fr8_st_map = (8-fp_tos)&0x7;
259 ptp = ia64_task_regs(tsk);
260 fpregp = (struct _fpreg_ia32 *)(((unsigned long)buf + 15) & ~15);
261 ia64f2ia32f(fpregp, &ptp->f8);
262 copy_to_user(&save->_st[(0+fr8_st_map)&0x7], fpregp, sizeof(struct _fpreg_ia32));
263 ia64f2ia32f(fpregp, &ptp->f9);
264 copy_to_user(&save->_st[(1+fr8_st_map)&0x7], fpregp, sizeof(struct _fpreg_ia32));
265 ia64f2ia32f(fpregp, &ptp->f10);
266 copy_to_user(&save->_st[(2+fr8_st_map)&0x7], fpregp, sizeof(struct _fpreg_ia32));
267 ia64f2ia32f(fpregp, &ptp->f11);
268 copy_to_user(&save->_st[(3+fr8_st_map)&0x7], fpregp, sizeof(struct _fpreg_ia32));
269
270 ia64_stfe(fpregp, 12);
271 copy_to_user(&save->_st[(4+fr8_st_map)&0x7], fpregp, sizeof(struct _fpreg_ia32));
272 ia64_stfe(fpregp, 13);
273 copy_to_user(&save->_st[(5+fr8_st_map)&0x7], fpregp, sizeof(struct _fpreg_ia32));
274 ia64_stfe(fpregp, 14);
275 copy_to_user(&save->_st[(6+fr8_st_map)&0x7], fpregp, sizeof(struct _fpreg_ia32));
276 ia64_stfe(fpregp, 15);
277 copy_to_user(&save->_st[(7+fr8_st_map)&0x7], fpregp, sizeof(struct _fpreg_ia32));
278
279 ia64_stf8(&num128[0], 16);
280 ia64_stf8(&num128[1], 17);
281 copy_to_user(&save->_xmm[0], num128, sizeof(struct _xmmreg_ia32));
282
283 ia64_stf8(&num128[0], 18);
284 ia64_stf8(&num128[1], 19);
285 copy_to_user(&save->_xmm[1], num128, sizeof(struct _xmmreg_ia32));
286
287 ia64_stf8(&num128[0], 20);
288 ia64_stf8(&num128[1], 21);
289 copy_to_user(&save->_xmm[2], num128, sizeof(struct _xmmreg_ia32));
290
291 ia64_stf8(&num128[0], 22);
292 ia64_stf8(&num128[1], 23);
293 copy_to_user(&save->_xmm[3], num128, sizeof(struct _xmmreg_ia32));
294
295 ia64_stf8(&num128[0], 24);
296 ia64_stf8(&num128[1], 25);
297 copy_to_user(&save->_xmm[4], num128, sizeof(struct _xmmreg_ia32));
298
299 ia64_stf8(&num128[0], 26);
300 ia64_stf8(&num128[1], 27);
301 copy_to_user(&save->_xmm[5], num128, sizeof(struct _xmmreg_ia32));
302
303 ia64_stf8(&num128[0], 28);
304 ia64_stf8(&num128[1], 29);
305 copy_to_user(&save->_xmm[6], num128, sizeof(struct _xmmreg_ia32));
306
307 ia64_stf8(&num128[0], 30);
308 ia64_stf8(&num128[1], 31);
309 copy_to_user(&save->_xmm[7], num128, sizeof(struct _xmmreg_ia32));
310 return 0;
311 }
312
313 static int
314 restore_ia32_fpstate_live (struct _fpstate_ia32 __user *save)
315 {
316 struct task_struct *tsk = current;
317 struct pt_regs *ptp;
318 unsigned int lo, hi;
319 unsigned long num128[2];
320 unsigned long num64, mxcsr;
321 struct _fpreg_ia32 *fpregp;
322 char buf[32];
323 unsigned long fsr, fcr, fir, fdr;
324 int fp_tos, fr8_st_map;
325
326 if (!access_ok(VERIFY_READ, save, sizeof(*save)))
327 return(-EFAULT);
328
329 /*
330 * Updating fsr, fcr, fir, fdr.
331 * Just a bit more complicated than save.
332 * - Need to make sure that we don't write any value other than the
333 * specific fpstate info
334 * - Need to make sure that the untouched part of frs, fdr, fir, fcr
335 * should remain same while writing.
336 * So, we do a read, change specific fields and write.
337 */
338 fsr = ia64_getreg(_IA64_REG_AR_FSR);
339 fcr = ia64_getreg(_IA64_REG_AR_FCR);
340 fir = ia64_getreg(_IA64_REG_AR_FIR);
341 fdr = ia64_getreg(_IA64_REG_AR_FDR);
342
343 __get_user(mxcsr, (unsigned int __user *)&save->mxcsr);
344 /* setting bits 0..5 8..12 with cw and 39..47 from mxcsr */
345 __get_user(lo, (unsigned int __user *)&save->cw);
346 num64 = mxcsr & 0xff10;
347 num64 = (num64 << 32) | (lo & 0x1f3f);
348 fcr = (fcr & (~0xff1000001f3fUL)) | num64;
349
350 /* setting bits 0..31 with sw and tag and 32..37 from mxcsr */
351 __get_user(lo, (unsigned int __user *)&save->sw);
352 /* set bits 15,7 (fsw.b, fsw.es) to reflect the current error status */
353 if ( !(lo & 0x7f) )
354 lo &= (~0x8080);
355 __get_user(hi, (unsigned int __user *)&save->tag);
356 num64 = mxcsr & 0x3f;
357 num64 = (num64 << 16) | (hi & 0xffff);
358 num64 = (num64 << 16) | (lo & 0xffff);
359 fsr = (fsr & (~0x3fffffffffUL)) | num64;
360
361 /* setting bits 0..47 with cssel and ipoff */
362 __get_user(lo, (unsigned int __user *)&save->ipoff);
363 __get_user(hi, (unsigned int __user *)&save->cssel);
364 num64 = hi & 0xffff;
365 num64 = (num64 << 32) | lo;
366 fir = (fir & (~0xffffffffffffUL)) | num64;
367
368 /* setting bits 0..47 with datasel and dataoff */
369 __get_user(lo, (unsigned int __user *)&save->dataoff);
370 __get_user(hi, (unsigned int __user *)&save->datasel);
371 num64 = hi & 0xffff;
372 num64 = (num64 << 32) | lo;
373 fdr = (fdr & (~0xffffffffffffUL)) | num64;
374
375 ia64_setreg(_IA64_REG_AR_FSR, fsr);
376 ia64_setreg(_IA64_REG_AR_FCR, fcr);
377 ia64_setreg(_IA64_REG_AR_FIR, fir);
378 ia64_setreg(_IA64_REG_AR_FDR, fdr);
379
380 /*
381 * restore f8..f11 onto pt_regs
382 * restore f12..f15 onto live registers
383 */
384 /*
385 * Find the location where f8 has to go in fp reg stack. This depends on
386 * TOP(11:13) field of sw. Other f reg continue sequentially from where f8 maps
387 * to.
388 */
389 fp_tos = (fsr>>11)&0x7;
390 fr8_st_map = (8-fp_tos)&0x7;
391 fpregp = (struct _fpreg_ia32 *)(((unsigned long)buf + 15) & ~15);
392
393 ptp = ia64_task_regs(tsk);
394 copy_from_user(fpregp, &save->_st[(0+fr8_st_map)&0x7], sizeof(struct _fpreg_ia32));
395 ia32f2ia64f(&ptp->f8, fpregp);
396 copy_from_user(fpregp, &save->_st[(1+fr8_st_map)&0x7], sizeof(struct _fpreg_ia32));
397 ia32f2ia64f(&ptp->f9, fpregp);
398 copy_from_user(fpregp, &save->_st[(2+fr8_st_map)&0x7], sizeof(struct _fpreg_ia32));
399 ia32f2ia64f(&ptp->f10, fpregp);
400 copy_from_user(fpregp, &save->_st[(3+fr8_st_map)&0x7], sizeof(struct _fpreg_ia32));
401 ia32f2ia64f(&ptp->f11, fpregp);
402
403 copy_from_user(fpregp, &save->_st[(4+fr8_st_map)&0x7], sizeof(struct _fpreg_ia32));
404 ia64_ldfe(12, fpregp);
405 copy_from_user(fpregp, &save->_st[(5+fr8_st_map)&0x7], sizeof(struct _fpreg_ia32));
406 ia64_ldfe(13, fpregp);
407 copy_from_user(fpregp, &save->_st[(6+fr8_st_map)&0x7], sizeof(struct _fpreg_ia32));
408 ia64_ldfe(14, fpregp);
409 copy_from_user(fpregp, &save->_st[(7+fr8_st_map)&0x7], sizeof(struct _fpreg_ia32));
410 ia64_ldfe(15, fpregp);
411
412 copy_from_user(num128, &save->_xmm[0], sizeof(struct _xmmreg_ia32));
413 ia64_ldf8(16, &num128[0]);
414 ia64_ldf8(17, &num128[1]);
415
416 copy_from_user(num128, &save->_xmm[1], sizeof(struct _xmmreg_ia32));
417 ia64_ldf8(18, &num128[0]);
418 ia64_ldf8(19, &num128[1]);
419
420 copy_from_user(num128, &save->_xmm[2], sizeof(struct _xmmreg_ia32));
421 ia64_ldf8(20, &num128[0]);
422 ia64_ldf8(21, &num128[1]);
423
424 copy_from_user(num128, &save->_xmm[3], sizeof(struct _xmmreg_ia32));
425 ia64_ldf8(22, &num128[0]);
426 ia64_ldf8(23, &num128[1]);
427
428 copy_from_user(num128, &save->_xmm[4], sizeof(struct _xmmreg_ia32));
429 ia64_ldf8(24, &num128[0]);
430 ia64_ldf8(25, &num128[1]);
431
432 copy_from_user(num128, &save->_xmm[5], sizeof(struct _xmmreg_ia32));
433 ia64_ldf8(26, &num128[0]);
434 ia64_ldf8(27, &num128[1]);
435
436 copy_from_user(num128, &save->_xmm[6], sizeof(struct _xmmreg_ia32));
437 ia64_ldf8(28, &num128[0]);
438 ia64_ldf8(29, &num128[1]);
439
440 copy_from_user(num128, &save->_xmm[7], sizeof(struct _xmmreg_ia32));
441 ia64_ldf8(30, &num128[0]);
442 ia64_ldf8(31, &num128[1]);
443 return 0;
444 }
445
446 static inline void
447 sigact_set_handler (struct k_sigaction *sa, unsigned int handler, unsigned int restorer)
448 {
449 if (handler + 1 <= 2)
450 /* SIG_DFL, SIG_IGN, or SIG_ERR: must sign-extend to 64-bits */
451 sa->sa.sa_handler = (__sighandler_t) A((int) handler);
452 else
453 sa->sa.sa_handler = (__sighandler_t) (((unsigned long) restorer << 32) | handler);
454 }
455
456 long
457 __ia32_rt_sigsuspend (compat_sigset_t *sset, unsigned int sigsetsize, struct sigscratch *scr)
458 {
459 extern long ia64_do_signal (sigset_t *oldset, struct sigscratch *scr, long in_syscall);
460 sigset_t oldset, set;
461
462 scr->scratch_unat = 0; /* avoid leaking kernel bits to user level */
463 memset(&set, 0, sizeof(&set));
464
465 if (memcpy(&set.sig, &sset->sig, sigsetsize))
466 return -EFAULT;
467
468 sigdelsetmask(&set, ~_BLOCKABLE);
469
470 spin_lock_irq(&current->sighand->siglock);
471 {
472 oldset = current->blocked;
473 current->blocked = set;
474 recalc_sigpending();
475 }
476 spin_unlock_irq(&current->sighand->siglock);
477
478 /*
479 * The return below usually returns to the signal handler. We need to pre-set the
480 * correct error code here to ensure that the right values get saved in sigcontext
481 * by ia64_do_signal.
482 */
483 scr->pt.r8 = -EINTR;
484 while (1) {
485 current->state = TASK_INTERRUPTIBLE;
486 schedule();
487 if (ia64_do_signal(&oldset, scr, 1))
488 return -EINTR;
489 }
490 }
491
492 asmlinkage long
493 ia32_rt_sigsuspend (compat_sigset_t __user *uset, unsigned int sigsetsize, struct sigscratch *scr)
494 {
495 compat_sigset_t set;
496
497 if (sigsetsize > sizeof(compat_sigset_t))
498 return -EINVAL;
499
500 if (copy_from_user(&set.sig, &uset->sig, sigsetsize))
501 return -EFAULT;
502
503 return __ia32_rt_sigsuspend(&set, sigsetsize, scr);
504 }
505
506 asmlinkage long
507 ia32_sigsuspend (unsigned int mask, struct sigscratch *scr)
508 {
509 return __ia32_rt_sigsuspend((compat_sigset_t *) &mask, sizeof(mask), scr);
510 }
511
512 asmlinkage long
513 sys32_signal (int sig, unsigned int handler)
514 {
515 struct k_sigaction new_sa, old_sa;
516 int ret;
517
518 sigact_set_handler(&new_sa, handler, 0);
519 new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
520
521 ret = do_sigaction(sig, &new_sa, &old_sa);
522
523 return ret ? ret : IA32_SA_HANDLER(&old_sa);
524 }
525
526 asmlinkage long
527 sys32_rt_sigaction (int sig, struct sigaction32 __user *act,
528 struct sigaction32 __user *oact, unsigned int sigsetsize)
529 {
530 struct k_sigaction new_ka, old_ka;
531 unsigned int handler, restorer;
532 int ret;
533
534 /* XXX: Don't preclude handling different sized sigset_t's. */
535 if (sigsetsize != sizeof(compat_sigset_t))
536 return -EINVAL;
537
538 if (act) {
539 ret = get_user(handler, &act->sa_handler);
540 ret |= get_user(new_ka.sa.sa_flags, &act->sa_flags);
541 ret |= get_user(restorer, &act->sa_restorer);
542 ret |= copy_from_user(&new_ka.sa.sa_mask, &act->sa_mask, sizeof(compat_sigset_t));
543 if (ret)
544 return -EFAULT;
545
546 sigact_set_handler(&new_ka, handler, restorer);
547 }
548
549 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
550
551 if (!ret && oact) {
552 ret = put_user(IA32_SA_HANDLER(&old_ka), &oact->sa_handler);
553 ret |= put_user(old_ka.sa.sa_flags, &oact->sa_flags);
554 ret |= put_user(IA32_SA_RESTORER(&old_ka), &oact->sa_restorer);
555 ret |= copy_to_user(&oact->sa_mask, &old_ka.sa.sa_mask, sizeof(compat_sigset_t));
556 }
557 return ret;
558 }
559
560
561 asmlinkage long
562 sys32_rt_sigprocmask (int how, compat_sigset_t __user *set, compat_sigset_t __user *oset,
563 unsigned int sigsetsize)
564 {
565 mm_segment_t old_fs = get_fs();
566 sigset_t s;
567 long ret;
568
569 if (sigsetsize > sizeof(s))
570 return -EINVAL;
571
572 if (set) {
573 memset(&s, 0, sizeof(s));
574 if (copy_from_user(&s.sig, set, sigsetsize))
575 return -EFAULT;
576 }
577 set_fs(KERNEL_DS);
578 ret = sys_rt_sigprocmask(how,
579 set ? (sigset_t __user *) &s : NULL,
580 oset ? (sigset_t __user *) &s : NULL, sizeof(s));
581 set_fs(old_fs);
582 if (ret)
583 return ret;
584 if (oset) {
585 if (copy_to_user(oset, &s.sig, sigsetsize))
586 return -EFAULT;
587 }
588 return 0;
589 }
590
591 asmlinkage long
592 sys32_rt_sigtimedwait (compat_sigset_t __user *uthese, siginfo_t32 __user *uinfo,
593 struct compat_timespec __user *uts, unsigned int sigsetsize)
594 {
595 mm_segment_t old_fs = get_fs();
596 struct timespec t;
597 siginfo_t info;
598 sigset_t s;
599 int ret;
600
601 if (copy_from_user(&s.sig, uthese, sizeof(compat_sigset_t)))
602 return -EFAULT;
603 if (uts && get_compat_timespec(&t, uts))
604 return -EFAULT;
605 set_fs(KERNEL_DS);
606 ret = sys_rt_sigtimedwait((sigset_t __user *) &s,
607 uinfo ? (siginfo_t __user *) &info : NULL,
608 uts ? (struct timespec __user *) &t : NULL,
609 sigsetsize);
610 set_fs(old_fs);
611 if (ret >= 0 && uinfo) {
612 if (copy_siginfo_to_user32(uinfo, &info))
613 return -EFAULT;
614 }
615 return ret;
616 }
617
618 asmlinkage long
619 sys32_rt_sigqueueinfo (int pid, int sig, siginfo_t32 __user *uinfo)
620 {
621 mm_segment_t old_fs = get_fs();
622 siginfo_t info;
623 int ret;
624
625 if (copy_siginfo_from_user32(&info, uinfo))
626 return -EFAULT;
627 set_fs(KERNEL_DS);
628 ret = sys_rt_sigqueueinfo(pid, sig, (siginfo_t __user *) &info);
629 set_fs(old_fs);
630 return ret;
631 }
632
633 asmlinkage long
634 sys32_sigaction (int sig, struct old_sigaction32 __user *act, struct old_sigaction32 __user *oact)
635 {
636 struct k_sigaction new_ka, old_ka;
637 unsigned int handler, restorer;
638 int ret;
639
640 if (act) {
641 compat_old_sigset_t mask;
642
643 ret = get_user(handler, &act->sa_handler);
644 ret |= get_user(new_ka.sa.sa_flags, &act->sa_flags);
645 ret |= get_user(restorer, &act->sa_restorer);
646 ret |= get_user(mask, &act->sa_mask);
647 if (ret)
648 return ret;
649
650 sigact_set_handler(&new_ka, handler, restorer);
651 siginitset(&new_ka.sa.sa_mask, mask);
652 }
653
654 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
655
656 if (!ret && oact) {
657 ret = put_user(IA32_SA_HANDLER(&old_ka), &oact->sa_handler);
658 ret |= put_user(old_ka.sa.sa_flags, &oact->sa_flags);
659 ret |= put_user(IA32_SA_RESTORER(&old_ka), &oact->sa_restorer);
660 ret |= put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
661 }
662
663 return ret;
664 }
665
666 static int
667 setup_sigcontext_ia32 (struct sigcontext_ia32 __user *sc, struct _fpstate_ia32 __user *fpstate,
668 struct pt_regs *regs, unsigned long mask)
669 {
670 int err = 0;
671 unsigned long flag;
672
673 if (!access_ok(VERIFY_WRITE, sc, sizeof(*sc)))
674 return -EFAULT;
675
676 err |= __put_user((regs->r16 >> 32) & 0xffff, (unsigned int __user *)&sc->fs);
677 err |= __put_user((regs->r16 >> 48) & 0xffff, (unsigned int __user *)&sc->gs);
678 err |= __put_user((regs->r16 >> 16) & 0xffff, (unsigned int __user *)&sc->es);
679 err |= __put_user(regs->r16 & 0xffff, (unsigned int __user *)&sc->ds);
680 err |= __put_user(regs->r15, &sc->edi);
681 err |= __put_user(regs->r14, &sc->esi);
682 err |= __put_user(regs->r13, &sc->ebp);
683 err |= __put_user(regs->r12, &sc->esp);
684 err |= __put_user(regs->r11, &sc->ebx);
685 err |= __put_user(regs->r10, &sc->edx);
686 err |= __put_user(regs->r9, &sc->ecx);
687 err |= __put_user(regs->r8, &sc->eax);
688 #if 0
689 err |= __put_user(current->tss.trap_no, &sc->trapno);
690 err |= __put_user(current->tss.error_code, &sc->err);
691 #endif
692 err |= __put_user(regs->cr_iip, &sc->eip);
693 err |= __put_user(regs->r17 & 0xffff, (unsigned int __user *)&sc->cs);
694 /*
695 * `eflags' is in an ar register for this context
696 */
697 flag = ia64_getreg(_IA64_REG_AR_EFLAG);
698 err |= __put_user((unsigned int)flag, &sc->eflags);
699 err |= __put_user(regs->r12, &sc->esp_at_signal);
700 err |= __put_user((regs->r17 >> 16) & 0xffff, (unsigned int __user *)&sc->ss);
701
702 if ( save_ia32_fpstate_live(fpstate) < 0 )
703 err = -EFAULT;
704 else
705 err |= __put_user((u32)(u64)fpstate, &sc->fpstate);
706
707 #if 0
708 tmp = save_i387(fpstate);
709 if (tmp < 0)
710 err = 1;
711 else
712 err |= __put_user(tmp ? fpstate : NULL, &sc->fpstate);
713
714 /* non-iBCS2 extensions.. */
715 #endif
716 err |= __put_user(mask, &sc->oldmask);
717 #if 0
718 err |= __put_user(current->tss.cr2, &sc->cr2);
719 #endif
720 return err;
721 }
722
723 static int
724 restore_sigcontext_ia32 (struct pt_regs *regs, struct sigcontext_ia32 __user *sc, int *peax)
725 {
726 unsigned int err = 0;
727
728 /* Always make any pending restarted system calls return -EINTR */
729 current_thread_info()->restart_block.fn = do_no_restart_syscall;
730
731 if (!access_ok(VERIFY_READ, sc, sizeof(*sc)))
732 return(-EFAULT);
733
734 #define COPY(ia64x, ia32x) err |= __get_user(regs->ia64x, &sc->ia32x)
735
736 #define copyseg_gs(tmp) (regs->r16 |= (unsigned long) (tmp) << 48)
737 #define copyseg_fs(tmp) (regs->r16 |= (unsigned long) (tmp) << 32)
738 #define copyseg_cs(tmp) (regs->r17 |= tmp)
739 #define copyseg_ss(tmp) (regs->r17 |= (unsigned long) (tmp) << 16)
740 #define copyseg_es(tmp) (regs->r16 |= (unsigned long) (tmp) << 16)
741 #define copyseg_ds(tmp) (regs->r16 |= tmp)
742
743 #define COPY_SEG(seg) \
744 { \
745 unsigned short tmp; \
746 err |= __get_user(tmp, &sc->seg); \
747 copyseg_##seg(tmp); \
748 }
749 #define COPY_SEG_STRICT(seg) \
750 { \
751 unsigned short tmp; \
752 err |= __get_user(tmp, &sc->seg); \
753 copyseg_##seg(tmp|3); \
754 }
755
756 /* To make COPY_SEGs easier, we zero r16, r17 */
757 regs->r16 = 0;
758 regs->r17 = 0;
759
760 COPY_SEG(gs);
761 COPY_SEG(fs);
762 COPY_SEG(es);
763 COPY_SEG(ds);
764 COPY(r15, edi);
765 COPY(r14, esi);
766 COPY(r13, ebp);
767 COPY(r12, esp);
768 COPY(r11, ebx);
769 COPY(r10, edx);
770 COPY(r9, ecx);
771 COPY(cr_iip, eip);
772 COPY_SEG_STRICT(cs);
773 COPY_SEG_STRICT(ss);
774 ia32_load_segment_descriptors(current);
775 {
776 unsigned int tmpflags;
777 unsigned long flag;
778
779 /*
780 * IA32 `eflags' is not part of `pt_regs', it's in an ar register which
781 * is part of the thread context. Fortunately, we are executing in the
782 * IA32 process's context.
783 */
784 err |= __get_user(tmpflags, &sc->eflags);
785 flag = ia64_getreg(_IA64_REG_AR_EFLAG);
786 flag &= ~0x40DD5;
787 flag |= (tmpflags & 0x40DD5);
788 ia64_setreg(_IA64_REG_AR_EFLAG, flag);
789
790 regs->r1 = -1; /* disable syscall checks, r1 is orig_eax */
791 }
792
793 {
794 struct _fpstate_ia32 __user *buf = NULL;
795 u32 fpstate_ptr;
796 err |= get_user(fpstate_ptr, &(sc->fpstate));
797 buf = compat_ptr(fpstate_ptr);
798 if (buf) {
799 err |= restore_ia32_fpstate_live(buf);
800 }
801 }
802
803 #if 0
804 {
805 struct _fpstate * buf;
806 err |= __get_user(buf, &sc->fpstate);
807 if (buf) {
808 if (verify_area(VERIFY_READ, buf, sizeof(*buf)))
809 goto badframe;
810 err |= restore_i387(buf);
811 }
812 }
813 #endif
814
815 err |= __get_user(*peax, &sc->eax);
816 return err;
817
818 #if 0
819 badframe:
820 return 1;
821 #endif
822 }
823
824 /*
825 * Determine which stack to use..
826 */
827 static inline void __user *
828 get_sigframe (struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
829 {
830 unsigned long esp;
831
832 /* Default to using normal stack (truncate off sign-extension of bit 31: */
833 esp = (unsigned int) regs->r12;
834
835 /* This is the X/Open sanctioned signal stack switching. */
836 if (ka->sa.sa_flags & SA_ONSTACK) {
837 if (!on_sig_stack(esp))
838 esp = current->sas_ss_sp + current->sas_ss_size;
839 }
840 /* Legacy stack switching not supported */
841
842 return (void __user *)((esp - frame_size) & -8ul);
843 }
844
845 static int
846 setup_frame_ia32 (int sig, struct k_sigaction *ka, sigset_t *set, struct pt_regs * regs)
847 {
848 struct exec_domain *ed = current_thread_info()->exec_domain;
849 struct sigframe_ia32 __user *frame;
850 int err = 0;
851
852 frame = get_sigframe(ka, regs, sizeof(*frame));
853
854 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
855 goto give_sigsegv;
856
857 err |= __put_user((ed && ed->signal_invmap && sig < 32
858 ? (int)(ed->signal_invmap[sig]) : sig), &frame->sig);
859
860 err |= setup_sigcontext_ia32(&frame->sc, &frame->fpstate, regs, set->sig[0]);
861
862 if (_COMPAT_NSIG_WORDS > 1)
863 err |= __copy_to_user(frame->extramask, (char *) &set->sig + 4,
864 sizeof(frame->extramask));
865
866 /* Set up to return from userspace. If provided, use a stub
867 already in userspace. */
868 if (ka->sa.sa_flags & SA_RESTORER) {
869 unsigned int restorer = IA32_SA_RESTORER(ka);
870 err |= __put_user(restorer, &frame->pretcode);
871 } else {
872 /* Pointing to restorer in ia32 gate page */
873 err |= __put_user(IA32_GATE_OFFSET, &frame->pretcode);
874 }
875
876 /* This is popl %eax ; movl $,%eax ; int $0x80
877 * and there for historical reasons only.
878 * See arch/i386/kernel/signal.c
879 */
880
881 err |= __put_user(0xb858, (short __user *)(frame->retcode+0));
882 err |= __put_user(__IA32_NR_sigreturn, (int __user *)(frame->retcode+2));
883 err |= __put_user(0x80cd, (short __user *)(frame->retcode+6));
884
885 if (err)
886 goto give_sigsegv;
887
888 /* Set up registers for signal handler */
889 regs->r12 = (unsigned long) frame;
890 regs->cr_iip = IA32_SA_HANDLER(ka);
891
892 set_fs(USER_DS);
893
894 #if 0
895 regs->eflags &= ~TF_MASK;
896 #endif
897
898 #if 0
899 printk("SIG deliver (%s:%d): sig=%d sp=%p pc=%lx ra=%x\n",
900 current->comm, current->pid, sig, (void *) frame, regs->cr_iip, frame->pretcode);
901 #endif
902
903 return 1;
904
905 give_sigsegv:
906 force_sigsegv(sig, current);
907 return 0;
908 }
909
910 static int
911 setup_rt_frame_ia32 (int sig, struct k_sigaction *ka, siginfo_t *info,
912 sigset_t *set, struct pt_regs * regs)
913 {
914 struct exec_domain *ed = current_thread_info()->exec_domain;
915 compat_uptr_t pinfo, puc;
916 struct rt_sigframe_ia32 __user *frame;
917 int err = 0;
918
919 frame = get_sigframe(ka, regs, sizeof(*frame));
920
921 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
922 goto give_sigsegv;
923
924 err |= __put_user((ed && ed->signal_invmap
925 && sig < 32 ? ed->signal_invmap[sig] : sig), &frame->sig);
926
927 pinfo = (long __user) &frame->info;
928 puc = (long __user) &frame->uc;
929 err |= __put_user(pinfo, &frame->pinfo);
930 err |= __put_user(puc, &frame->puc);
931 err |= copy_siginfo_to_user32(&frame->info, info);
932
933 /* Create the ucontext. */
934 err |= __put_user(0, &frame->uc.uc_flags);
935 err |= __put_user(0, &frame->uc.uc_link);
936 err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
937 err |= __put_user(sas_ss_flags(regs->r12), &frame->uc.uc_stack.ss_flags);
938 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
939 err |= setup_sigcontext_ia32(&frame->uc.uc_mcontext, &frame->fpstate, regs, set->sig[0]);
940 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
941 if (err)
942 goto give_sigsegv;
943
944 /* Set up to return from userspace. If provided, use a stub
945 already in userspace. */
946 if (ka->sa.sa_flags & SA_RESTORER) {
947 unsigned int restorer = IA32_SA_RESTORER(ka);
948 err |= __put_user(restorer, &frame->pretcode);
949 } else {
950 /* Pointing to rt_restorer in ia32 gate page */
951 err |= __put_user(IA32_GATE_OFFSET + 8, &frame->pretcode);
952 }
953
954 /* This is movl $,%eax ; int $0x80
955 * and there for historical reasons only.
956 * See arch/i386/kernel/signal.c
957 */
958
959 err |= __put_user(0xb8, (char __user *)(frame->retcode+0));
960 err |= __put_user(__IA32_NR_rt_sigreturn, (int __user *)(frame->retcode+1));
961 err |= __put_user(0x80cd, (short __user *)(frame->retcode+5));
962
963 if (err)
964 goto give_sigsegv;
965
966 /* Set up registers for signal handler */
967 regs->r12 = (unsigned long) frame;
968 regs->cr_iip = IA32_SA_HANDLER(ka);
969
970 set_fs(USER_DS);
971
972 #if 0
973 regs->eflags &= ~TF_MASK;
974 #endif
975
976 #if 0
977 printk("SIG deliver (%s:%d): sp=%p pc=%lx ra=%x\n",
978 current->comm, current->pid, (void *) frame, regs->cr_iip, frame->pretcode);
979 #endif
980
981 return 1;
982
983 give_sigsegv:
984 force_sigsegv(sig, current);
985 return 0;
986 }
987
988 int
989 ia32_setup_frame1 (int sig, struct k_sigaction *ka, siginfo_t *info,
990 sigset_t *set, struct pt_regs *regs)
991 {
992 /* Set up the stack frame */
993 if (ka->sa.sa_flags & SA_SIGINFO)
994 return setup_rt_frame_ia32(sig, ka, info, set, regs);
995 else
996 return setup_frame_ia32(sig, ka, set, regs);
997 }
998
999 asmlinkage long
1000 sys32_sigreturn (int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7,
1001 unsigned long stack)
1002 {
1003 struct pt_regs *regs = (struct pt_regs *) &stack;
1004 unsigned long esp = (unsigned int) regs->r12;
1005 struct sigframe_ia32 __user *frame = (struct sigframe_ia32 __user *)(esp - 8);
1006 sigset_t set;
1007 int eax;
1008
1009 if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
1010 goto badframe;
1011
1012 if (__get_user(set.sig[0], &frame->sc.oldmask)
1013 || (_COMPAT_NSIG_WORDS > 1 && __copy_from_user((char *) &set.sig + 4, &frame->extramask,
1014 sizeof(frame->extramask))))
1015 goto badframe;
1016
1017 sigdelsetmask(&set, ~_BLOCKABLE);
1018 spin_lock_irq(&current->sighand->siglock);
1019 current->blocked = set;
1020 recalc_sigpending();
1021 spin_unlock_irq(&current->sighand->siglock);
1022
1023 if (restore_sigcontext_ia32(regs, &frame->sc, &eax))
1024 goto badframe;
1025 return eax;
1026
1027 badframe:
1028 force_sig(SIGSEGV, current);
1029 return 0;
1030 }
1031
1032 asmlinkage long
1033 sys32_rt_sigreturn (int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7,
1034 unsigned long stack)
1035 {
1036 struct pt_regs *regs = (struct pt_regs *) &stack;
1037 unsigned long esp = (unsigned int) regs->r12;
1038 struct rt_sigframe_ia32 __user *frame = (struct rt_sigframe_ia32 __user *)(esp - 4);
1039 sigset_t set;
1040 int eax;
1041
1042 if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
1043 goto badframe;
1044 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
1045 goto badframe;
1046
1047 sigdelsetmask(&set, ~_BLOCKABLE);
1048 spin_lock_irq(&current->sighand->siglock);
1049 current->blocked = set;
1050 recalc_sigpending();
1051 spin_unlock_irq(&current->sighand->siglock);
1052
1053 if (restore_sigcontext_ia32(regs, &frame->uc.uc_mcontext, &eax))
1054 goto badframe;
1055
1056 /* It is more difficult to avoid calling this function than to
1057 call it and ignore errors. */
1058 do_sigaltstack((stack_t __user *) &frame->uc.uc_stack, NULL, esp);
1059
1060 return eax;
1061
1062 badframe:
1063 force_sig(SIGSEGV, current);
1064 return 0;
1065 }
MOXA 2.6.9 from sdlinux-moxaart.tgz