Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 08f739570de697dc06b949ba3be33acdda21498c

Authored by Al Viro
1 parent 7e243643df
Exists in smarc-l5.0.0_1.0.0-ga and in 5 other branches imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga

sparc: convert to ksignal 

Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

Showing 3 changed files with 164 additions and 254 deletions Side-by-side Diff

arch/sparc/kernel/signal32.c
Diff comments   View file @ 08f7395
... ... @@ -323,7 +323,7 @@
323 323 return 0;
324 324 }
325 325  
326   -static void __user *get_sigframe(struct sigaction *sa, struct pt_regs *regs, unsigned long framesize)
  326 +static void __user *get_sigframe(struct ksignal *ksig, struct pt_regs *regs, unsigned long framesize)
327 327 {
328 328 unsigned long sp;
329 329  
330 330  
... ... @@ -338,13 +338,8 @@
338 338 return (void __user *) -1L;
339 339  
340 340 /* This is the X/Open sanctioned signal stack switching. */
341   - if (sa->sa_flags & SA_ONSTACK) {
342   - if (sas_ss_flags(sp) == 0)
343   - sp = current->sas_ss_sp + current->sas_ss_size;
344   - }
  341 + sp = sigsp(sp, ksig) - framesize;
345 342  
346   - sp -= framesize;
347   -
348 343 /* Always align the stack frame. This handles two cases. First,
349 344 * sigaltstack need not be mindful of platform specific stack
350 345 * alignment. Second, if we took this signal because the stack
... ... @@ -414,8 +409,8 @@
414 409  
415 410 }
416 411  
417   -static int setup_frame32(struct k_sigaction *ka, struct pt_regs *regs,
418   - int signo, sigset_t *oldset)
  412 +static int setup_frame32(struct ksignal *ksig, struct pt_regs *regs,
  413 + sigset_t *oldset)
419 414 {
420 415 struct signal_frame32 __user *sf;
421 416 int i, err, wsaved;
422 417  
... ... @@ -437,10 +432,12 @@
437 432 sigframe_size += sizeof(__siginfo_rwin_t);
438 433  
439 434 sf = (struct signal_frame32 __user *)
440   - get_sigframe(&ka->sa, regs, sigframe_size);
  435 + get_sigframe(ksig, regs, sigframe_size);
441 436  
442   - if (invalid_frame_pointer(sf, sigframe_size))
443   - goto sigill;
  437 + if (invalid_frame_pointer(sf, sigframe_size)) {
  438 + do_exit(SIGILL);
  439 + return -EINVAL;
  440 + }
444 441  
445 442 tail = (sf + 1);
446 443  
447 444  
448 445  
... ... @@ -514,16 +511,16 @@
514 511 err |= __put_user(rp->ins[7], &sf->ss.callers_pc);
515 512 }
516 513 if (err)
517   - goto sigsegv;
  514 + return err;
518 515  
519 516 /* 3. signal handler back-trampoline and parameters */
520 517 regs->u_regs[UREG_FP] = (unsigned long) sf;
521   - regs->u_regs[UREG_I0] = signo;
  518 + regs->u_regs[UREG_I0] = ksig->sig;
522 519 regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
523 520 regs->u_regs[UREG_I2] = (unsigned long) &sf->info;
524 521  
525 522 /* 4. signal handler */
526   - regs->tpc = (unsigned long) ka->sa.sa_handler;
  523 + regs->tpc = (unsigned long) ksig->ka.sa.sa_handler;
527 524 regs->tnpc = (regs->tpc + 4);
528 525 if (test_thread_flag(TIF_32BIT)) {
529 526 regs->tpc &= 0xffffffff;
... ... @@ -531,8 +528,8 @@
531 528 }
532 529  
533 530 /* 5. return to kernel instructions */
534   - if (ka->ka_restorer) {
535   - regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
  531 + if (ksig->ka.ka_restorer) {
  532 + regs->u_regs[UREG_I7] = (unsigned long)ksig->ka.ka_restorer;
536 533 } else {
537 534 unsigned long address = ((unsigned long)&(sf->insns[0]));
538 535  
539 536  
540 537  
... ... @@ -541,23 +538,14 @@
541 538 err = __put_user(0x821020d8, &sf->insns[0]); /*mov __NR_sigreturn, %g1*/
542 539 err |= __put_user(0x91d02010, &sf->insns[1]); /*t 0x10*/
543 540 if (err)
544   - goto sigsegv;
  541 + return err;
545 542 flush_signal_insns(address);
546 543 }
547 544 return 0;
548   -
549   -sigill:
550   - do_exit(SIGILL);
551   - return -EINVAL;
552   -
553   -sigsegv:
554   - force_sigsegv(signo, current);
555   - return -EFAULT;
556 545 }
557 546  
558   -static int setup_rt_frame32(struct k_sigaction *ka, struct pt_regs *regs,
559   - unsigned long signr, sigset_t *oldset,
560   - siginfo_t *info)
  547 +static int setup_rt_frame32(struct ksignal *ksig, struct pt_regs *regs,
  548 + sigset_t *oldset)
561 549 {
562 550 struct rt_signal_frame32 __user *sf;
563 551 int i, err, wsaved;
564 552  
... ... @@ -579,10 +567,12 @@
579 567 sigframe_size += sizeof(__siginfo_rwin_t);
580 568  
581 569 sf = (struct rt_signal_frame32 __user *)
582   - get_sigframe(&ka->sa, regs, sigframe_size);
  570 + get_sigframe(ksig, regs, sigframe_size);
583 571  
584   - if (invalid_frame_pointer(sf, sigframe_size))
585   - goto sigill;
  572 + if (invalid_frame_pointer(sf, sigframe_size)) {
  573 + do_exit(SIGILL);
  574 + return -EINVAL;
  575 + }
586 576  
587 577 tail = (sf + 1);
588 578  
... ... @@ -627,7 +617,7 @@
627 617 }
628 618  
629 619 /* Update the siginfo structure. */
630   - err |= copy_siginfo_to_user32(&sf->info, info);
  620 + err |= copy_siginfo_to_user32(&sf->info, &ksig->info);
631 621  
632 622 /* Setup sigaltstack */
633 623 err |= __compat_save_altstack(&sf->stack, regs->u_regs[UREG_FP]);
634 624  
635 625  
... ... @@ -660,16 +650,16 @@
660 650 err |= __put_user(rp->ins[7], &sf->ss.callers_pc);
661 651 }
662 652 if (err)
663   - goto sigsegv;
  653 + return err;
