projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge master.kernel.org:/pub/scm/linux/kernel/git/sam/kbuild
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / arch / mips / kernel / signal32.c
1 /*
2 * This file is subject to the terms and conditions of the GNU General Public
3 * License. See the file "COPYING" in the main directory of this archive
4 * for more details.
5 *
6 * Copyright (C) 1991, 1992 Linus Torvalds
7 * Copyright (C) 1994 - 2000 Ralf Baechle
8 * Copyright (C) 1999, 2000 Silicon Graphics, Inc.
9 */
10 #include <linux/cache.h>
11 #include <linux/sched.h>
12 #include <linux/mm.h>
13 #include <linux/smp.h>
14 #include <linux/smp_lock.h>
15 #include <linux/kernel.h>
16 #include <linux/signal.h>
17 #include <linux/syscalls.h>
18 #include <linux/errno.h>
19 #include <linux/wait.h>
20 #include <linux/ptrace.h>
21 #include <linux/compat.h>
22 #include <linux/suspend.h>
23 #include <linux/compiler.h>
24
25 #include <asm/abi.h>
26 #include <asm/asm.h>
27 #include <linux/bitops.h>
28 #include <asm/cacheflush.h>
29 #include <asm/sim.h>
30 #include <asm/uaccess.h>
31 #include <asm/ucontext.h>
32 #include <asm/system.h>
33 #include <asm/fpu.h>
34 #include <asm/war.h>
35
36 #define SI_PAD_SIZE32 ((SI_MAX_SIZE/sizeof(int)) - 3)
37
38 typedef struct compat_siginfo {
39 int si_signo;
40 int si_code;
41 int si_errno;
42
43 union {
44 int _pad[SI_PAD_SIZE32];
45
46 /* kill() */
47 struct {
48 compat_pid_t _pid; /* sender's pid */
49 compat_uid_t _uid; /* sender's uid */
50 } _kill;
51
52 /* SIGCHLD */
53 struct {
54 compat_pid_t _pid; /* which child */
55 compat_uid_t _uid; /* sender's uid */
56 int _status; /* exit code */
57 compat_clock_t _utime;
58 compat_clock_t _stime;
59 } _sigchld;
60
61 /* IRIX SIGCHLD */
62 struct {
63 compat_pid_t _pid; /* which child */
64 compat_clock_t _utime;
65 int _status; /* exit code */
66 compat_clock_t _stime;
67 } _irix_sigchld;
68
69 /* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
70 struct {
71 s32 _addr; /* faulting insn/memory ref. */
72 } _sigfault;
73
74 /* SIGPOLL, SIGXFSZ (To do ...) */
75 struct {
76 int _band; /* POLL_IN, POLL_OUT, POLL_MSG */
77 int _fd;
78 } _sigpoll;
79
80 /* POSIX.1b timers */
81 struct {
82 timer_t _tid; /* timer id */
83 int _overrun; /* overrun count */
84 compat_sigval_t _sigval;/* same as below */
85 int _sys_private; /* not to be passed to user */
86 } _timer;
87
88 /* POSIX.1b signals */
89 struct {
90 compat_pid_t _pid; /* sender's pid */
91 compat_uid_t _uid; /* sender's uid */
92 compat_sigval_t _sigval;
93 } _rt;
94
95 } _sifields;
96 } compat_siginfo_t;
97
98 /*
99 * Including <asm/unistd.h> would give use the 64-bit syscall numbers ...
100 */
101 #define __NR_O32_sigreturn 4119
102 #define __NR_O32_rt_sigreturn 4193
103 #define __NR_O32_restart_syscall 4253
104
105 #define DEBUG_SIG 0
106
107 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
108
109 extern int do_signal32(sigset_t *oldset, struct pt_regs *regs);
110
111 /* 32-bit compatibility types */
112
113 #define _NSIG_BPW32 32
114 #define _NSIG_WORDS32 (_NSIG / _NSIG_BPW32)
115
116 typedef struct {
117 unsigned int sig[_NSIG_WORDS32];
118 } sigset_t32;
119
120 typedef unsigned int __sighandler32_t;
121 typedef void (*vfptr_t)(void);
122
123 struct sigaction32 {
124 unsigned int sa_flags;
125 __sighandler32_t sa_handler;
126 compat_sigset_t sa_mask;
127 };
128
129 /* IRIX compatible stack_t */
130 typedef struct sigaltstack32 {
131 s32 ss_sp;
132 compat_size_t ss_size;
133 int ss_flags;
134 } stack32_t;
135
136 struct ucontext32 {
137 u32 uc_flags;
138 s32 uc_link;
139 stack32_t uc_stack;
140 struct sigcontext32 uc_mcontext;
141 sigset_t32 uc_sigmask; /* mask last for extensibility */
142 };
143
144 extern void __put_sigset_unknown_nsig(void);
145 extern void __get_sigset_unknown_nsig(void);
146
147 static inline int put_sigset(const sigset_t *kbuf, compat_sigset_t *ubuf)
148 {
149 int err = 0;
150
151 if (!access_ok(VERIFY_WRITE, ubuf, sizeof(*ubuf)))
152 return -EFAULT;
153
154 switch (_NSIG_WORDS) {
155 default:
156 __put_sigset_unknown_nsig();
157 case 2:
158 err |= __put_user (kbuf->sig[1] >> 32, &ubuf->sig[3]);
159 err |= __put_user (kbuf->sig[1] & 0xffffffff, &ubuf->sig[2]);
160 case 1:
161 err |= __put_user (kbuf->sig[0] >> 32, &ubuf->sig[1]);
162 err |= __put_user (kbuf->sig[0] & 0xffffffff, &ubuf->sig[0]);
163 }
164
165 return err;
166 }
167
168 static inline int get_sigset(sigset_t *kbuf, const compat_sigset_t *ubuf)
169 {
170 int err = 0;
171 unsigned long sig[4];
172
173 if (!access_ok(VERIFY_READ, ubuf, sizeof(*ubuf)))
174 return -EFAULT;
175
176 switch (_NSIG_WORDS) {
177 default:
178 __get_sigset_unknown_nsig();
179 case 2:
180 err |= __get_user (sig[3], &ubuf->sig[3]);
181 err |= __get_user (sig[2], &ubuf->sig[2]);
182 kbuf->sig[1] = sig[2] | (sig[3] << 32);
183 case 1:
184 err |= __get_user (sig[1], &ubuf->sig[1]);
185 err |= __get_user (sig[0], &ubuf->sig[0]);
186 kbuf->sig[0] = sig[0] | (sig[1] << 32);
187 }
188
189 return err;
190 }
191
192 /*
193 * Atomically swap in the new signal mask, and wait for a signal.
194 */
195
196 save_static_function(sys32_sigsuspend);
197 __attribute_used__ noinline static int
198 _sys32_sigsuspend(nabi_no_regargs struct pt_regs regs)
199 {
200 compat_sigset_t *uset;
201 sigset_t newset, saveset;
202
203 uset = (compat_sigset_t *) regs.regs[4];
204 if (get_sigset(&newset, uset))
205 return -EFAULT;
206 sigdelsetmask(&newset, ~_BLOCKABLE);
207
208 spin_lock_irq(&current->sighand->siglock);
209 saveset = current->blocked;
210 current->blocked = newset;
211 recalc_sigpending();
212 spin_unlock_irq(&current->sighand->siglock);
213
214 regs.regs[2] = EINTR;
215 regs.regs[7] = 1;
216 while (1) {
217 current->state = TASK_INTERRUPTIBLE;
218 schedule();
219 if (do_signal32(&saveset, &regs))
220 return -EINTR;
221 }
222 }
223
224 save_static_function(sys32_rt_sigsuspend);
225 __attribute_used__ noinline static int
226 _sys32_rt_sigsuspend(nabi_no_regargs struct pt_regs regs)
227 {
228 compat_sigset_t *uset;
229 sigset_t newset, saveset;
230 size_t sigsetsize;
231
232 /* XXX Don't preclude handling different sized sigset_t's. */
233 sigsetsize = regs.regs[5];
234 if (sigsetsize != sizeof(compat_sigset_t))
235 return -EINVAL;
236
237 uset = (compat_sigset_t *) regs.regs[4];
238 if (get_sigset(&newset, uset))
239 return -EFAULT;
240 sigdelsetmask(&newset, ~_BLOCKABLE);
241
242 spin_lock_irq(&current->sighand->siglock);
243 saveset = current->blocked;
244 current->blocked = newset;
245 recalc_sigpending();
246 spin_unlock_irq(&current->sighand->siglock);
247
248 regs.regs[2] = EINTR;
249 regs.regs[7] = 1;
250 while (1) {
251 current->state = TASK_INTERRUPTIBLE;
252 schedule();
253 if (do_signal32(&saveset, &regs))
254 return -EINTR;
255 }
256 }
257
258 asmlinkage int sys32_sigaction(int sig, const struct sigaction32 *act,
259 struct sigaction32 *oact)
260 {
261 struct k_sigaction new_ka, old_ka;
262 int ret;
263 int err = 0;
264
265 if (act) {
266 old_sigset_t mask;
267 s32 handler;
268
269 if (!access_ok(VERIFY_READ, act, sizeof(*act)))
270 return -EFAULT;
271 err |= __get_user(handler, &act->sa_handler);
272 new_ka.sa.sa_handler = (void*)(s64)handler;
273 err |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
274 err |= __get_user(mask, &act->sa_mask.sig[0]);
275 if (err)
276 return -EFAULT;
277
278 siginitset(&new_ka.sa.sa_mask, mask);
279 }
280
281 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
282
283 if (!ret && oact) {
284 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
285 return -EFAULT;
286 err |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
287 err |= __put_user((u32)(u64)old_ka.sa.sa_handler,
288 &oact->sa_handler);
289 err |= __put_user(old_ka.sa.sa_mask.sig[0], oact->sa_mask.sig);
290 err |= __put_user(0, &oact->sa_mask.sig[1]);
291 err |= __put_user(0, &oact->sa_mask.sig[2]);
292 err |= __put_user(0, &oact->sa_mask.sig[3]);
293 if (err)
294 return -EFAULT;
295 }
296
297 return ret;
298 }
299
300 asmlinkage int sys32_sigaltstack(nabi_no_regargs struct pt_regs regs)
301 {
302 const stack32_t *uss = (const stack32_t *) regs.regs[4];
303 stack32_t *uoss = (stack32_t *) regs.regs[5];
304 unsigned long usp = regs.regs[29];
305 stack_t kss, koss;
306 int ret, err = 0;
307 mm_segment_t old_fs = get_fs();
308 s32 sp;
309
310 if (uss) {
311 if (!access_ok(VERIFY_READ, uss, sizeof(*uss)))
312 return -EFAULT;
313 err |= __get_user(sp, &uss->ss_sp);
314 kss.ss_sp = (void *) (long) sp;
315 err |= __get_user(kss.ss_size, &uss->ss_size);
316 err |= __get_user(kss.ss_flags, &uss->ss_flags);
317 if (err)
318 return -EFAULT;
319 }
320
321 set_fs (KERNEL_DS);
322 ret = do_sigaltstack(uss ? &kss : NULL , uoss ? &koss : NULL, usp);
323 set_fs (old_fs);
324
325 if (!ret && uoss) {
326 if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss)))
327 return -EFAULT;
328 sp = (int) (long) koss.ss_sp;
329 err |= __put_user(sp, &uoss->ss_sp);
330 err |= __put_user(koss.ss_size, &uoss->ss_size);
331 err |= __put_user(koss.ss_flags, &uoss->ss_flags);
332 if (err)
333 return -EFAULT;
334 }
335 return ret;
336 }
337
338 static int restore_sigcontext32(struct pt_regs *regs, struct sigcontext32 *sc)
339 {
340 u32 used_math;
341 int err = 0;
342 s32 treg;
343
344 /* Always make any pending restarted system calls return -EINTR */
345 current_thread_info()->restart_block.fn = do_no_restart_syscall;
346
347 err |= __get_user(regs->cp0_epc, &sc->sc_pc);
348 err |= __get_user(regs->hi, &sc->sc_mdhi);
349 err |= __get_user(regs->lo, &sc->sc_mdlo);
350 if (cpu_has_dsp) {
351 err |= __get_user(treg, &sc->sc_hi1); mthi1(treg);
352 err |= __get_user(treg, &sc->sc_lo1); mtlo1(treg);
353 err |= __get_user(treg, &sc->sc_hi2); mthi2(treg);
354 err |= __get_user(treg, &sc->sc_lo2); mtlo2(treg);
355 err |= __get_user(treg, &sc->sc_hi3); mthi3(treg);
356 err |= __get_user(treg, &sc->sc_lo3); mtlo3(treg);
357 err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK);
358 }
359
360 #define restore_gp_reg(i) do { \
361 err |= __get_user(regs->regs[i], &sc->sc_regs[i]); \
362 } while(0)
363 restore_gp_reg( 1); restore_gp_reg( 2); restore_gp_reg( 3);
364 restore_gp_reg( 4); restore_gp_reg( 5); restore_gp_reg( 6);
365 restore_gp_reg( 7); restore_gp_reg( 8); restore_gp_reg( 9);
366 restore_gp_reg(10); restore_gp_reg(11); restore_gp_reg(12);
367 restore_gp_reg(13); restore_gp_reg(14); restore_gp_reg(15);
368 restore_gp_reg(16); restore_gp_reg(17); restore_gp_reg(18);
369 restore_gp_reg(19); restore_gp_reg(20); restore_gp_reg(21);
370 restore_gp_reg(22); restore_gp_reg(23); restore_gp_reg(24);
371 restore_gp_reg(25); restore_gp_reg(26); restore_gp_reg(27);
372 restore_gp_reg(28); restore_gp_reg(29); restore_gp_reg(30);
373 restore_gp_reg(31);
374 #undef restore_gp_reg
375
376 err |= __get_user(used_math, &sc->sc_used_math);
377 conditional_used_math(used_math);
378
379 preempt_disable();
380
381 if (used_math()) {
382 /* restore fpu context if we have used it before */
383 own_fpu();
384 err |= restore_fp_context32(sc);
385 } else {
386 /* signal handler may have used FPU. Give it up. */
387 lose_fpu();
388 }
389
390 preempt_enable();
391
392 return err;
393 }
394
395 struct sigframe {
396 u32 sf_ass[4]; /* argument save space for o32 */
397 #if ICACHE_REFILLS_WORKAROUND_WAR
398 u32 sf_pad[2];
399 #else
400 u32 sf_code[2]; /* signal trampoline */
401 #endif
402 struct sigcontext32 sf_sc;
403 sigset_t sf_mask;
404 #if ICACHE_REFILLS_WORKAROUND_WAR
405 u32 sf_code[8] ____cacheline_aligned; /* signal trampoline */
406 #endif
407 };
408
409 struct rt_sigframe32 {
410 u32 rs_ass[4]; /* argument save space for o32 */
411 #if ICACHE_REFILLS_WORKAROUND_WAR
412 u32 rs_pad[2];
413 #else
414 u32 rs_code[2]; /* signal trampoline */
415 #endif
416 compat_siginfo_t rs_info;
417 struct ucontext32 rs_uc;
418 #if ICACHE_REFILLS_WORKAROUND_WAR
419 u32 rs_code[8] __attribute__((aligned(32))); /* signal trampoline */
420 #endif
421 };
422
423 int copy_siginfo_to_user32(compat_siginfo_t *to, siginfo_t *from)
424 {
425 int err;
426
427 if (!access_ok (VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
428 return -EFAULT;
429
430 /* If you change siginfo_t structure, please be sure
431 this code is fixed accordingly.
432 It should never copy any pad contained in the structure
433 to avoid security leaks, but must copy the generic
434 3 ints plus the relevant union member.
435 This routine must convert siginfo from 64bit to 32bit as well
436 at the same time. */
437 err = __put_user(from->si_signo, &to->si_signo);
438 err |= __put_user(from->si_errno, &to->si_errno);
439 err |= __put_user((short)from->si_code, &to->si_code);
440 if (from->si_code < 0)
441 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
442 else {
443 switch (from->si_code >> 16) {
444 case __SI_TIMER >> 16:
445 err |= __put_user(from->si_tid, &to->si_tid);
446 err |= __put_user(from->si_overrun, &to->si_overrun);
447 err |= __put_user(from->si_int, &to->si_int);
448 break;
449 case __SI_CHLD >> 16:
450 err |= __put_user(from->si_utime, &to->si_utime);
451 err |= __put_user(from->si_stime, &to->si_stime);
452 err |= __put_user(from->si_status, &to->si_status);
453 default:
454 err |= __put_user(from->si_pid, &to->si_pid);
455 err |= __put_user(from->si_uid, &to->si_uid);
456 break;
457 case __SI_FAULT >> 16:
458 err |= __put_user((long)from->si_addr, &to->si_addr);
459 break;
460 case __SI_POLL >> 16:
461 err |= __put_user(from->si_band, &to->si_band);
462 err |= __put_user(from->si_fd, &to->si_fd);
463 break;
464 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
465 case __SI_MESGQ >> 16:
466 err |= __put_user(from->si_pid, &to->si_pid);
467 err |= __put_user(from->si_uid, &to->si_uid);
468 err |= __put_user(from->si_int, &to->si_int);
469 break;
470 }
471 }
472 return err;
473 }
474
475 save_static_function(sys32_sigreturn);
476 __attribute_used__ noinline static void
477 _sys32_sigreturn(nabi_no_regargs struct pt_regs regs)
478 {
479 struct sigframe *frame;
480 sigset_t blocked;
481
482 frame = (struct sigframe *) regs.regs[29];
483 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
484 goto badframe;
485 if (__copy_from_user(&blocked, &frame->sf_mask, sizeof(blocked)))
486 goto badframe;
487
488 sigdelsetmask(&blocked, ~_BLOCKABLE);
489 spin_lock_irq(&current->sighand->siglock);
490 current->blocked = blocked;
491 recalc_sigpending();
492 spin_unlock_irq(&current->sighand->siglock);
493
494 if (restore_sigcontext32(&regs, &frame->sf_sc))
495 goto badframe;
496
497 /*
498 * Don't let your children do this ...
499 */
500 if (current_thread_info()->flags & TIF_SYSCALL_TRACE)
501 do_syscall_trace(&regs, 1);
502 __asm__ __volatile__(
503 "move\t$29, %0\n\t"
504 "j\tsyscall_exit"
505 :/* no outputs */
506 :"r" (&regs));
507 /* Unreached */
508
509 badframe:
510 force_sig(SIGSEGV, current);
511 }
512
513 save_static_function(sys32_rt_sigreturn);
514 __attribute_used__ noinline static void
515 _sys32_rt_sigreturn(nabi_no_regargs struct pt_regs regs)
516 {
517 struct rt_sigframe32 *frame;
518 mm_segment_t old_fs;
519 sigset_t set;
520 stack_t st;
521 s32 sp;
522
523 frame = (struct rt_sigframe32 *) regs.regs[29];
524 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
525 goto badframe;
526 if (__copy_from_user(&set, &frame->rs_uc.uc_sigmask, sizeof(set)))
527 goto badframe;
528
529 sigdelsetmask(&set, ~_BLOCKABLE);
530 spin_lock_irq(&current->sighand->siglock);
531 current->blocked = set;
532 recalc_sigpending();
533 spin_unlock_irq(&current->sighand->siglock);
534
535 if (restore_sigcontext32(&regs, &frame->rs_uc.uc_mcontext))
536 goto badframe;
537
538 /* The ucontext contains a stack32_t, so we must convert! */
539 if (__get_user(sp, &frame->rs_uc.uc_stack.ss_sp))
540 goto badframe;
541 st.ss_size = (long) sp;
542 if (__get_user(st.ss_size, &frame->rs_uc.uc_stack.ss_size))
543 goto badframe;
544 if (__get_user(st.ss_flags, &frame->rs_uc.uc_stack.ss_flags))
545 goto badframe;
546
547 /* It is more difficult to avoid calling this function than to
548 call it and ignore errors. */
549 old_fs = get_fs();
550 set_fs (KERNEL_DS);
551 do_sigaltstack(&st, NULL, regs.regs[29]);
552 set_fs (old_fs);
553
554 /*
555 * Don't let your children do this ...
556 */
557 __asm__ __volatile__(
558 "move\t$29, %0\n\t"
559 "j\tsyscall_exit"
560 :/* no outputs */
561 :"r" (&regs));
562 /* Unreached */
563
564 badframe:
565 force_sig(SIGSEGV, current);
566 }
567
568 static inline int setup_sigcontext32(struct pt_regs *regs,
569 struct sigcontext32 *sc)
570 {
571 int err = 0;
572
573 err |= __put_user(regs->cp0_epc, &sc->sc_pc);
574 err |= __put_user(regs->cp0_status, &sc->sc_status);
575
576 #define save_gp_reg(i) { \
577 err |= __put_user(regs->regs[i], &sc->sc_regs[i]); \
578 } while(0)
579 __put_user(0, &sc->sc_regs[0]); save_gp_reg(1); save_gp_reg(2);
580 save_gp_reg(3); save_gp_reg(4); save_gp_reg(5); save_gp_reg(6);
581 save_gp_reg(7); save_gp_reg(8); save_gp_reg(9); save_gp_reg(10);
582 save_gp_reg(11); save_gp_reg(12); save_gp_reg(13); save_gp_reg(14);
583 save_gp_reg(15); save_gp_reg(16); save_gp_reg(17); save_gp_reg(18);
584 save_gp_reg(19); save_gp_reg(20); save_gp_reg(21); save_gp_reg(22);
585 save_gp_reg(23); save_gp_reg(24); save_gp_reg(25); save_gp_reg(26);
586 save_gp_reg(27); save_gp_reg(28); save_gp_reg(29); save_gp_reg(30);
587 save_gp_reg(31);
588 #undef save_gp_reg
589
590 err |= __put_user(regs->hi, &sc->sc_mdhi);
591 err |= __put_user(regs->lo, &sc->sc_mdlo);
592 if (cpu_has_dsp) {
593 err |= __put_user(rddsp(DSP_MASK), &sc->sc_hi1);
594 err |= __put_user(mfhi1(), &sc->sc_hi1);
595 err |= __put_user(mflo1(), &sc->sc_lo1);
596 err |= __put_user(mfhi2(), &sc->sc_hi2);
597 err |= __put_user(mflo2(), &sc->sc_lo2);
598 err |= __put_user(mfhi3(), &sc->sc_hi3);
599 err |= __put_user(mflo3(), &sc->sc_lo3);
600 }
601
602 err |= __put_user(!!used_math(), &sc->sc_used_math);
603
604 if (!used_math())
605 goto out;
606
607 /*
608 * Save FPU state to signal context. Signal handler will "inherit"
609 * current FPU state.
610 */
611 preempt_disable();
612
613 if (!is_fpu_owner()) {
614 own_fpu();
615 restore_fp(current);
616 }
617 err |= save_fp_context32(sc);
618
619 preempt_enable();
620
621 out:
622 return err;
623 }
624
625 /*
626 * Determine which stack to use..
627 */
628 static inline void *get_sigframe(struct k_sigaction *ka, struct pt_regs *regs,
629 size_t frame_size)
630 {
631 unsigned long sp;
632
633 /* Default to using normal stack */
634 sp = regs->regs[29];
635
636 /*
637 * FPU emulator may have it's own trampoline active just
638 * above the user stack, 16-bytes before the next lowest
639 * 16 byte boundary. Try to avoid trashing it.
640 */
641 sp -= 32;
642
643 /* This is the X/Open sanctioned signal stack switching. */
644 if ((ka->sa.sa_flags & SA_ONSTACK) && (sas_ss_flags (sp) == 0))
645 sp = current->sas_ss_sp + current->sas_ss_size;
646
647 return (void *)((sp - frame_size) & ALMASK);
648 }
649
650 int setup_frame_32(struct k_sigaction * ka, struct pt_regs *regs,
651 int signr, sigset_t *set)
652 {
653 struct sigframe *frame;
654 int err = 0;
655
656 frame = get_sigframe(ka, regs, sizeof(*frame));
657 if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
658 goto give_sigsegv;
659
660 /*
661 * Set up the return code ...
662 *
663 * li v0, __NR_O32_sigreturn
664 * syscall
665 */
666 err |= __put_user(0x24020000 + __NR_O32_sigreturn, frame->sf_code + 0);
667 err |= __put_user(0x0000000c , frame->sf_code + 1);
668 flush_cache_sigtramp((unsigned long) frame->sf_code);
669
670 err |= setup_sigcontext32(regs, &frame->sf_sc);
671 err |= __copy_to_user(&frame->sf_mask, set, sizeof(*set));
672 if (err)
673 goto give_sigsegv;
674
675 /*
676 * Arguments to signal handler:
677 *
678 * a0 = signal number
679 * a1 = 0 (should be cause)
680 * a2 = pointer to struct sigcontext
681 *
682 * $25 and c0_epc point to the signal handler, $29 points to the
683 * struct sigframe.
684 */
685 regs->regs[ 4] = signr;
686 regs->regs[ 5] = 0;
687 regs->regs[ 6] = (unsigned long) &frame->sf_sc;
688 regs->regs[29] = (unsigned long) frame;
689 regs->regs[31] = (unsigned long) frame->sf_code;
690 regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
691
692 #if DEBUG_SIG
693 printk("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%p\n",
694 current->comm, current->pid,
695 frame, regs->cp0_epc, frame->sf_code);
696 #endif
697 return 1;
698
699 give_sigsegv:
700 force_sigsegv(signr, current);
701 return 0;
702 }
703
704 int setup_rt_frame_32(struct k_sigaction * ka, struct pt_regs *regs,
705 int signr, sigset_t *set, siginfo_t *info)
706 {
707 struct rt_sigframe32 *frame;
708 int err = 0;
709 s32 sp;
710
711 frame = get_sigframe(ka, regs, sizeof(*frame));
712 if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
713 goto give_sigsegv;
714
715 /* Set up to return from userspace. If provided, use a stub already
716 in userspace. */
717 /*
718 * Set up the return code ...
719 *
720 * li v0, __NR_O32_rt_sigreturn
721 * syscall
722 */
723 err |= __put_user(0x24020000 + __NR_O32_rt_sigreturn, frame->rs_code + 0);
724 err |= __put_user(0x0000000c , frame->rs_code + 1);
725 flush_cache_sigtramp((unsigned long) frame->rs_code);
726
727 /* Convert (siginfo_t -> compat_siginfo_t) and copy to user. */
728 err |= copy_siginfo_to_user32(&frame->rs_info, info);
729
730 /* Create the ucontext. */
731 err |= __put_user(0, &frame->rs_uc.uc_flags);
732 err |= __put_user(0, &frame->rs_uc.uc_link);
733 sp = (int) (long) current->sas_ss_sp;
734 err |= __put_user(sp,
735 &frame->rs_uc.uc_stack.ss_sp);
736 err |= __put_user(sas_ss_flags(regs->regs[29]),
737 &frame->rs_uc.uc_stack.ss_flags);
738 err |= __put_user(current->sas_ss_size,
739 &frame->rs_uc.uc_stack.ss_size);
740 err |= setup_sigcontext32(regs, &frame->rs_uc.uc_mcontext);
741 err |= __copy_to_user(&frame->rs_uc.uc_sigmask, set, sizeof(*set));
742
743 if (err)
744 goto give_sigsegv;
745
746 /*
747 * Arguments to signal handler:
748 *
749 * a0 = signal number
750 * a1 = 0 (should be cause)
751 * a2 = pointer to ucontext
752 *
753 * $25 and c0_epc point to the signal handler, $29 points to
754 * the struct rt_sigframe32.
755 */
756 regs->regs[ 4] = signr;
757 regs->regs[ 5] = (unsigned long) &frame->rs_info;
758 regs->regs[ 6] = (unsigned long) &frame->rs_uc;
759 regs->regs[29] = (unsigned long) frame;
760 regs->regs[31] = (unsigned long) frame->rs_code;
761 regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
762
763 #if DEBUG_SIG
764 printk("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%p\n",
765 current->comm, current->pid,
766 frame, regs->cp0_epc, frame->rs_code);
767 #endif
768 return 1;
769
770 give_sigsegv:
771 force_sigsegv(signr, current);
772 return 0;
773 }
774
775 static inline int handle_signal(unsigned long sig, siginfo_t *info,
776 struct k_sigaction *ka, sigset_t *oldset, struct pt_regs * regs)
777 {
778 int ret;
779
780 switch (regs->regs[0]) {
781 case ERESTART_RESTARTBLOCK:
782 case ERESTARTNOHAND:
783 regs->regs[2] = EINTR;
784 break;
785 case ERESTARTSYS:
786 if(!(ka->sa.sa_flags & SA_RESTART)) {
787 regs->regs[2] = EINTR;
788 break;
789 }
790 /* fallthrough */
791 case ERESTARTNOINTR: /* Userland will reload $v0. */
792 regs->regs[7] = regs->regs[26];
793 regs->cp0_epc -= 8;
794 }
795
796 regs->regs[0] = 0; /* Don't deal with this again. */
797
798 if (ka->sa.sa_flags & SA_SIGINFO)
799 ret = current->thread.abi->setup_rt_frame(ka, regs, sig, oldset, info);
800 else
801 ret = current->thread.abi->setup_frame(ka, regs, sig, oldset);
802
803 spin_lock_irq(&current->sighand->siglock);
804 sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
805 if (!(ka->sa.sa_flags & SA_NODEFER))
806 sigaddset(&current->blocked,sig);
807 recalc_sigpending();
808 spin_unlock_irq(&current->sighand->siglock);
809
810 return ret;
811 }
812
813 int do_signal32(sigset_t *oldset, struct pt_regs *regs)
814 {
815 struct k_sigaction ka;
816 siginfo_t info;
817 int signr;
818
819 /*
820 * We want the common case to go fast, which is why we may in certain
821 * cases get here from kernel mode. Just return without doing anything
822 * if so.
823 */
824 if (!user_mode(regs))
825 return 1;
826
827 if (try_to_freeze())
828 goto no_signal;
829
830 if (!oldset)
831 oldset = &current->blocked;
832
833 signr = get_signal_to_deliver(&info, &ka, regs, NULL);
834 if (signr > 0)
835 return handle_signal(signr, &info, &ka, oldset, regs);
836
837 no_signal:
838 /*
839 * Who's code doesn't conform to the restartable syscall convention
840 * dies here!!! The li instruction, a single machine instruction,
841 * must directly be followed by the syscall instruction.
842 */
843 if (regs->regs[0]) {
844 if (regs->regs[2] == ERESTARTNOHAND ||
845 regs->regs[2] == ERESTARTSYS ||
846 regs->regs[2] == ERESTARTNOINTR) {
847 regs->regs[7] = regs->regs[26];
848 regs->cp0_epc -= 8;
849 }
850 if (regs->regs[2] == ERESTART_RESTARTBLOCK) {
851 regs->regs[2] = __NR_O32_restart_syscall;
852 regs->regs[7] = regs->regs[26];
853 regs->cp0_epc -= 4;
854 }
855 }
856 return 0;
857 }
858
859 asmlinkage int sys32_rt_sigaction(int sig, const struct sigaction32 *act,
860 struct sigaction32 *oact,
861 unsigned int sigsetsize)
862 {
863 struct k_sigaction new_sa, old_sa;
864 int ret = -EINVAL;
865
866 /* XXX: Don't preclude handling different sized sigset_t's. */
867 if (sigsetsize != sizeof(sigset_t))
868 goto out;
869
870 if (act) {
871 s32 handler;
872 int err = 0;
873
874 if (!access_ok(VERIFY_READ, act, sizeof(*act)))
875 return -EFAULT;
876 err |= __get_user(handler, &act->sa_handler);
877 new_sa.sa.sa_handler = (void*)(s64)handler;
878 err |= __get_user(new_sa.sa.sa_flags, &act->sa_flags);
879 err |= get_sigset(&new_sa.sa.sa_mask, &act->sa_mask);
880 if (err)
881 return -EFAULT;
882 }
883
884 ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
885
886 if (!ret && oact) {
887 int err = 0;
888
889 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
890 return -EFAULT;
891
892 err |= __put_user((u32)(u64)old_sa.sa.sa_handler,
893 &oact->sa_handler);
894 err |= __put_user(old_sa.sa.sa_flags, &oact->sa_flags);
895 err |= put_sigset(&old_sa.sa.sa_mask, &oact->sa_mask);
896 if (err)
897 return -EFAULT;
898 }
899 out:
900 return ret;
901 }
902
903 asmlinkage int sys32_rt_sigprocmask(int how, compat_sigset_t *set,
904 compat_sigset_t *oset, unsigned int sigsetsize)
905 {
906 sigset_t old_set, new_set;
907 int ret;
908 mm_segment_t old_fs = get_fs();
909
910 if (set && get_sigset(&new_set, set))
911 return -EFAULT;
912
913 set_fs (KERNEL_DS);
914 ret = sys_rt_sigprocmask(how, set ? &new_set : NULL,
915 oset ? &old_set : NULL, sigsetsize);
916 set_fs (old_fs);
917
918 if (!ret && oset && put_sigset(&old_set, oset))
919 return -EFAULT;
920
921 return ret;
922 }
923
924 asmlinkage int sys32_rt_sigpending(compat_sigset_t *uset,
925 unsigned int sigsetsize)
926 {
927 int ret;
928 sigset_t set;
929 mm_segment_t old_fs = get_fs();
930
931 set_fs (KERNEL_DS);
932 ret = sys_rt_sigpending(&set, sigsetsize);
933 set_fs (old_fs);
934
935 if (!ret && put_sigset(&set, uset))
936 return -EFAULT;
937
938 return ret;
939 }
940
941 asmlinkage int sys32_rt_sigqueueinfo(int pid, int sig, compat_siginfo_t *uinfo)
942 {
943 siginfo_t info;
944 int ret;
945 mm_segment_t old_fs = get_fs();
946
947 if (copy_from_user (&info, uinfo, 3*sizeof(int)) ||
948 copy_from_user (info._sifields._pad, uinfo->_sifields._pad, SI_PAD_SIZE))
949 return -EFAULT;
950 set_fs (KERNEL_DS);
951 ret = sys_rt_sigqueueinfo(pid, sig, &info);
952 set_fs (old_fs);
953 return ret;
954 }
955
956 asmlinkage long
957 sys32_waitid(int which, compat_pid_t pid,
958 compat_siginfo_t __user *uinfo, int options,
959 struct compat_rusage __user *uru)
960 {
961 siginfo_t info;
962 struct rusage ru;
963 long ret;
964 mm_segment_t old_fs = get_fs();
965
966 info.si_signo = 0;
967 set_fs (KERNEL_DS);
968 ret = sys_waitid(which, pid, (siginfo_t __user *) &info, options,
969 uru ? (struct rusage __user *) &ru : NULL);
970 set_fs (old_fs);
971
972 if (ret < 0 || info.si_signo == 0)
973 return ret;
974
975 if (uru && (ret = put_compat_rusage(&ru, uru)))
976 return ret;
977
978 BUG_ON(info.si_code & __SI_MASK);
979 info.si_code |= __SI_CHLD;
980 return copy_siginfo_to_user32(uinfo, &info);
981 }
kernel source for telekom puls (alcatel/mediatek)