]> git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blob - arch/sparc/kernel/signal32.c
projects / mirror_ubuntu-jammy-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
alpha: osf_sys.c: use timespec64 where appropriate
[mirror_ubuntu-jammy-kernel.git] / arch / sparc / kernel / signal32.c
1 // SPDX-License-Identifier: GPL-2.0
2 /* arch/sparc64/kernel/signal32.c
3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
6 * Copyright (C) 1996 Miguel de Icaza (miguel@nuclecu.unam.mx)
7 * Copyright (C) 1997 Eddie C. Dost (ecd@skynet.be)
8 * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
9 */
10
11 #include <linux/sched.h>
12 #include <linux/kernel.h>
13 #include <linux/signal.h>
14 #include <linux/errno.h>
15 #include <linux/wait.h>
16 #include <linux/ptrace.h>
17 #include <linux/unistd.h>
18 #include <linux/mm.h>
19 #include <linux/tty.h>
20 #include <linux/binfmts.h>
21 #include <linux/compat.h>
22 #include <linux/bitops.h>
23 #include <linux/tracehook.h>
24
25 #include <linux/uaccess.h>
26 #include <asm/ptrace.h>
27 #include <asm/pgtable.h>
28 #include <asm/psrcompat.h>
29 #include <asm/fpumacro.h>
30 #include <asm/visasm.h>
31 #include <asm/compat_signal.h>
32 #include <asm/switch_to.h>
33
34 #include "sigutil.h"
35 #include "kernel.h"
36
37 /* This magic should be in g_upper[0] for all upper parts
38 * to be valid.
39 */
40 #define SIGINFO_EXTRA_V8PLUS_MAGIC 0x130e269
41 typedef struct {
42 unsigned int g_upper[8];
43 unsigned int o_upper[8];
44 unsigned int asi;
45 } siginfo_extra_v8plus_t;
46
47 struct signal_frame32 {
48 struct sparc_stackf32 ss;
49 __siginfo32_t info;
50 /* __siginfo_fpu_t * */ u32 fpu_save;
51 unsigned int insns[2];
52 unsigned int extramask[_COMPAT_NSIG_WORDS - 1];
53 unsigned int extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */
54 /* Only valid if (info.si_regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */
55 siginfo_extra_v8plus_t v8plus;
56 /* __siginfo_rwin_t * */u32 rwin_save;
57 } __attribute__((aligned(8)));
58
59 struct rt_signal_frame32 {
60 struct sparc_stackf32 ss;
61 compat_siginfo_t info;
62 struct pt_regs32 regs;
63 compat_sigset_t mask;
64 /* __siginfo_fpu_t * */ u32 fpu_save;
65 unsigned int insns[2];
66 compat_stack_t stack;
67 unsigned int extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */
68 /* Only valid if (regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */
69 siginfo_extra_v8plus_t v8plus;
70 /* __siginfo_rwin_t * */u32 rwin_save;
71 } __attribute__((aligned(8)));
72
73 int copy_siginfo_to_user32(compat_siginfo_t __user *to, const siginfo_t *from)
74 {
75 int err;
76
77 if (!access_ok(VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
78 return -EFAULT;
79
80 /* If you change siginfo_t structure, please be sure
81 this code is fixed accordingly.
82 It should never copy any pad contained in the structure
83 to avoid security leaks, but must copy the generic
84 3 ints plus the relevant union member.
85 This routine must convert siginfo from 64bit to 32bit as well
86 at the same time. */
87 err = __put_user(from->si_signo, &to->si_signo);
88 err |= __put_user(from->si_errno, &to->si_errno);
89 err |= __put_user(from->si_code, &to->si_code);
90 if (from->si_code < 0)
91 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
92 else {
93 switch (siginfo_layout(from->si_signo, from->si_code)) {
94 case SIL_TIMER:
95 err |= __put_user(from->si_tid, &to->si_tid);
96 err |= __put_user(from->si_overrun, &to->si_overrun);
97 err |= __put_user(from->si_int, &to->si_int);
98 break;
99 case SIL_CHLD:
100 err |= __put_user(from->si_utime, &to->si_utime);
101 err |= __put_user(from->si_stime, &to->si_stime);
102 err |= __put_user(from->si_status, &to->si_status);
103 default:
104 case SIL_KILL:
105 err |= __put_user(from->si_pid, &to->si_pid);
106 err |= __put_user(from->si_uid, &to->si_uid);
107 break;
108 case SIL_FAULT:
109 err |= __put_user(from->si_trapno, &to->si_trapno);
110 err |= __put_user((unsigned long)from->si_addr, &to->si_addr);
111 break;
112 case SIL_POLL:
113 err |= __put_user(from->si_band, &to->si_band);
114 err |= __put_user(from->si_fd, &to->si_fd);
115 break;
116 case SIL_RT:
117 err |= __put_user(from->si_pid, &to->si_pid);
118 err |= __put_user(from->si_uid, &to->si_uid);
119 err |= __put_user(from->si_int, &to->si_int);
120 break;
121 }
122 }
123 return err;
124 }
125
126 /* CAUTION: This is just a very minimalist implementation for the
127 * sake of compat_sys_rt_sigqueueinfo()
128 */
129 int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
130 {
131 if (!access_ok(VERIFY_WRITE, from, sizeof(compat_siginfo_t)))
132 return -EFAULT;
133
134 if (copy_from_user(to, from, 3*sizeof(int)) ||
135 copy_from_user(to->_sifields._pad, from->_sifields._pad,
136 SI_PAD_SIZE))
137 return -EFAULT;
138
139 return 0;
140 }
141
142 /* Checks if the fp is valid. We always build signal frames which are
143 * 16-byte aligned, therefore we can always enforce that the restore
144 * frame has that property as well.
145 */
146 static bool invalid_frame_pointer(void __user *fp, int fplen)
147 {
148 if ((((unsigned long) fp) & 15) ||
149 ((unsigned long)fp) > 0x100000000ULL - fplen)
150 return true;
151 return false;
152 }
153
154 void do_sigreturn32(struct pt_regs *regs)
155 {
156 struct signal_frame32 __user *sf;
157 compat_uptr_t fpu_save;
158 compat_uptr_t rwin_save;
159 unsigned int psr, ufp;
160 unsigned int pc, npc;
161 sigset_t set;
162 compat_sigset_t seta;
163 int err, i;
164
165 /* Always make any pending restarted system calls return -EINTR */
166 current->restart_block.fn = do_no_restart_syscall;
167
168 synchronize_user_stack();
169
170 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
171 sf = (struct signal_frame32 __user *) regs->u_regs[UREG_FP];
172
173 /* 1. Make sure we are not getting garbage from the user */
174 if (invalid_frame_pointer(sf, sizeof(*sf)))
175 goto segv;
176
177 if (get_user(ufp, &sf->info.si_regs.u_regs[UREG_FP]))
178 goto segv;
179
180 if (ufp & 0x7)
181 goto segv;
182
183 if (__get_user(pc, &sf->info.si_regs.pc) ||
184 __get_user(npc, &sf->info.si_regs.npc))
185 goto segv;
186
187 if ((pc | npc) & 3)
188 goto segv;
189
190 if (test_thread_flag(TIF_32BIT)) {
191 pc &= 0xffffffff;
192 npc &= 0xffffffff;
193 }
194 regs->tpc = pc;
195 regs->tnpc = npc;
196
197 /* 2. Restore the state */
198 err = __get_user(regs->y, &sf->info.si_regs.y);
199 err |= __get_user(psr, &sf->info.si_regs.psr);
200
201 for (i = UREG_G1; i <= UREG_I7; i++)
202 err |= __get_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]);
203 if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) {
204 err |= __get_user(i, &sf->v8plus.g_upper[0]);
205 if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) {
206 unsigned long asi;
207
208 for (i = UREG_G1; i <= UREG_I7; i++)
209 err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
210 err |= __get_user(asi, &sf->v8plus.asi);
211 regs->tstate &= ~TSTATE_ASI;
212 regs->tstate |= ((asi & 0xffUL) << 24UL);
213 }
214 }
215
216 /* User can only change condition codes in %tstate. */
217 regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
218 regs->tstate |= psr_to_tstate_icc(psr);
219
220 /* Prevent syscall restart. */
221 pt_regs_clear_syscall(regs);
222
223 err |= __get_user(fpu_save, &sf->fpu_save);
224 if (!err && fpu_save)
225 err |= restore_fpu_state(regs, compat_ptr(fpu_save));
226 err |= __get_user(rwin_save, &sf->rwin_save);
227 if (!err && rwin_save) {
228 if (restore_rwin_state(compat_ptr(rwin_save)))
229 goto segv;
230 }
231 err |= __get_user(seta.sig[0], &sf->info.si_mask);
232 err |= copy_from_user(&seta.sig[1], &sf->extramask,
233 (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
234 if (err)
235 goto segv;
236
237 set.sig[0] = seta.sig[0] + (((long)seta.sig[1]) << 32);
238 set_current_blocked(&set);
239 return;
240
241 segv:
242 force_sig(SIGSEGV, current);
243 }
244
245 asmlinkage void do_rt_sigreturn32(struct pt_regs *regs)
246 {
247 struct rt_signal_frame32 __user *sf;
248 unsigned int psr, pc, npc, ufp;
249 compat_uptr_t fpu_save;
250 compat_uptr_t rwin_save;
251 sigset_t set;
252 int err, i;
253
254 /* Always make any pending restarted system calls return -EINTR */
255 current->restart_block.fn = do_no_restart_syscall;
256
257 synchronize_user_stack();
258 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
259 sf = (struct rt_signal_frame32 __user *) regs->u_regs[UREG_FP];
260
261 /* 1. Make sure we are not getting garbage from the user */
262 if (invalid_frame_pointer(sf, sizeof(*sf)))
263 goto segv;
264
265 if (get_user(ufp, &sf->regs.u_regs[UREG_FP]))
266 goto segv;
267
268 if (ufp & 0x7)
269 goto segv;
270
271 if (__get_user(pc, &sf->regs.pc) ||
272 __get_user(npc, &sf->regs.npc))
273 goto segv;
274
275 if ((pc | npc) & 3)
276 goto segv;
277
278 if (test_thread_flag(TIF_32BIT)) {
279 pc &= 0xffffffff;
280 npc &= 0xffffffff;
281 }
282 regs->tpc = pc;
283 regs->tnpc = npc;
284
285 /* 2. Restore the state */
286 err = __get_user(regs->y, &sf->regs.y);
287 err |= __get_user(psr, &sf->regs.psr);
288
289 for (i = UREG_G1; i <= UREG_I7; i++)
290 err |= __get_user(regs->u_regs[i], &sf->regs.u_regs[i]);
291 if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) {
292 err |= __get_user(i, &sf->v8plus.g_upper[0]);
293 if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) {
294 unsigned long asi;
295
296 for (i = UREG_G1; i <= UREG_I7; i++)
297 err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
298 err |= __get_user(asi, &sf->v8plus.asi);
299 regs->tstate &= ~TSTATE_ASI;
300 regs->tstate |= ((asi & 0xffUL) << 24UL);
301 }
302 }
303
304 /* User can only change condition codes in %tstate. */
305 regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
306 regs->tstate |= psr_to_tstate_icc(psr);
307
308 /* Prevent syscall restart. */
309 pt_regs_clear_syscall(regs);
310
311 err |= __get_user(fpu_save, &sf->fpu_save);
312 if (!err && fpu_save)
313 err |= restore_fpu_state(regs, compat_ptr(fpu_save));
314 err |= get_compat_sigset(&set, &sf->mask);
315 err |= compat_restore_altstack(&sf->stack);
316 if (err)
317 goto segv;
318
319 err |= __get_user(rwin_save, &sf->rwin_save);
320 if (!err && rwin_save) {
321 if (restore_rwin_state(compat_ptr(rwin_save)))
322 goto segv;
323 }
324
325 set_current_blocked(&set);
326 return;
327 segv:
328 force_sig(SIGSEGV, current);
329 }
330
331 static void __user *get_sigframe(struct ksignal *ksig, struct pt_regs *regs, unsigned long framesize)
332 {
333 unsigned long sp;
334
335 regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
336 sp = regs->u_regs[UREG_FP];
337
338 /*
339 * If we are on the alternate signal stack and would overflow it, don't.
340 * Return an always-bogus address instead so we will die with SIGSEGV.
341 */
342 if (on_sig_stack(sp) && !likely(on_sig_stack(sp - framesize)))
343 return (void __user *) -1L;
344
345 /* This is the X/Open sanctioned signal stack switching. */
346 sp = sigsp(sp, ksig) - framesize;
347
348 /* Always align the stack frame. This handles two cases. First,
349 * sigaltstack need not be mindful of platform specific stack
350 * alignment. Second, if we took this signal because the stack
351 * is not aligned properly, we'd like to take the signal cleanly
352 * and report that.
353 */
354 sp &= ~15UL;
355
356 return (void __user *) sp;
357 }
358
359 /* The I-cache flush instruction only works in the primary ASI, which
360 * right now is the nucleus, aka. kernel space.
361 *
362 * Therefore we have to kick the instructions out using the kernel
363 * side linear mapping of the physical address backing the user
364 * instructions.
365 */
366 static void flush_signal_insns(unsigned long address)
367 {
368 unsigned long pstate, paddr;
369 pte_t *ptep, pte;
370 pgd_t *pgdp;
371 pud_t *pudp;
372 pmd_t *pmdp;
373
374 /* Commit all stores of the instructions we are about to flush. */
375 wmb();
376
377 /* Disable cross-call reception. In this way even a very wide
378 * munmap() on another cpu can't tear down the page table
379 * hierarchy from underneath us, since that can't complete
380 * until the IPI tlb flush returns.
381 */
382
383 __asm__ __volatile__("rdpr %%pstate, %0" : "=r" (pstate));
384 __asm__ __volatile__("wrpr %0, %1, %%pstate"
385 : : "r" (pstate), "i" (PSTATE_IE));
386
387 pgdp = pgd_offset(current->mm, address);
388 if (pgd_none(*pgdp))
389 goto out_irqs_on;
390 pudp = pud_offset(pgdp, address);
391 if (pud_none(*pudp))
392 goto out_irqs_on;
393 pmdp = pmd_offset(pudp, address);
394 if (pmd_none(*pmdp))
395 goto out_irqs_on;
396
397 ptep = pte_offset_map(pmdp, address);
398 pte = *ptep;
399 if (!pte_present(pte))
400 goto out_unmap;
401
402 paddr = (unsigned long) page_address(pte_page(pte));
403
404 __asm__ __volatile__("flush %0 + %1"
405 : /* no outputs */
406 : "r" (paddr),
407 "r" (address & (PAGE_SIZE - 1))
408 : "memory");
409
410 out_unmap:
411 pte_unmap(ptep);
412 out_irqs_on:
413 __asm__ __volatile__("wrpr %0, 0x0, %%pstate" : : "r" (pstate));
414
415 }
416
417 static int setup_frame32(struct ksignal *ksig, struct pt_regs *regs,
418 sigset_t *oldset)
419 {
420 struct signal_frame32 __user *sf;
421 int i, err, wsaved;
422 void __user *tail;
423 int sigframe_size;
424 u32 psr;
425 compat_sigset_t seta;
426
427 /* 1. Make sure everything is clean */
428 synchronize_user_stack();
429 save_and_clear_fpu();
430
431 wsaved = get_thread_wsaved();
432
433 sigframe_size = sizeof(*sf);
434 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
435 sigframe_size += sizeof(__siginfo_fpu_t);
436 if (wsaved)
437 sigframe_size += sizeof(__siginfo_rwin_t);
438
439 sf = (struct signal_frame32 __user *)
440 get_sigframe(ksig, regs, sigframe_size);
441
442 if (invalid_frame_pointer(sf, sigframe_size)) {
443 do_exit(SIGILL);
444 return -EINVAL;
445 }
446
447 tail = (sf + 1);
448
449 /* 2. Save the current process state */
450 if (test_thread_flag(TIF_32BIT)) {
451 regs->tpc &= 0xffffffff;
452 regs->tnpc &= 0xffffffff;
453 }
454 err = put_user(regs->tpc, &sf->info.si_regs.pc);
455 err |= __put_user(regs->tnpc, &sf->info.si_regs.npc);
456 err |= __put_user(regs->y, &sf->info.si_regs.y);
457 psr = tstate_to_psr(regs->tstate);
458 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
459 psr |= PSR_EF;
460 err |= __put_user(psr, &sf->info.si_regs.psr);
461 for (i = 0; i < 16; i++)
462 err |= __put_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]);
463 err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
464 err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
465 for (i = 1; i < 16; i++)
466 err |= __put_user(((u32 *)regs->u_regs)[2*i],
467 &sf->v8plus.g_upper[i]);
468 err |= __put_user((regs->tstate & TSTATE_ASI) >> 24UL,
469 &sf->v8plus.asi);
470
471 if (psr & PSR_EF) {
472 __siginfo_fpu_t __user *fp = tail;
473 tail += sizeof(*fp);
474 err |= save_fpu_state(regs, fp);
475 err |= __put_user((u64)fp, &sf->fpu_save);
476 } else {
477 err |= __put_user(0, &sf->fpu_save);
478 }
479 if (wsaved) {
480 __siginfo_rwin_t __user *rwp = tail;
481 tail += sizeof(*rwp);
482 err |= save_rwin_state(wsaved, rwp);
483 err |= __put_user((u64)rwp, &sf->rwin_save);
484 set_thread_wsaved(0);
485 } else {
486 err |= __put_user(0, &sf->rwin_save);
487 }
488
489 /* If these change we need to know - assignments to seta relies on these sizes */
490 BUILD_BUG_ON(_NSIG_WORDS != 1);
491 BUILD_BUG_ON(_COMPAT_NSIG_WORDS != 2);
492 seta.sig[1] = (oldset->sig[0] >> 32);
493 seta.sig[0] = oldset->sig[0];
494
495 err |= __put_user(seta.sig[0], &sf->info.si_mask);
496 err |= __copy_to_user(sf->extramask, &seta.sig[1],
497 (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
498
499 if (!wsaved) {
500 err |= copy_in_user((u32 __user *)sf,
501 (u32 __user *)(regs->u_regs[UREG_FP]),
502 sizeof(struct reg_window32));
503 } else {
504 struct reg_window *rp;
505
506 rp = &current_thread_info()->reg_window[wsaved - 1];
507 for (i = 0; i < 8; i++)
508 err |= __put_user(rp->locals[i], &sf->ss.locals[i]);
509 for (i = 0; i < 6; i++)
510 err |= __put_user(rp->ins[i], &sf->ss.ins[i]);
511 err |= __put_user(rp->ins[6], &sf->ss.fp);
512 err |= __put_user(rp->ins[7], &sf->ss.callers_pc);
513 }
514 if (err)
515 return err;
516
517 /* 3. signal handler back-trampoline and parameters */
518 regs->u_regs[UREG_FP] = (unsigned long) sf;
519 regs->u_regs[UREG_I0] = ksig->sig;
520 regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
521 regs->u_regs[UREG_I2] = (unsigned long) &sf->info;
522
523 /* 4. signal handler */
524 regs->tpc = (unsigned long) ksig->ka.sa.sa_handler;
525 regs->tnpc = (regs->tpc + 4);
526 if (test_thread_flag(TIF_32BIT)) {
527 regs->tpc &= 0xffffffff;
528 regs->tnpc &= 0xffffffff;
529 }
530
531 /* 5. return to kernel instructions */
532 if (ksig->ka.ka_restorer) {
533 regs->u_regs[UREG_I7] = (unsigned long)ksig->ka.ka_restorer;
534 } else {
535 unsigned long address = ((unsigned long)&(sf->insns[0]));
536
537 regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
538
539 err = __put_user(0x821020d8, &sf->insns[0]); /*mov __NR_sigreturn, %g1*/
540 err |= __put_user(0x91d02010, &sf->insns[1]); /*t 0x10*/
541 if (err)
542 return err;
543 flush_signal_insns(address);
544 }
545 return 0;
546 }
547
548 static int setup_rt_frame32(struct ksignal *ksig, struct pt_regs *regs,
549 sigset_t *oldset)
550 {
551 struct rt_signal_frame32 __user *sf;
552 int i, err, wsaved;
553 void __user *tail;
554 int sigframe_size;
555 u32 psr;
556
557 /* 1. Make sure everything is clean */
558 synchronize_user_stack();
559 save_and_clear_fpu();
560
561 wsaved = get_thread_wsaved();
562
563 sigframe_size = sizeof(*sf);
564 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
565 sigframe_size += sizeof(__siginfo_fpu_t);
566 if (wsaved)
567 sigframe_size += sizeof(__siginfo_rwin_t);
568
569 sf = (struct rt_signal_frame32 __user *)
570 get_sigframe(ksig, regs, sigframe_size);
571
572 if (invalid_frame_pointer(sf, sigframe_size)) {
573 do_exit(SIGILL);
574 return -EINVAL;
575 }
576
577 tail = (sf + 1);
578
579 /* 2. Save the current process state */
580 if (test_thread_flag(TIF_32BIT)) {
581 regs->tpc &= 0xffffffff;
582 regs->tnpc &= 0xffffffff;
583 }
584 err = put_user(regs->tpc, &sf->regs.pc);
585 err |= __put_user(regs->tnpc, &sf->regs.npc);
586 err |= __put_user(regs->y, &sf->regs.y);
587 psr = tstate_to_psr(regs->tstate);
588 if (current_thread_info()->fpsaved[0] & FPRS_FEF)
589 psr |= PSR_EF;
590 err |= __put_user(psr, &sf->regs.psr);
591 for (i = 0; i < 16; i++)
592 err |= __put_user(regs->u_regs[i], &sf->regs.u_regs[i]);
593 err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
594 err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
595 for (i = 1; i < 16; i++)
596 err |= __put_user(((u32 *)regs->u_regs)[2*i],
597 &sf->v8plus.g_upper[i]);
598 err |= __put_user((regs->tstate & TSTATE_ASI) >> 24UL,
599 &sf->v8plus.asi);
600
601 if (psr & PSR_EF) {
602 __siginfo_fpu_t __user *fp = tail;
603 tail += sizeof(*fp);
604 err |= save_fpu_state(regs, fp);
605 err |= __put_user((u64)fp, &sf->fpu_save);
606 } else {
607 err |= __put_user(0, &sf->fpu_save);
608 }
609 if (wsaved) {
610 __siginfo_rwin_t __user *rwp = tail;
611 tail += sizeof(*rwp);
612 err |= save_rwin_state(wsaved, rwp);
613 err |= __put_user((u64)rwp, &sf->rwin_save);
614 set_thread_wsaved(0);
615 } else {
616 err |= __put_user(0, &sf->rwin_save);
617 }
618
619 /* Update the siginfo structure. */
620 err |= copy_siginfo_to_user32(&sf->info, &ksig->info);
621
622 /* Setup sigaltstack */
623 err |= __compat_save_altstack(&sf->stack, regs->u_regs[UREG_FP]);
624
625 err |= put_compat_sigset(&sf->mask, oldset, sizeof(compat_sigset_t));
626
627 if (!wsaved) {
628 err |= copy_in_user((u32 __user *)sf,
629 (u32 __user *)(regs->u_regs[UREG_FP]),
630 sizeof(struct reg_window32));
631 } else {
632 struct reg_window *rp;
633
634 rp = &current_thread_info()->reg_window[wsaved - 1];
635 for (i = 0; i < 8; i++)
636 err |= __put_user(rp->locals[i], &sf->ss.locals[i]);
637 for (i = 0; i < 6; i++)
638 err |= __put_user(rp->ins[i], &sf->ss.ins[i]);
639 err |= __put_user(rp->ins[6], &sf->ss.fp);
640 err |= __put_user(rp->ins[7], &sf->ss.callers_pc);
641 }
642 if (err)
643 return err;
644
645 /* 3. signal handler back-trampoline and parameters */
646 regs->u_regs[UREG_FP] = (unsigned long) sf;
647 regs->u_regs[UREG_I0] = ksig->sig;
648 regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
649 regs->u_regs[UREG_I2] = (unsigned long) &sf->regs;
650
651 /* 4. signal handler */
652 regs->tpc = (unsigned long) ksig->ka.sa.sa_handler;
653 regs->tnpc = (regs->tpc + 4);
654 if (test_thread_flag(TIF_32BIT)) {
655 regs->tpc &= 0xffffffff;
656 regs->tnpc &= 0xffffffff;
657 }
658
659 /* 5. return to kernel instructions */
660 if (ksig->ka.ka_restorer)
661 regs->u_regs[UREG_I7] = (unsigned long)ksig->ka.ka_restorer;
662 else {
663 unsigned long address = ((unsigned long)&(sf->insns[0]));
664
665 regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
666
667 /* mov __NR_rt_sigreturn, %g1 */
668 err |= __put_user(0x82102065, &sf->insns[0]);
669
670 /* t 0x10 */
671 err |= __put_user(0x91d02010, &sf->insns[1]);
672 if (err)
673 return err;
674
675 flush_signal_insns(address);
676 }
677 return 0;
678 }
679
680 static inline void handle_signal32(struct ksignal *ksig,
681 struct pt_regs *regs)
682 {
683 sigset_t *oldset = sigmask_to_save();
684 int err;
685
686 if (ksig->ka.sa.sa_flags & SA_SIGINFO)
687 err = setup_rt_frame32(ksig, regs, oldset);
688 else
689 err = setup_frame32(ksig, regs, oldset);
690
691 signal_setup_done(err, ksig, 0);
692 }
693
694 static inline void syscall_restart32(unsigned long orig_i0, struct pt_regs *regs,
695 struct sigaction *sa)
696 {
697 switch (regs->u_regs[UREG_I0]) {
698 case ERESTART_RESTARTBLOCK:
699 case ERESTARTNOHAND:
700 no_system_call_restart:
701 regs->u_regs[UREG_I0] = EINTR;
702 regs->tstate |= TSTATE_ICARRY;
703 break;
704 case ERESTARTSYS:
705 if (!(sa->sa_flags & SA_RESTART))
706 goto no_system_call_restart;
707 /* fallthrough */
708 case ERESTARTNOINTR:
709 regs->u_regs[UREG_I0] = orig_i0;
710 regs->tpc -= 4;
711 regs->tnpc -= 4;
712 }
713 }
714
715 /* Note that 'init' is a special process: it doesn't get signals it doesn't
716 * want to handle. Thus you cannot kill init even with a SIGKILL even by
717 * mistake.
718 */
719 void do_signal32(struct pt_regs * regs)
720 {
721 struct ksignal ksig;
722 unsigned long orig_i0 = 0;
723 int restart_syscall = 0;
724 bool has_handler = get_signal(&ksig);
725
726 if (pt_regs_is_syscall(regs) &&
727 (regs->tstate & (TSTATE_XCARRY | TSTATE_ICARRY))) {
728 restart_syscall = 1;
729 orig_i0 = regs->u_regs[UREG_G6];
730 }
731
732 if (has_handler) {
733 if (restart_syscall)
734 syscall_restart32(orig_i0, regs, &ksig.ka.sa);
735 handle_signal32(&ksig, regs);
736 } else {
737 if (restart_syscall) {
738 switch (regs->u_regs[UREG_I0]) {
739 case ERESTARTNOHAND:
740 case ERESTARTSYS:
741 case ERESTARTNOINTR:
742 /* replay the system call when we are done */
743 regs->u_regs[UREG_I0] = orig_i0;
744 regs->tpc -= 4;
745 regs->tnpc -= 4;
746 pt_regs_clear_syscall(regs);
747 case ERESTART_RESTARTBLOCK:
748 regs->u_regs[UREG_G1] = __NR_restart_syscall;
749 regs->tpc -= 4;
750 regs->tnpc -= 4;
751 pt_regs_clear_syscall(regs);
752 }
753 }
754 restore_saved_sigmask();
755 }
756 }
757
758 struct sigstack32 {
759 u32 the_stack;
760 int cur_status;
761 };
762
763 asmlinkage int do_sys32_sigstack(u32 u_ssptr, u32 u_ossptr, unsigned long sp)
764 {
765 struct sigstack32 __user *ssptr =
766 (struct sigstack32 __user *)((unsigned long)(u_ssptr));
767 struct sigstack32 __user *ossptr =
768 (struct sigstack32 __user *)((unsigned long)(u_ossptr));
769 int ret = -EFAULT;
770
771 /* First see if old state is wanted. */
772 if (ossptr) {
773 if (put_user(current->sas_ss_sp + current->sas_ss_size,
774 &ossptr->the_stack) ||
775 __put_user(on_sig_stack(sp), &ossptr->cur_status))
776 goto out;
777 }
778
779 /* Now see if we want to update the new state. */
780 if (ssptr) {
781 u32 ss_sp;
782
783 if (get_user(ss_sp, &ssptr->the_stack))
784 goto out;
785
786 /* If the current stack was set with sigaltstack, don't
787 * swap stacks while we are on it.
788 */
789 ret = -EPERM;
790 if (current->sas_ss_sp && on_sig_stack(sp))
791 goto out;
792
793 /* Since we don't know the extent of the stack, and we don't
794 * track onstack-ness, but rather calculate it, we must
795 * presume a size. Ho hum this interface is lossy.
796 */
797 current->sas_ss_sp = (unsigned long)ss_sp - SIGSTKSZ;
798 current->sas_ss_size = SIGSTKSZ;
799 }
800
801 ret = 0;
802 out:
803 return ret;
804 }
Ubuntu Jammy Linux kernel mirror