664 654  
665 655 /* 3. signal handler back-trampoline and parameters */
666 656 regs->u_regs[UREG_FP] = (unsigned long) sf;
667   - regs->u_regs[UREG_I0] = signr;
  657 + regs->u_regs[UREG_I0] = ksig->sig;
668 658 regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
669 659 regs->u_regs[UREG_I2] = (unsigned long) &sf->regs;
670 660  
671 661 /* 4. signal handler */
672   - regs->tpc = (unsigned long) ka->sa.sa_handler;
  662 + regs->tpc = (unsigned long) ksig->ka.sa.sa_handler;
673 663 regs->tnpc = (regs->tpc + 4);
674 664 if (test_thread_flag(TIF_32BIT)) {
675 665 regs->tpc &= 0xffffffff;
... ... @@ -677,8 +667,8 @@
677 667 }
678 668  
679 669 /* 5. return to kernel instructions */
680   - if (ka->ka_restorer)
681   - regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
  670 + if (ksig->ka.ka_restorer)
  671 + regs->u_regs[UREG_I7] = (unsigned long)ksig->ka.ka_restorer;
682 672 else {
683 673 unsigned long address = ((unsigned long)&(sf->insns[0]));
684 674  
685 675  
686 676  
687 677  
688 678  
689 679  
690 680  
... ... @@ -690,36 +680,25 @@
690 680 /* t 0x10 */
691 681 err |= __put_user(0x91d02010, &sf->insns[1]);
692 682 if (err)
693   - goto sigsegv;
  683 + return err;
694 684  
695 685 flush_signal_insns(address);
696 686 }
697 687 return 0;
698   -
699   -sigill:
700   - do_exit(SIGILL);
701   - return -EINVAL;
702   -
703   -sigsegv:
704   - force_sigsegv(signr, current);
705   - return -EFAULT;
706 688 }
707 689  
708   -static inline void handle_signal32(unsigned long signr, struct k_sigaction *ka,
709   - siginfo_t *info,
710   - sigset_t *oldset, struct pt_regs *regs)
  690 +static inline void handle_signal32(struct ksignal *ksig,
  691 + struct pt_regs *regs)
