]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - arch/x86/kernel/signal.c
projects / mirror_ubuntu-bionic-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mszeredi...
[mirror_ubuntu-bionic-kernel.git] / arch / x86 / kernel / signal.c
CommitLineData
1da177e4 1/*
1da177e4 2 * Copyright (C) 1991, 1992 Linus Torvalds
e5fa2d06 3 * Copyright (C) 2000, 2001, 2002 Andi Kleen SuSE Labs
1da177e4
LT		 4 *
5 * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson
6 * 2000-06-20 Pentium III FXSR, SSE support by Gareth Hughes
e5fa2d06 7 * 2000-2002 x86-64 support by Andi Kleen
1da177e4 8 */
5c9b3a0c
HS		 9#include <linux/sched.h>
10#include <linux/mm.h>
11#include <linux/smp.h>
1da177e4 12#include <linux/kernel.h>
1da177e4
LT		 13#include <linux/errno.h>
14#include <linux/wait.h>
36a03308 15#include <linux/tracehook.h>
5c9b3a0c
HS		 16#include <linux/unistd.h>
17#include <linux/stddef.h>
18#include <linux/personality.h>
19#include <linux/uaccess.h>
7c68af6e 20#include <linux/user-return-notifier.h>
0326f5a9 21#include <linux/uprobes.h>
7e907f48 22
1da177e4
LT		 23#include <asm/processor.h>
24#include <asm/ucontext.h>
1da177e4 25#include <asm/i387.h>
1361b83a 26#include <asm/fpu-internal.h>
6c3652ef 27#include <asm/vdso.h>
4efc0670 28#include <asm/mce.h>
f28f0c23 29#include <asm/sighandling.h>
5c9b3a0c
HS		 30
31#ifdef CONFIG_X86_64
32#include <asm/proto.h>
33#include <asm/ia32_unistd.h>
c5a37394 34#include <asm/sys_ia32.h>
5c9b3a0c
HS		 35#endif /* CONFIG_X86_64 */
36
bb57925f 37#include <asm/syscall.h>
bbc1f698 38#include <asm/syscalls.h>
7e907f48 39
41af86fa 40#include <asm/sigframe.h>
1da177e4 41
1a176803
HH		 42#ifdef CONFIG_X86_32
43# define FIX_EFLAGS (__FIX_EFLAGS | X86_EFLAGS_RF)
44#else
45# define FIX_EFLAGS __FIX_EFLAGS
46#endif
47
d9a89a26
TH		 48#define COPY(x) do { \
49 get_user_ex(regs->x, &sc->x); \
50} while (0)
2601657d 51
d9a89a26
TH		 52#define GET_SEG(seg) ({ \
53 unsigned short tmp; \
54 get_user_ex(tmp, &sc->seg); \
55 tmp; \
56})
2601657d 57
d9a89a26
TH		 58#define COPY_SEG(seg) do { \
59 regs->seg = GET_SEG(seg); \
60} while (0)
2601657d 61
d9a89a26
TH		 62#define COPY_SEG_CPL3(seg) do { \
63 regs->seg = GET_SEG(seg) | 3; \
64} while (0)
2601657d 65
85139422
PA		 66int restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc,
67 unsigned long *pax)
2601657d
HS		 68{
69 void __user *buf;
70 unsigned int tmpflags;
71 unsigned int err = 0;
72
73 /* Always make any pending restarted system calls return -EINTR */
74 current_thread_info()->restart_block.fn = do_no_restart_syscall;
75
98e3d45e
HS		 76 get_user_try {
77
2601657d 78#ifdef CONFIG_X86_32
d9a89a26 79 set_user_gs(regs, GET_SEG(gs));
98e3d45e
HS		 80 COPY_SEG(fs);
81 COPY_SEG(es);
82 COPY_SEG(ds);
2601657d
HS		 83#endif /* CONFIG_X86_32 */
84
98e3d45e
HS		 85 COPY(di); COPY(si); COPY(bp); COPY(sp); COPY(bx);
86 COPY(dx); COPY(cx); COPY(ip);
2601657d
HS		 87
88#ifdef CONFIG_X86_64
98e3d45e
HS		 89 COPY(r8);
90 COPY(r9);
91 COPY(r10);
92 COPY(r11);
93 COPY(r12);
94 COPY(r13);
95 COPY(r14);
96 COPY(r15);
2601657d
HS		 97#endif /* CONFIG_X86_64 */
98
99#ifdef CONFIG_X86_32
98e3d45e
HS		 100 COPY_SEG_CPL3(cs);
101 COPY_SEG_CPL3(ss);
2601657d 102#else /* !CONFIG_X86_32 */
98e3d45e
HS		 103 /* Kernel saves and restores only the CS segment register on signals,
104 * which is the bare minimum needed to allow mixed 32/64-bit code.
105 * App's signal handler can save/restore other segments if needed. */
106 COPY_SEG_CPL3(cs);
2601657d
HS		 107#endif /* CONFIG_X86_32 */
108
98e3d45e
HS		 109 get_user_ex(tmpflags, &sc->flags);
110 regs->flags = (regs->flags & ~FIX_EFLAGS) | (tmpflags & FIX_EFLAGS);
111 regs->orig_ax = -1; /* disable syscall checks */
112
113 get_user_ex(buf, &sc->fpstate);
114 err |= restore_i387_xstate(buf);
2601657d 115
98e3d45e
HS		 116 get_user_ex(*pax, &sc->ax);
117 } get_user_catch(err);
2601657d 118
2601657d
HS		 119 return err;
120}
121
85139422
PA		 122int setup_sigcontext(struct sigcontext __user *sc, void __user *fpstate,
123 struct pt_regs *regs, unsigned long mask)
2601657d
HS		 124{
125 int err = 0;
126
98e3d45e 127 put_user_try {
2601657d 128
98e3d45e 129#ifdef CONFIG_X86_32
d9a89a26 130 put_user_ex(get_user_gs(regs), (unsigned int __user *)&sc->gs);
98e3d45e
HS		 131 put_user_ex(regs->fs, (unsigned int __user *)&sc->fs);
132 put_user_ex(regs->es, (unsigned int __user *)&sc->es);
133 put_user_ex(regs->ds, (unsigned int __user *)&sc->ds);
2601657d
HS		 134#endif /* CONFIG_X86_32 */
135
98e3d45e
HS		 136 put_user_ex(regs->di, &sc->di);
137 put_user_ex(regs->si, &sc->si);
138 put_user_ex(regs->bp, &sc->bp);
139 put_user_ex(regs->sp, &sc->sp);
140 put_user_ex(regs->bx, &sc->bx);
141 put_user_ex(regs->dx, &sc->dx);
142 put_user_ex(regs->cx, &sc->cx);
143 put_user_ex(regs->ax, &sc->ax);
2601657d 144#ifdef CONFIG_X86_64
98e3d45e
HS		 145 put_user_ex(regs->r8, &sc->r8);
146 put_user_ex(regs->r9, &sc->r9);
147 put_user_ex(regs->r10, &sc->r10);
148 put_user_ex(regs->r11, &sc->r11);
149 put_user_ex(regs->r12, &sc->r12);
150 put_user_ex(regs->r13, &sc->r13);
151 put_user_ex(regs->r14, &sc->r14);
152 put_user_ex(regs->r15, &sc->r15);
2601657d
HS		 153#endif /* CONFIG_X86_64 */
154
51e7dc70 155 put_user_ex(current->thread.trap_nr, &sc->trapno);
98e3d45e
HS		 156 put_user_ex(current->thread.error_code, &sc->err);
157 put_user_ex(regs->ip, &sc->ip);
2601657d 158#ifdef CONFIG_X86_32
98e3d45e
HS		 159 put_user_ex(regs->cs, (unsigned int __user *)&sc->cs);
160 put_user_ex(regs->flags, &sc->flags);
161 put_user_ex(regs->sp, &sc->sp_at_signal);
162 put_user_ex(regs->ss, (unsigned int __user *)&sc->ss);
2601657d 163#else /* !CONFIG_X86_32 */
98e3d45e
HS		 164 put_user_ex(regs->flags, &sc->flags);
165 put_user_ex(regs->cs, &sc->cs);
166 put_user_ex(0, &sc->gs);
167 put_user_ex(0, &sc->fs);
2601657d
HS		 168#endif /* CONFIG_X86_32 */
169
98e3d45e 170 put_user_ex(fpstate, &sc->fpstate);
2601657d 171
98e3d45e
HS		 172 /* non-iBCS2 extensions.. */
173 put_user_ex(mask, &sc->oldmask);
174 put_user_ex(current->thread.cr2, &sc->cr2);
175 } put_user_catch(err);
2601657d
HS		 176
177 return err;
178}
179
1da177e4 180/*
bfeb91a9 181 * Set up a signal frame.
1da177e4 182 */
1da177e4
LT		 183
184/*
185 * Determine which stack to use..
186 */
1fae0279
HS		 187static unsigned long align_sigframe(unsigned long sp)
188{
189#ifdef CONFIG_X86_32
190 /*
191 * Align the stack pointer according to the i386 ABI,
192 * i.e. so that on function entry ((sp + 4) & 15) == 0.
193 */
194 sp = ((sp + 4) & -16ul) - 4;
195#else /* !CONFIG_X86_32 */
196 sp = round_down(sp, 16) - 8;
197#endif
198 return sp;
199}
200
1da177e4 201static inline void __user *
3c1c7f10 202get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, size_t frame_size,
144b0712 203 void __user **fpstate)
1da177e4 204{
1da177e4 205 /* Default to using normal stack */
75779f05 206 unsigned long sp = regs->sp;
14fc9fbc 207 int onsigstack = on_sig_stack(sp);
75779f05
HS		 208
209#ifdef CONFIG_X86_64
210 /* redzone */
211 sp -= 128;
212#endif /* CONFIG_X86_64 */
1da177e4 213
14fc9fbc
HS		 214 if (!onsigstack) {
215 /* This is the X/Open sanctioned signal stack switching. */
216 if (ka->sa.sa_flags & SA_ONSTACK) {
0f8f3089 217 if (current->sas_ss_size)
14fc9fbc
HS		 218 sp = current->sas_ss_sp + current->sas_ss_size;
219 } else {
75779f05 220#ifdef CONFIG_X86_32
14fc9fbc
HS		 221 /* This is the legacy signal stack switching. */
222 if ((regs->ss & 0xffff) != __USER_DS &&
223 !(ka->sa.sa_flags & SA_RESTORER) &&
224 ka->sa.sa_restorer)
225 sp = (unsigned long) ka->sa.sa_restorer;
75779f05 226#endif /* CONFIG_X86_32 */
14fc9fbc 227 }
1da177e4
LT		 228 }
229
3c1c7f10 230 if (used_math()) {
75779f05 231 sp -= sig_xstate_size;
25051702
HS		 232#ifdef CONFIG_X86_64
233 sp = round_down(sp, 64);
234#endif /* CONFIG_X86_64 */
235 *fpstate = (void __user *)sp;
3c1c7f10
SS		 236 }
237
14fc9fbc
HS		 238 sp = align_sigframe(sp - frame_size);
239
240 /*
241 * If we are on the alternate signal stack and would overflow it, don't.
242 * Return an always-bogus address instead so we will die with SIGSEGV.
243 */
244 if (onsigstack && !likely(on_sig_stack(sp)))
245 return (void __user *)-1L;
246
247 /* save i387 state */
248 if (used_math() && save_i387_xstate(*fpstate) < 0)
249 return (void __user *)-1L;
250
251 return (void __user *)sp;
1da177e4
LT		 252}
253
75779f05
HS		 254#ifdef CONFIG_X86_32
255static const struct {
256 u16 poplmovl;
257 u32 val;
258 u16 int80;
259} __attribute__((packed)) retcode = {
260 0xb858, /* popl %eax; movl $..., %eax */
261 __NR_sigreturn,
262 0x80cd, /* int $0x80 */
263};
264
265static const struct {
266 u8 movl;
267 u32 val;
268 u16 int80;
269 u8 pad;
270} __attribute__((packed)) rt_retcode = {
271 0xb8, /* movl $..., %eax */
272 __NR_rt_sigreturn,
273 0x80cd, /* int $0x80 */
274 0
275};
276
7e907f48 277static int
1d13024e
HS		 278__setup_frame(int sig, struct k_sigaction *ka, sigset_t *set,
279 struct pt_regs *regs)
1da177e4 280{
1da177e4 281 struct sigframe __user *frame;
7e907f48 282 void __user *restorer;
1da177e4 283 int err = 0;
ab513701 284 void __user *fpstate = NULL;
1da177e4 285
3c1c7f10 286 frame = get_sigframe(ka, regs, sizeof(*frame), &fpstate);
1da177e4
LT		 287
288 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
3d0aedd9 289 return -EFAULT;
1da177e4 290
2ba48e16 291 if (__put_user(sig, &frame->sig))
3d0aedd9 292 return -EFAULT;
1da177e4 293
2ba48e16 294 if (setup_sigcontext(&frame->sc, fpstate, regs, set->sig[0]))
3d0aedd9 295 return -EFAULT;
1da177e4
LT		 296
297 if (_NSIG_WORDS > 1) {
2ba48e16
HS		 298 if (__copy_to_user(&frame->extramask, &set->sig[1],
299 sizeof(frame->extramask)))
3d0aedd9 300 return -EFAULT;
1da177e4
LT		 301 }
302
1a3e4ca4 303 if (current->mm->context.vdso)
6c3652ef 304 restorer = VDSO32_SYMBOL(current->mm->context.vdso, sigreturn);
9fbbd4dd 305 else
ade1af77 306 restorer = &frame->retcode;
1da177e4
LT		 307 if (ka->sa.sa_flags & SA_RESTORER)
308 restorer = ka->sa.sa_restorer;
309
310 /* Set up to return from userspace. */
311 err |= __put_user(restorer, &frame->pretcode);
7e907f48 312
1da177e4 313 /*
7e907f48 314 * This is popl %eax ; movl $__NR_sigreturn, %eax ; int $0x80
1da177e4
LT		 315 *
316 * WE DO NOT USE IT ANY MORE! It's only left here for historical
317 * reasons and because gdb uses it as a signature to notice
318 * signal handler stack frames.
319 */
4a612048 320 err |= __put_user(*((u64 *)&retcode), (u64 *)frame->retcode);
1da177e4
LT		 321
322 if (err)
3d0aedd9 323 return -EFAULT;
1da177e4
LT		 324
325 /* Set up registers for signal handler */
7e907f48
IM		 326 regs->sp = (unsigned long)frame;
327 regs->ip = (unsigned long)ka->sa.sa_handler;
328 regs->ax = (unsigned long)sig;
92bc2056
HH		 329 regs->dx = 0;
330 regs->cx = 0;
1da177e4 331
65ea5b03
PA		 332 regs->ds = __USER_DS;
333 regs->es = __USER_DS;
334 regs->ss = __USER_DS;
335 regs->cs = __USER_CS;
1da177e4 336
283828f3 337 return 0;
1da177e4
LT		 338}
339
1d13024e
HS		 340static int __setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
341 sigset_t *set, struct pt_regs *regs)
1da177e4 342{
1da177e4 343 struct rt_sigframe __user *frame;
7e907f48 344 void __user *restorer;
1da177e4 345 int err = 0;
ab513701 346 void __user *fpstate = NULL;
1da177e4 347
3c1c7f10 348 frame = get_sigframe(ka, regs, sizeof(*frame), &fpstate);
1da177e4
LT		 349
350 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
3d0aedd9 351 return -EFAULT;
1da177e4 352
98e3d45e
HS		 353 put_user_try {
354 put_user_ex(sig, &frame->sig);
355 put_user_ex(&frame->info, &frame->pinfo);
356 put_user_ex(&frame->uc, &frame->puc);
357 err |= copy_siginfo_to_user(&frame->info, info);
358
359 /* Create the ucontext. */
360 if (cpu_has_xsave)
361 put_user_ex(UC_FP_XSTATE, &frame->uc.uc_flags);
362 else
363 put_user_ex(0, &frame->uc.uc_flags);
364 put_user_ex(0, &frame->uc.uc_link);
365 put_user_ex(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
366 put_user_ex(sas_ss_flags(regs->sp),
367 &frame->uc.uc_stack.ss_flags);
368 put_user_ex(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
369 err |= setup_sigcontext(&frame->uc.uc_mcontext, fpstate,
370 regs, set->sig[0]);
371 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
372
373 /* Set up to return from userspace. */
374 restorer = VDSO32_SYMBOL(current->mm->context.vdso, rt_sigreturn);
375 if (ka->sa.sa_flags & SA_RESTORER)
376 restorer = ka->sa.sa_restorer;
377 put_user_ex(restorer, &frame->pretcode);
378
379 /*
380 * This is movl $__NR_rt_sigreturn, %ax ; int $0x80
381 *
382 * WE DO NOT USE IT ANY MORE! It's only left here for historical
383 * reasons and because gdb uses it as a signature to notice
384 * signal handler stack frames.
385 */
386 put_user_ex(*((u64 *)&rt_retcode), (u64 *)frame->retcode);
387 } put_user_catch(err);
1da177e4
LT		 388
389 if (err)
3d0aedd9 390 return -EFAULT;
1da177e4
LT		 391
392 /* Set up registers for signal handler */
7e907f48
IM		 393 regs->sp = (unsigned long)frame;
394 regs->ip = (unsigned long)ka->sa.sa_handler;
13ad7725 395 regs->ax = (unsigned long)sig;
7e907f48
IM		 396 regs->dx = (unsigned long)&frame->info;
397 regs->cx = (unsigned long)&frame->uc;
1da177e4 398
65ea5b03
PA		 399 regs->ds = __USER_DS;
400 regs->es = __USER_DS;
401 regs->ss = __USER_DS;
402 regs->cs = __USER_CS;
1da177e4 403
283828f3 404 return 0;
1da177e4 405}
bfeb91a9 406#else /* !CONFIG_X86_32 */
bfeb91a9
HS		 407static int __setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
408 sigset_t *set, struct pt_regs *regs)
409{
410 struct rt_sigframe __user *frame;
411 void __user *fp = NULL;
412 int err = 0;
413 struct task_struct *me = current;
414
97286a2b 415 frame = get_sigframe(ka, regs, sizeof(struct rt_sigframe), &fp);
bfeb91a9
HS		 416
417 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
418 return -EFAULT;
419
420 if (ka->sa.sa_flags & SA_SIGINFO) {
421 if (copy_siginfo_to_user(&frame->info, info))
422 return -EFAULT;
423 }
424
98e3d45e
HS		 425 put_user_try {
426 /* Create the ucontext. */
427 if (cpu_has_xsave)
428 put_user_ex(UC_FP_XSTATE, &frame->uc.uc_flags);
429 else
430 put_user_ex(0, &frame->uc.uc_flags);
431 put_user_ex(0, &frame->uc.uc_link);
432 put_user_ex(me->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
433 put_user_ex(sas_ss_flags(regs->sp),
434 &frame->uc.uc_stack.ss_flags);
435 put_user_ex(me->sas_ss_size, &frame->uc.uc_stack.ss_size);
436 err |= setup_sigcontext(&frame->uc.uc_mcontext, fp, regs, set->sig[0]);
437 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
438
439 /* Set up to return from userspace. If provided, use a stub
440 already in userspace. */
441 /* x86-64 should always use SA_RESTORER. */
442 if (ka->sa.sa_flags & SA_RESTORER) {
443 put_user_ex(ka->sa.sa_restorer, &frame->pretcode);
444 } else {
445 /* could use a vstub here */
446 err |= -EFAULT;
447 }
448 } put_user_catch(err);
bfeb91a9
HS		 449
450 if (err)
451 return -EFAULT;
452
453 /* Set up registers for signal handler */
454 regs->di = sig;
455 /* In case the signal handler was declared without prototypes */
456 regs->ax = 0;
457
458 /* This also works for non SA_SIGINFO handlers because they expect the
459 next argument after the signal number on the stack. */
460 regs->si = (unsigned long)&frame->info;
461 regs->dx = (unsigned long)&frame->uc;
462 regs->ip = (unsigned long) ka->sa.sa_handler;
463
464 regs->sp = (unsigned long)frame;
465
466 /* Set up the CS register to run signal handlers in 64-bit mode,
467 even if the handler happens to be interrupting 32-bit code. */
468 regs->cs = __USER_CS;
469
470 return 0;
471}
472#endif /* CONFIG_X86_32 */
473
e5fa2d06 474#ifdef CONFIG_X86_32
bfeb91a9
HS		 475/*
476 * Atomically swap in the new signal mask, and wait for a signal.
477 */
478asmlinkage int
479sys_sigsuspend(int history0, int history1, old_sigset_t mask)
480{
3982294b 481 sigset_t blocked;
3982294b 482 siginitset(&blocked, mask);
68f3f16d 483 return sigsuspend(&blocked);
bfeb91a9
HS		 484}
485
486asmlinkage int
487sys_sigaction(int sig, const struct old_sigaction __user *act,
488 struct old_sigaction __user *oact)
489{
490 struct k_sigaction new_ka, old_ka;
98e3d45e 491 int ret = 0;
bfeb91a9
HS		 492
493 if (act) {
494 old_sigset_t mask;
495
98e3d45e 496 if (!access_ok(VERIFY_READ, act, sizeof(*act)))
bfeb91a9
HS		 497 return -EFAULT;
498
98e3d45e
HS		 499 get_user_try {
500 get_user_ex(new_ka.sa.sa_handler, &act->sa_handler);
501 get_user_ex(new_ka.sa.sa_flags, &act->sa_flags);
502 get_user_ex(mask, &act->sa_mask);
503 get_user_ex(new_ka.sa.sa_restorer, &act->sa_restorer);
504 } get_user_catch(ret);
505
506 if (ret)
507 return -EFAULT;
bfeb91a9
HS		 508 siginitset(&new_ka.sa.sa_mask, mask);
509 }
510
511 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
512
513 if (!ret && oact) {
98e3d45e 514 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
bfeb91a9
HS		 515 return -EFAULT;
516
98e3d45e
HS		 517 put_user_try {
518 put_user_ex(old_ka.sa.sa_handler, &oact->sa_handler);
519 put_user_ex(old_ka.sa.sa_flags, &oact->sa_flags);
520 put_user_ex(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
521 put_user_ex(old_ka.sa.sa_restorer, &oact->sa_restorer);
522 } put_user_catch(ret);
523
524 if (ret)
525 return -EFAULT;
bfeb91a9
HS		 526 }
527
528 return ret;
529}
e5fa2d06 530#endif /* CONFIG_X86_32 */
bfeb91a9 531
052acad4 532long
bfeb91a9
HS		 533sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss,
534 struct pt_regs *regs)
535{
536 return do_sigaltstack(uss, uoss, regs->sp);
537}
bfeb91a9
HS		 538
539/*
540 * Do a signal return; undo the signal stack.
541 */
e5fa2d06 542#ifdef CONFIG_X86_32
b12bdaf1 543unsigned long sys_sigreturn(struct pt_regs *regs)
bfeb91a9
HS		 544{
545 struct sigframe __user *frame;
bfeb91a9
HS		 546 unsigned long ax;
547 sigset_t set;
548
bfeb91a9
HS		 549 frame = (struct sigframe __user *)(regs->sp - 8);
550
551 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
552 goto badframe;
553 if (__get_user(set.sig[0], &frame->sc.oldmask) || (_NSIG_WORDS > 1
554 && __copy_from_user(&set.sig[1], &frame->extramask,
555 sizeof(frame->extramask))))
556 goto badframe;
557
3982294b 558 set_current_blocked(&set);
bfeb91a9
HS		 559
560 if (restore_sigcontext(regs, &frame->sc, &ax))
561 goto badframe;
562 return ax;
563
564badframe:
ae417bb4 565 signal_fault(regs, frame, "sigreturn");
bfeb91a9
HS		 566
567 return 0;
568}
e5fa2d06 569#endif /* CONFIG_X86_32 */
bfeb91a9 570
74452509 571long sys_rt_sigreturn(struct pt_regs *regs)
bfeb91a9
HS		 572{
573 struct rt_sigframe __user *frame;
574 unsigned long ax;
575 sigset_t set;
576
577 frame = (struct rt_sigframe __user *)(regs->sp - sizeof(long));
578 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
579 goto badframe;
580 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
581 goto badframe;
582
e9bd3f0f 583 set_current_blocked(&set);
bfeb91a9
HS		 584
585 if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &ax))
586 goto badframe;
587
588 if (do_sigaltstack(&frame->uc.uc_stack, NULL, regs->sp) == -EFAULT)
589 goto badframe;
590
591 return ax;
592
593badframe:
594 signal_fault(regs, frame, "rt_sigreturn");
595 return 0;
596}
597
1da177e4 598/*
7e907f48
IM		 599 * OK, we're invoking a handler:
600 */
8d8c13bd
HS		 601static int signr_convert(int sig)
602{
96bf84b7 603#ifdef CONFIG_X86_32
8d8c13bd
HS		 604 struct thread_info *info = current_thread_info();
605
606 if (info->exec_domain && info->exec_domain->signal_invmap && sig < 32)
607 return info->exec_domain->signal_invmap[sig];
96bf84b7 608#endif /* CONFIG_X86_32 */
8d8c13bd
HS		 609 return sig;
610}
611
cabf5035
HS		 612#ifdef CONFIG_X86_32
613
455edbc4 614#define is_ia32 1
4694d239
HS		 615#define ia32_setup_frame __setup_frame
616#define ia32_setup_rt_frame __setup_rt_frame
455edbc4 617
cabf5035
HS		 618#else /* !CONFIG_X86_32 */
619
620#ifdef CONFIG_IA32_EMULATION
621#define is_ia32 test_thread_flag(TIF_IA32)
622#else /* !CONFIG_IA32_EMULATION */
623#define is_ia32 0
624#endif /* CONFIG_IA32_EMULATION */
625
c5a37394
PA		 626#ifdef CONFIG_X86_X32_ABI
627#define is_x32 test_thread_flag(TIF_X32)
628
629static int x32_setup_rt_frame(int sig, struct k_sigaction *ka,
630 siginfo_t *info, compat_sigset_t *set,
631 struct pt_regs *regs);
632#else /* !CONFIG_X86_X32_ABI */
633#define is_x32 0
634#endif /* CONFIG_X86_X32_ABI */
635
f5223763
HS		 636int ia32_setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
637 sigset_t *set, struct pt_regs *regs);
638int ia32_setup_frame(int sig, struct k_sigaction *ka,
639 sigset_t *set, struct pt_regs *regs);
640
cabf5035
HS		 641#endif /* CONFIG_X86_32 */
642
1d13024e
HS		 643static int
644setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
9b429620 645 struct pt_regs *regs)
1d13024e 646{
8d8c13bd 647 int usig = signr_convert(sig);
b7f9a11a 648 sigset_t *set = sigmask_to_save();
1d13024e
HS		 649
650 /* Set up the stack frame */
455edbc4
HS		 651 if (is_ia32) {
652 if (ka->sa.sa_flags & SA_SIGINFO)
a610d6e6 653 return ia32_setup_rt_frame(usig, ka, info, set, regs);
455edbc4 654 else
a610d6e6 655 return ia32_setup_frame(usig, ka, set, regs);
c5a37394
PA		 656#ifdef CONFIG_X86_X32_ABI
657 } else if (is_x32) {
a610d6e6 658 return x32_setup_rt_frame(usig, ka, info,
c5a37394
PA		 659 (compat_sigset_t *)set, regs);
660#endif
661 } else {
a610d6e6 662 return __setup_rt_frame(sig, ka, info, set, regs);
c5a37394 663 }
1d13024e
HS		 664}
665
a610d6e6 666static void
1da177e4 667handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
9b429620 668 struct pt_regs *regs)
1da177e4
LT		 669{
670 /* Are we from a system call? */
bb57925f 671 if (syscall_get_nr(current, regs) >= 0) {
1da177e4 672 /* If so, check system call restarting.. */
bb57925f 673 switch (syscall_get_error(current, regs)) {
ac66f3fd
HH		 674 case -ERESTART_RESTARTBLOCK:
675 case -ERESTARTNOHAND:
676 regs->ax = -EINTR;
677 break;
678
679 case -ERESTARTSYS:
680 if (!(ka->sa.sa_flags & SA_RESTART)) {
65ea5b03 681 regs->ax = -EINTR;
1da177e4 682 break;
ac66f3fd
HH		 683 }
684 /* fallthrough */
685 case -ERESTARTNOINTR:
686 regs->ax = regs->orig_ax;
687 regs->ip -= 2;
688 break;
1da177e4
LT		 689 }
690 }
691
692 /*
e1f28773
RM		 693 * If TF is set due to a debugger (TIF_FORCED_TF), clear the TF
694 * flag so that register information in the sigcontext is correct.
1da177e4 695 */
65ea5b03 696 if (unlikely(regs->flags & X86_EFLAGS_TF) &&
e1f28773 697 likely(test_and_clear_thread_flag(TIF_FORCED_TF)))
65ea5b03 698 regs->flags &= ~X86_EFLAGS_TF;
1da177e4 699
a610d6e6
AV		 700 if (setup_rt_frame(sig, ka, info, regs) < 0) {
701 force_sigsegv(sig, current);
702 return;
703 }
7c1def16 704
8b9c5ff3
RM		 705 /*
706 * Clear the direction flag as per the ABI for function entry.
707 */
708 regs->flags &= ~X86_EFLAGS_DF;
709
710 /*
711 * Clear TF when entering the signal handler, but
712 * notify any tracer that was single-stepping it.
713 * The tracer may want to single-step inside the
714 * handler too.
715 */
716 regs->flags &= ~X86_EFLAGS_TF;
8b9c5ff3 717
efee984c
AV		 718 signal_delivered(sig, info, ka, regs,
719 test_thread_flag(TIF_SINGLESTEP));
1da177e4
LT		 720}
721
57917752 722#ifdef CONFIG_X86_32
8fcd8e20 723#define NR_restart_syscall __NR_restart_syscall
57917752
HS		 724#else /* !CONFIG_X86_32 */
725#define NR_restart_syscall \
726 test_thread_flag(TIF_IA32) ? __NR_ia32_restart_syscall : __NR_restart_syscall
727#endif /* CONFIG_X86_32 */
728
1da177e4
LT		 729/*
730 * Note that 'init' is a special process: it doesn't get signals it doesn't
731 * want to handle. Thus you cannot kill init even with a SIGKILL even by
732 * mistake.
733 */
75604d7f 734static void do_signal(struct pt_regs *regs)
1da177e4 735{
ac66f3fd 736 struct k_sigaction ka;
1da177e4
LT		 737 siginfo_t info;
738 int signr;
1da177e4 739
1da177e4
LT		 740 signr = get_signal_to_deliver(&info, &ka, regs, NULL);
741 if (signr > 0) {
7e907f48 742 /* Whee! Actually deliver the signal. */
9b429620 743 handle_signal(signr, &info, &ka, regs);
283828f3 744 return;
1da177e4
LT		 745 }
746
1da177e4 747 /* Did we come from a system call? */
bb57925f 748 if (syscall_get_nr(current, regs) >= 0) {
1da177e4 749 /* Restart the system call - no handlers present */
bb57925f 750 switch (syscall_get_error(current, regs)) {
283828f3
DH		 751 case -ERESTARTNOHAND:
752 case -ERESTARTSYS:
753 case -ERESTARTNOINTR:
65ea5b03
PA		 754 regs->ax = regs->orig_ax;
755 regs->ip -= 2;
283828f3
DH		 756 break;
757
758 case -ERESTART_RESTARTBLOCK:
8fcd8e20 759 regs->ax = NR_restart_syscall;
65ea5b03 760 regs->ip -= 2;
283828f3 761 break;
1da177e4
LT		 762 }
763 }
283828f3 764
ac66f3fd
HH		 765 /*
766 * If there's no signal to deliver, we just put the saved sigmask
767 * back.
768 */
51a7b448 769 restore_saved_sigmask();
1da177e4
LT		 770}
771
772/*
773 * notification of userspace execution resumption
283828f3 774 * - triggered by the TIF_WORK_MASK flags
1da177e4 775 */
7e907f48
IM		 776void
777do_notify_resume(struct pt_regs *regs, void *unused, __u32 thread_info_flags)
1da177e4 778{
c1ebf835 779#ifdef CONFIG_X86_MCE
ee847c54
HS		 780 /* notify userspace of pending MCEs */
781 if (thread_info_flags & _TIF_MCE_NOTIFY)
9b1beaf2 782 mce_notify_process();
ee847c54
HS		 783#endif /* CONFIG_X86_64 && CONFIG_X86_MCE */
784
0326f5a9
SD		 785 if (thread_info_flags & _TIF_UPROBE) {
786 clear_thread_flag(TIF_UPROBE);
787 uprobe_notify_resume(regs);
788 }
789
1da177e4 790 /* deal with pending signal delivery */
5a8da0ea 791 if (thread_info_flags & _TIF_SIGPENDING)
283828f3 792 do_signal(regs);
8f4d37ec 793
59e52130
RM		 794 if (thread_info_flags & _TIF_NOTIFY_RESUME) {
795 clear_thread_flag(TIF_NOTIFY_RESUME);
796 tracehook_notify_resume(regs);
797 }
7c68af6e
AK		 798 if (thread_info_flags & _TIF_USER_RETURN_NOTIFY)
799 fire_user_return_notifiers();
59e52130 800
ee847c54 801#ifdef CONFIG_X86_32
1da177e4 802 clear_thread_flag(TIF_IRET);
ee847c54 803#endif /* CONFIG_X86_32 */
1da177e4 804}
72fa50f4
HS		 805
806void signal_fault(struct pt_regs *regs, void __user *frame, char *where)
807{
808 struct task_struct *me = current;
809
810 if (show_unhandled_signals && printk_ratelimit()) {
ae417bb4 811 printk("%s"
72fa50f4 812 "%s[%d] bad frame in %s frame:%p ip:%lx sp:%lx orax:%lx",
ae417bb4 813 task_pid_nr(current) > 1 ? KERN_INFO : KERN_EMERG,
72fa50f4
HS		 814 me->comm, me->pid, where, frame,
815 regs->ip, regs->sp, regs->orig_ax);
816 print_vma_addr(" in ", regs->ip);
817 printk(KERN_CONT "\n");
818 }
819
820 force_sig(SIGSEGV, me);
821}
c5a37394
PA		 822
823#ifdef CONFIG_X86_X32_ABI
824static int x32_setup_rt_frame(int sig, struct k_sigaction *ka,
825 siginfo_t *info, compat_sigset_t *set,
826 struct pt_regs *regs)
827{
828 struct rt_sigframe_x32 __user *frame;
829 void __user *restorer;
830 int err = 0;
831 void __user *fpstate = NULL;
832
833 frame = get_sigframe(ka, regs, sizeof(*frame), &fpstate);
834
835 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
836 return -EFAULT;
837
838 if (ka->sa.sa_flags & SA_SIGINFO) {
839 if (copy_siginfo_to_user32(&frame->info, info))
840 return -EFAULT;
841 }
842
843 put_user_try {
844 /* Create the ucontext. */
845 if (cpu_has_xsave)
846 put_user_ex(UC_FP_XSTATE, &frame->uc.uc_flags);
847 else
848 put_user_ex(0, &frame->uc.uc_flags);
849 put_user_ex(0, &frame->uc.uc_link);
850 put_user_ex(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
851 put_user_ex(sas_ss_flags(regs->sp),
852 &frame->uc.uc_stack.ss_flags);
853 put_user_ex(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
854 put_user_ex(0, &frame->uc.uc__pad0);
855 err |= setup_sigcontext(&frame->uc.uc_mcontext, fpstate,
856 regs, set->sig[0]);
857 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
858
859 if (ka->sa.sa_flags & SA_RESTORER) {
860 restorer = ka->sa.sa_restorer;
861 } else {
862 /* could use a vstub here */
863 restorer = NULL;
864 err |= -EFAULT;
865 }
866 put_user_ex(restorer, &frame->pretcode);
867 } put_user_catch(err);
868
869 if (err)
870 return -EFAULT;
871
872 /* Set up registers for signal handler */
873 regs->sp = (unsigned long) frame;
874 regs->ip = (unsigned long) ka->sa.sa_handler;
875
876 /* We use the x32 calling convention here... */
877 regs->di = sig;
878 regs->si = (unsigned long) &frame->info;
879 regs->dx = (unsigned long) &frame->uc;
880
881 loadsegment(ds, __USER_DS);
882 loadsegment(es, __USER_DS);
883
884 regs->cs = __USER_CS;
885 regs->ss = __USER_DS;
886
887 return 0;
888}
889
890asmlinkage long sys32_x32_rt_sigreturn(struct pt_regs *regs)
891{
892 struct rt_sigframe_x32 __user *frame;
893 sigset_t set;
894 unsigned long ax;
895 struct pt_regs tregs;
896
897 frame = (struct rt_sigframe_x32 __user *)(regs->sp - 8);
898
899 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
900 goto badframe;
901 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
902 goto badframe;
903
c5a37394
PA		 904 set_current_blocked(&set);
905
906 if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &ax))
907 goto badframe;
908
909 tregs = *regs;
910 if (sys32_sigaltstack(&frame->uc.uc_stack, NULL, &tregs) == -EFAULT)
911 goto badframe;
912
913 return ax;
914
915badframe:
916 signal_fault(regs, frame, "x32 rt_sigreturn");
917 return 0;
918}
919#endif
ubuntu-bionic-kernel mirror