711 692 {
  693 + sigset_t *oldset = sigmask_to_save();
712 694 int err;
713 695  
714   - if (ka->sa.sa_flags & SA_SIGINFO)
715   - err = setup_rt_frame32(ka, regs, signr, oldset, info);
  696 + if (ksig->ka.sa.sa_flags & SA_SIGINFO)
  697 + err = setup_rt_frame32(ksig, regs, oldset);
716 698 else
717   - err = setup_frame32(ka, regs, signr, oldset);
  699 + err = setup_frame32(ksig, regs, oldset);
718 700  
719   - if (err)
720   - return;
721   -
722   - signal_delivered(signr, info, ka, regs, 0);
  701 + signal_setup_done(err, ksig, 0);
723 702 }
724 703  
725 704 static inline void syscall_restart32(unsigned long orig_i0, struct pt_regs *regs,
726 705  
727 706  
728 707  
729 708  
... ... @@ -749,50 +728,41 @@
749 728 */
750 729 void do_signal32(sigset_t *oldset, struct pt_regs * regs)
751 730 {
752   - struct k_sigaction ka;
753   - unsigned long orig_i0;
754   - int restart_syscall;
755   - siginfo_t info;
756   - int signr;
757   -
758   - signr = get_signal_to_deliver(&info, &ka, regs, NULL);
  731 + struct ksignal ksig;
  732 + unsigned long orig_i0 = 0;
  733 + int restart_syscall = 0;
  734 + bool has_handler = get_signal(&ksig);
759 735  
760   - restart_syscall = 0;
761   - orig_i0 = 0;
762 736 if (pt_regs_is_syscall(regs) &&
763 737 (regs->tstate & (TSTATE_XCARRY | TSTATE_ICARRY))) {
764 738 restart_syscall = 1;
765 739 orig_i0 = regs->u_regs[UREG_G6];
766 740 }
767 741  
768   - if (signr > 0) {
  742 + if (has_handler) {
769 743 if (restart_syscall)
770   - syscall_restart32(orig_i0, regs, &ka.sa);
771   - handle_signal32(signr, &ka, &info, oldset, regs);
772   - return;
  744 + syscall_restart32(orig_i0, regs, &ksig.ka.sa);
  745 + handle_signal32(&ksig, regs);
  746 + } else {
  747 + if (restart_syscall) {
  748 + switch (regs->u_regs[UREG_I0]) {
  749 + case ERESTARTNOHAND:
  750 + case ERESTARTSYS:
  751 + case ERESTARTNOINTR:
  752 + /* replay the system call when we are done */
  753 + regs->u_regs[UREG_I0] = orig_i0;
  754 + regs->tpc -= 4;
  755 + regs->tnpc -= 4;
  756 + pt_regs_clear_syscall(regs);
  757 + case ERESTART_RESTARTBLOCK:
  758 + regs->u_regs[UREG_G1] = __NR_restart_syscall;
  759 + regs->tpc -= 4;
  760 + regs->tnpc -= 4;
  761 + pt_regs_clear_syscall(regs);
  762 + }
  763 + }
  764 + restore_saved_sigmask();
773 765 }
774   - if (restart_syscall &&
775   - (regs->u_regs[UREG_I0] == ERESTARTNOHAND ||
776   - regs->u_regs[UREG_I0] == ERESTARTSYS ||
777   - regs->u_regs[UREG_I0] == ERESTARTNOINTR)) {
778   - /* replay the system call when we are done */
779   - regs->u_regs[UREG_I0] = orig_i0;
780   - regs->tpc -= 4;
781   - regs->tnpc -= 4;
782   - pt_regs_clear_syscall(regs);
783   - }
784   - if (restart_syscall &&
785   - regs->u_regs[UREG_I0] == ERESTART_RESTARTBLOCK) {
786   - regs->u_regs[UREG_G1] = __NR_restart_syscall;
787   - regs->tpc -= 4;
788   - regs->tnpc -= 4;
789   - pt_regs_clear_syscall(regs);
790   - }
791   -
792   - /* If there's no signal to deliver, we just put the saved sigmask
793   - * back
794   - */
795   - restore_saved_sigmask();
796 766 }
797 767  
798 768 struct sigstack32 {
arch/sparc/kernel/signal_32.c
Diff comments   View file @ 08f7395
... ... @@ -186,7 +186,7 @@
186 186 return 0;
187 187 }
188 188  
189   -static inline void __user *get_sigframe(struct sigaction *sa, struct pt_regs *regs, unsigned long framesize)
  189 +static inline void __user *get_sigframe(struct ksignal *ksig, struct pt_regs *regs, unsigned long framesize)
190 190 {
191 191 unsigned long sp = regs->u_regs[UREG_FP];
192 192  
193 193  
... ... @@ -198,13 +198,8 @@
198 198 return (void __user *) -1L;
199 199  
200 200 /* This is the X/Open sanctioned signal stack switching. */
201   - if (sa->sa_flags & SA_ONSTACK) {
202   - if (sas_ss_flags(sp) == 0)
203   - sp = current->sas_ss_sp + current->sas_ss_size;
204   - }
  201 + sp = sigsp(sp, ksig) - framesize;
205 202  
206   - sp -= framesize;
207   -
208 203 /* Always align the stack frame. This handles two cases. First,
209 204 * sigaltstack need not be mindful of platform specific stack
210 205 * alignment. Second, if we took this signal because the stack
... ... @@ -216,8 +211,8 @@
216 211 return (void __user *) sp;
217 212 }
218 213  
219   -static int setup_frame(struct k_sigaction *ka, struct pt_regs *regs,
220   - int signo, sigset_t *oldset)
  214 +static int setup_frame(struct ksignal *ksig, struct pt_regs *regs,
  215 + sigset_t *oldset)
221 216 {
222 217 struct signal_frame __user *sf;
223 218 int sigframe_size, err, wsaved;
224 219  
... ... @@ -235,10 +230,12 @@
235 230 sigframe_size += sizeof(__siginfo_rwin_t);
236 231  
237 232 sf = (struct signal_frame __user *)
238   - get_sigframe(&ka->sa, regs, sigframe_size);
  233 + get_sigframe(ksig, regs, sigframe_size);
239 234  
240   - if (invalid_frame_pointer(sf, sigframe_size))
241   - goto sigill_and_return;
  235 + if (invalid_frame_pointer(sf, sigframe_size)) {
  236 + do_exit(SIGILL);
  237 + return -EINVAL;
  238 + }
242 239  
243 240 tail = sf + 1;
244 241  
245 242  
246 243  
247 244  
... ... @@ -277,21 +274,21 @@
277 274 err |= __copy_to_user(sf, rp, sizeof(struct reg_window32));
278 275 }
279 276 if (err)
280   - goto sigsegv;
  277 + return err;
281 278  
282 279 /* 3. signal handler back-trampoline and parameters */
283 280 regs->u_regs[UREG_FP] = (unsigned long) sf;
284   - regs->u_regs[UREG_I0] = signo;
  281 + regs->u_regs[UREG_I0] = ksig->sig;
285 282 regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
286 283 regs->u_regs[UREG_I2] = (unsigned long) &sf->info;
287 284  
288 285 /* 4. signal handler */
289   - regs->pc = (unsigned long) ka->sa.sa_handler;
  286 + regs->pc = (unsigned long) ksig->ka.sa.sa_handler;
290 287 regs->npc = (regs->pc + 4);
291 288  
292 289 /* 5. return to kernel instructions */
293   - if (ka->ka_restorer)
294   - regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
  290 + if (ksig->ka.ka_restorer)
  291 + regs->u_regs[UREG_I7] = (unsigned long)ksig->ka.ka_restorer;
295 292 else {
296 293 regs->u_regs[UREG_I7] = (unsigned long)(&(sf->insns[0]) - 2);
297 294  
298 295  
299 296  
... ... @@ -301,24 +298,16 @@
301 298 /* t 0x10 */
302 299 err |= __put_user(0x91d02010, &sf->insns[1]);
303 300 if (err)
304   - goto sigsegv;
  301 + return err;
305 302  
306 303 /* Flush instruction space. */
307 304 flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0]));
308 305 }
309 306 return 0;
310   -
311   -sigill_and_return:
312   - do_exit(SIGILL);
313   - return -EINVAL;
314   -
315   -sigsegv:
316   - force_sigsegv(signo, current);
317   - return -EFAULT;
318 307 }
319 308  
320   -static int setup_rt_frame(struct k_sigaction *ka, struct pt_regs *regs,
321   - int signo, sigset_t *oldset, siginfo_t *info)
  309 +static int setup_rt_frame(struct ksignal *ksig, struct pt_regs *regs,
  310 + sigset_t *oldset)
322 311 {
323 312 struct rt_signal_frame __user *sf;
324 313 int sigframe_size, wsaved;
... ... @@ -334,9 +323,11 @@
334 323 if (wsaved)
335 324 sigframe_size += sizeof(__siginfo_rwin_t);
336 325 sf = (struct rt_signal_frame __user *)
337   - get_sigframe(&ka->sa, regs, sigframe_size);
338   - if (invalid_frame_pointer(sf, sigframe_size))
339   - goto sigill;
  326 + get_sigframe(ksig, regs, sigframe_size);
  327 + if (invalid_frame_pointer(sf, sigframe_size)) {
  328 + do_exit(SIGILL);
  329 + return -EINVAL;
  330 + }
340 331  
341 332 tail = sf + 1;
342 333 err = __put_user(regs->pc, &sf->regs.pc);
343 334  
344 335  
345 336  
346 337  
... ... @@ -380,21 +371,21 @@
380 371 err |= __copy_to_user(sf, rp, sizeof(struct reg_window32));
381 372 }
382 373  
383   - err |= copy_siginfo_to_user(&sf->info, info);
  374 + err |= copy_siginfo_to_user(&sf->info, &ksig->info);
384 375  
385 376 if (err)
386   - goto sigsegv;
  377 + return err;
387 378  
388 379 regs->u_regs[UREG_FP] = (unsigned long) sf;
389   - regs->u_regs[UREG_I0] = signo;
  380 + regs->u_regs[UREG_I0] = ksig->sig;
390 381 regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
391 382 regs->u_regs[UREG_I2] = (unsigned long) &sf->regs;
392 383  
393   - regs->pc = (unsigned long) ka->sa.sa_handler;
  384 + regs->pc = (unsigned long) ksig->ka.sa.sa_handler;
394 385 regs->npc = (regs->pc + 4);
395 386  
396   - if (ka->ka_restorer)
397   - regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
  387 + if (ksig->ka.ka_restorer)
  388 + regs->u_regs[UREG_I7] = (unsigned long)ksig->ka.ka_restorer;
398 389 else {
399 390 regs->u_regs[UREG_I7] = (unsigned long)(&(sf->insns[0]) - 2);
400 391  
401 392  
402 393  
403 394  
404 395  
... ... @@ -404,38 +395,25 @@
404 395 /* t 0x10 */
405 396 err |= __put_user(0x91d02010, &sf->insns[1]);
406 397 if (err)
407   - goto sigsegv;
  398 + return err;
408 399  
409 400 /* Flush instruction space. */
410 401 flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0]));
411 402 }
412 403 return 0;
413   -
414   -sigill:
415   - do_exit(SIGILL);
416   - return -EINVAL;
417   -
418   -sigsegv:
419   - force_sigsegv(signo, current);
420   - return -EFAULT;
421 404 }
422 405  
423 406 static inline void
424   -handle_signal(unsigned long signr, struct k_sigaction *ka,
425   - siginfo_t *info, struct pt_regs *regs)
  407 +handle_signal(struct ksignal *ksig, struct pt_regs *regs)
426 408 {
427 409 sigset_t *oldset = sigmask_to_save();
428 410 int err;
429 411  
430   - if (ka->sa.sa_flags & SA_SIGINFO)
431   - err = setup_rt_frame(ka, regs, signr, oldset, info);
  412 + if (ksig->ka.sa.sa_flags & SA_SIGINFO)
  413 + err = setup_rt_frame(ksig, regs, oldset);
432 414 else
433   - err = setup_frame(ka, regs, signr, oldset);
434   -
435   - if (err)
436   - return;
437   -
438   - signal_delivered(signr, info, ka, regs, 0);
  415 + err = setup_frame(ksig, regs, oldset);
  416 + signal_setup_done(err, ksig, 0);
439 417 }
440 418  
441 419 static inline void syscall_restart(unsigned long orig_i0, struct pt_regs *regs,
442 420  
... ... @@ -465,10 +443,9 @@
465 443 */
466 444 static void do_signal(struct pt_regs *regs, unsigned long orig_i0)
467 445 {
468   - struct k_sigaction ka;
  446 + struct ksignal ksig;
469 447 int restart_syscall;
470   - siginfo_t info;
471   - int signr;
  448 + bool has_handler;
472 449  
473 450 /* It's a lot of work and synchronization to add a new ptrace
474 451 * register for GDB to save and restore in order to get
... ... @@ -491,7 +468,7 @@
491 468 if (pt_regs_is_syscall(regs) && (regs->psr & PSR_C))
492 469 regs->u_regs[UREG_G6] = orig_i0;
493 470  
494   - signr = get_signal_to_deliver(&info, &ka, regs, NULL);
  471 + has_handler = get_signal(&ksig);
495 472  
496 473 /* If the debugger messes with the program counter, it clears
497 474 * the software "in syscall" bit, directing us to not perform
498 475  
499 476  
... ... @@ -503,35 +480,30 @@
503 480 orig_i0 = regs->u_regs[UREG_G6];
504 481 }
505 482  
506   -
507   - if (signr > 0) {
  483 + if (has_handler) {
508 484 if (restart_syscall)
509   - syscall_restart(orig_i0, regs, &ka.sa);
510   - handle_signal(signr, &ka, &info, regs);
511   - return;
  485 + syscall_restart(orig_i0, regs, &ksig.ka.sa);
  486 + handle_signal(&ksig, regs);
  487 + } else {
  488 + if (restart_syscall) {
  489 + switch (regs->u_regs[UREG_I0]) {
  490 + case ERESTARTNOHAND:
  491 + case ERESTARTSYS:
  492 + case ERESTARTNOINTR:
  493 + /* replay the system call when we are done */
  494 + regs->u_regs[UREG_I0] = orig_i0;
  495 + regs->pc -= 4;
  496 + regs->npc -= 4;
  497 + pt_regs_clear_syscall(regs);
  498 + case ERESTART_RESTARTBLOCK:
  499 + regs->u_regs[UREG_G1] = __NR_restart_syscall;
  500 + regs->pc -= 4;
  501 + regs->npc -= 4;
  502 + pt_regs_clear_syscall(regs);
  503 + }
  504 + }
  505 + restore_saved_sigmask();
512 506 }
513   - if (restart_syscall &&
514   - (regs->u_regs[UREG_I0] == ERESTARTNOHAND ||
515   - regs->u_regs[UREG_I0] == ERESTARTSYS ||
516   - regs->u_regs[UREG_I0] == ERESTARTNOINTR)) {
517   - /* replay the system call when we are done */
518   - regs->u_regs[UREG_I0] = orig_i0;
519   - regs->pc -= 4;
520   - regs->npc -= 4;
521   - pt_regs_clear_syscall(regs);
522   - }
523   - if (restart_syscall &&
524   - regs->u_regs[UREG_I0] == ERESTART_RESTARTBLOCK) {
525   - regs->u_regs[UREG_G1] = __NR_restart_syscall;
526   - regs->pc -= 4;
527   - regs->npc -= 4;
528   - pt_regs_clear_syscall(regs);
529   - }
530   -
531   - /* if there's no signal to deliver, we just put the saved sigmask
532   - * back
533   - */
534   - restore_saved_sigmask();
535 507 }
536 508  
537 509 void do_notify_resume(struct pt_regs *regs, unsigned long orig_i0,
arch/sparc/kernel/signal_64.c
Diff comments   View file @ 08f7395
... ... @@ -308,7 +308,7 @@
308 308 return 0;
309 309 }
310 310  
311   -static inline void __user *get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, unsigned long framesize)
  311 +static inline void __user *get_sigframe(struct ksignal *ksig, struct pt_regs *regs, unsigned long framesize)
312 312 {
313 313 unsigned long sp = regs->u_regs[UREG_FP] + STACK_BIAS;
314 314  
315 315  
... ... @@ -320,13 +320,8 @@
320 320 return (void __user *) -1L;
321 321  
322 322 /* This is the X/Open sanctioned signal stack switching. */
323   - if (ka->sa.sa_flags & SA_ONSTACK) {
324   - if (sas_ss_flags(sp) == 0)
325   - sp = current->sas_ss_sp + current->sas_ss_size;
326   - }
  323 + sp = sigsp(sp, ksig) - framesize;
327 324  
328   - sp -= framesize;
329   -
330 325 /* Always align the stack frame. This handles two cases. First,
331 326 * sigaltstack need not be mindful of platform specific stack
332 327 * alignment. Second, if we took this signal because the stack
... ... @@ -339,8 +334,7 @@
339 334 }
340 335  
341 336 static inline int
342   -setup_rt_frame(struct k_sigaction *ka, struct pt_regs *regs,
343   - int signo, sigset_t *oldset, siginfo_t *info)
  337 +setup_rt_frame(struct ksignal *ksig, struct pt_regs *regs)
344 338 {
345 339 struct rt_signal_frame __user *sf;
346 340 int wsaved, err, sf_size;
347 341  
... ... @@ -358,10 +352,12 @@
358 352 if (wsaved)
359 353 sf_size += sizeof(__siginfo_rwin_t);
360 354 sf = (struct rt_signal_frame __user *)
361   - get_sigframe(ka, regs, sf_size);
  355 + get_sigframe(ksig, regs, sf_size);
362 356  
363   - if (invalid_frame_pointer (sf))
364   - goto sigill;
  357 + if (invalid_frame_pointer (sf)) {
  358 + do_exit(SIGILL); /* won't return, actually */
  359 + return -EINVAL;
  360 + }
365 361  
366 362 tail = (sf + 1);
367 363  
... ... @@ -389,7 +385,7 @@
389 385 /* Setup sigaltstack */
390 386 err |= __save_altstack(&sf->stack, regs->u_regs[UREG_FP]);
391 387  
392   - err |= copy_to_user(&sf->mask, oldset, sizeof(sigset_t));
  388 + err |= copy_to_user(&sf->mask, sigmask_to_save(), sizeof(sigset_t));
393 389  
394 390 if (!wsaved) {
395 391 err |= copy_in_user((u64 __user *)sf,
396 392  
397 393  
398 394  
... ... @@ -402,18 +398,18 @@
402 398 rp = &current_thread_info()->reg_window[wsaved - 1];
403 399 err |= copy_to_user(sf, rp, sizeof(struct reg_window));
404 400 }
405   - if (info)
406   - err |= copy_siginfo_to_user(&sf->info, info);
  401 + if (ksig->ka.sa.sa_flags & SA_SIGINFO)
  402 + err |= copy_siginfo_to_user(&sf->info, &ksig->info);
407 403 else {
408   - err |= __put_user(signo, &sf->info.si_signo);
  404 + err |= __put_user(ksig->sig, &sf->info.si_signo);
409 405 err |= __put_user(SI_NOINFO, &sf->info.si_code);
410 406 }
411 407 if (err)
412   - goto sigsegv;
  408 + return err;
413 409  
414 410 /* 3. signal handler back-trampoline and parameters */
415 411 regs->u_regs[UREG_FP] = ((unsigned long) sf) - STACK_BIAS;
416   - regs->u_regs[UREG_I0] = signo;
  412 + regs->u_regs[UREG_I0] = ksig->sig;
417 413 regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
418 414  
419 415 /* The sigcontext is passed in this way because of how it
420 416  
421 417  
422 418  
... ... @@ -423,39 +419,17 @@
423 419 regs->u_regs[UREG_I2] = (unsigned long) &sf->info;
424 420  
425 421 /* 5. signal handler */
426   - regs->tpc = (unsigned long) ka->sa.sa_handler;
  422 + regs->tpc = (unsigned long) ksig->ka.sa.sa_handler;
427 423 regs->tnpc = (regs->tpc + 4);
428 424 if (test_thread_flag(TIF_32BIT)) {
429 425 regs->tpc &= 0xffffffff;
430 426 regs->tnpc &= 0xffffffff;
431 427 }
432 428 /* 4. return to kernel instructions */
433   - regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
  429 + regs->u_regs[UREG_I7] = (unsigned long)ksig->ka.ka_restorer;
434 430 return 0;
435   -
436   -sigill:
437   - do_exit(SIGILL);
438   - return -EINVAL;
439   -
440   -sigsegv:
441   - force_sigsegv(signo, current);
442   - return -EFAULT;
443 431 }
444 432  
445   -static inline void handle_signal(unsigned long signr, struct k_sigaction *ka,
446   - siginfo_t *info,
447   - sigset_t *oldset, struct pt_regs *regs)
448   -{
449   - int err;
450   -
451   - err = setup_rt_frame(ka, regs, signr, oldset,
452   - (ka->sa.sa_flags & SA_SIGINFO) ? info : NULL);
453   - if (err)
454   - return;
455   -
456   - signal_delivered(signr, info, ka, regs, 0);
457   -}
458   -
459 433 static inline void syscall_restart(unsigned long orig_i0, struct pt_regs *regs,
460 434 struct sigaction *sa)
461 435 {
462 436  
... ... @@ -483,11 +457,9 @@
483 457 */
484 458 static void do_signal(struct pt_regs *regs, unsigned long orig_i0)
485 459 {
486   - struct k_sigaction ka;
  460 + struct ksignal ksig;
487 461 int restart_syscall;
488   - sigset_t *oldset = sigmask_to_save();
489   - siginfo_t info;
490   - int signr;
  462 + bool has_handler;
491 463  
492 464 /* It's a lot of work and synchronization to add a new ptrace
493 465 * register for GDB to save and restore in order to get
494 466  
... ... @@ -513,13 +485,13 @@
513 485  
514 486 #ifdef CONFIG_COMPAT
515 487 if (test_thread_flag(TIF_32BIT)) {
516   - extern void do_signal32(sigset_t *, struct pt_regs *);
517   - do_signal32(oldset, regs);
  488 + extern void do_signal32(struct pt_regs *);
  489 + do_signal32(regs);
518 490 return;
519 491 }
520 492 #endif
521 493  
522   - signr = get_signal_to_deliver(&info, &ka, regs, NULL);
  494 + has_handler = get_signal(&ksig);
523 495  
524 496 restart_syscall = 0;
525 497 if (pt_regs_is_syscall(regs) &&
526 498  
527 499  
... ... @@ -528,34 +500,30 @@
528 500 orig_i0 = regs->u_regs[UREG_G6];
529 501 }
530 502  
531   - if (signr > 0) {
  503 + if (has_handler) {
532 504 if (restart_syscall)
533   - syscall_restart(orig_i0, regs, &ka.sa);
534   - handle_signal(signr, &ka, &info, oldset, regs);
535   - return;
  505 + syscall_restart(orig_i0, regs, &ksig.ka.sa);
  506 + signal_setup_done(setup_rt_frame(&ksig, regs), &ksig, 0);
  507 + } else {
  508 + if (restart_syscall) {
  509 + switch (regs->u_regs[UREG_I0]) {
  510 + case ERESTARTNOHAND:
  511 + case ERESTARTSYS:
  512 + case ERESTARTNOINTR:
  513 + /* replay the system call when we are done */
  514 + regs->u_regs[UREG_I0] = orig_i0;
  515 + regs->tpc -= 4;
  516 + regs->tnpc -= 4;
  517 + pt_regs_clear_syscall(regs);
  518 + case ERESTART_RESTARTBLOCK:
  519 + regs->u_regs[UREG_G1] = __NR_restart_syscall;
  520 + regs->tpc -= 4;
  521 + regs->tnpc -= 4;
  522 + pt_regs_clear_syscall(regs);
  523 + }
  524 + }
  525 + restore_saved_sigmask();
536 526 }
537   - if (restart_syscall &&
538   - (regs->u_regs[UREG_I0] == ERESTARTNOHAND ||
539   - regs->u_regs[UREG_I0] == ERESTARTSYS ||
540   - regs->u_regs[UREG_I0] == ERESTARTNOINTR)) {
541   - /* replay the system call when we are done */
542   - regs->u_regs[UREG_I0] = orig_i0;
543   - regs->tpc -= 4;
544   - regs->tnpc -= 4;
545   - pt_regs_clear_syscall(regs);
546   - }
547   - if (restart_syscall &&
548   - regs->u_regs[UREG_I0] == ERESTART_RESTARTBLOCK) {
549   - regs->u_regs[UREG_G1] = __NR_restart_syscall;
550   - regs->tpc -= 4;
551   - regs->tnpc -= 4;
552   - pt_regs_clear_syscall(regs);
553   - }
554   -
555   - /* If there's no signal to deliver, we just put the saved sigmask
556   - * back
557   - */
558   - restore_saved_sigmask();
559 527 }
560 528  
561 529 void do_notify_resume(struct pt_regs *regs, unsigned long orig_i0, unsigned long thread_info_flags)