sh: Use get_signal() signal_setup_done()

Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git

kernel os linux

Use the more generic functions get_signal() signal_setup_done()
for signal delivery.

Signed-off-by: Richard Weinberger <richard@nod.at>

authored by

Richard Weinberger and committed by

Richard Weinberger 11 years ago b46e8487 2bb12b77

+64 -97

2 changed files

expand all

arch

kernel

signal_32.c

signal_64.c

+32 -47

arch/sh/kernel/signal_32.c

··· 262 262 extern void __kernel_sigreturn(void); 263 263 extern void __kernel_rt_sigreturn(void); 264 264 265 - static int setup_frame(int sig, struct k_sigaction *ka, 266 - sigset_t *set, struct pt_regs *regs) 265 + static int setup_frame(struct ksignal *ksig, sigset_t *set, 266 + struct pt_regs *regs) 267 267 { 268 268 struct sigframe __user *frame; 269 - int err = 0; 269 + int err = 0, sig = ksig->sig; 270 270 int signal; 271 271 272 - frame = get_sigframe(ka, regs->regs[15], sizeof(*frame)); 272 + frame = get_sigframe(&ksig->ka, regs->regs[15], sizeof(*frame)); 273 273 274 274 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame))) 275 - goto give_sigsegv; 275 + return -EFAULT; 276 276 277 277 signal = current_thread_info()->exec_domain 278 278 && current_thread_info()->exec_domain->signal_invmap ··· 288 288 289 289 /* Set up to return from userspace. If provided, use a stub 290 290 already in userspace. */ 291 - if (ka->sa.sa_flags & SA_RESTORER) { 292 - regs->pr = (unsigned long) ka->sa.sa_restorer; 291 + if (ksig->ka.sa.sa_flags & SA_RESTORER) { 292 + regs->pr = (unsigned long) ksig->ka.sa.sa_restorer; 293 293 #ifdef CONFIG_VSYSCALL 294 294 } else if (likely(current->mm->context.vdso)) { 295 295 regs->pr = VDSO_SYM(&__kernel_sigreturn); ··· 309 309 } 310 310 311 311 if (err) 312 - goto give_sigsegv; 312 + return -EFAULT; 313 313 314 314 /* Set up registers for signal handler */ 315 315 regs->regs[15] = (unsigned long) frame; ··· 319 319 320 320 if (current->personality & FDPIC_FUNCPTRS) { 321 321 struct fdpic_func_descriptor __user *funcptr = 322 - (struct fdpic_func_descriptor __user *)ka->sa.sa_handler; 322 + (struct fdpic_func_descriptor __user *)ksig->ka.sa.sa_handler; 323 323 324 324 err |= __get_user(regs->pc, &funcptr->text); 325 325 err |= __get_user(regs->regs[12], &funcptr->GOT); 326 326 } else 327 - regs->pc = (unsigned long)ka->sa.sa_handler; 327 + regs->pc = (unsigned long)ksig->ka.sa.sa_handler; 328 328 329 329 if (err) 330 - goto give_sigsegv; 330 + return -EFAULT; 331 331 332 332 set_fs(USER_DS); 333 333 ··· 335 335 current->comm, task_pid_nr(current), frame, regs->pc, regs->pr); 336 336 337 337 return 0; 338 - 339 - give_sigsegv: 340 - force_sigsegv(sig, current); 341 - return -EFAULT; 342 338 } 343 339 344 - static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info, 345 - sigset_t *set, struct pt_regs *regs) 340 + static int setup_rt_frame(struct ksignal *ksig, sigset_t *set, 341 + struct pt_regs *regs) 346 342 { 347 343 struct rt_sigframe __user *frame; 348 - int err = 0; 344 + int err = 0, sig = ksig->sig; 349 345 int signal; 350 346 351 - frame = get_sigframe(ka, regs->regs[15], sizeof(*frame)); 347 + frame = get_sigframe(&ksig->ka, regs->regs[15], sizeof(*frame)); 352 348 353 349 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame))) 354 - goto give_sigsegv; 350 + return -EFAULT; 355 351 356 352 signal = current_thread_info()->exec_domain 357 353 && current_thread_info()->exec_domain->signal_invmap ··· 355 359 ? current_thread_info()->exec_domain->signal_invmap[sig] 356 360 : sig; 357 361 358 - err |= copy_siginfo_to_user(&frame->info, info); 362 + err |= copy_siginfo_to_user(&frame->info, &ksig->info); 359 363 360 364 /* Create the ucontext. */ 361 365 err |= __put_user(0, &frame->uc.uc_flags); ··· 367 371 368 372 /* Set up to return from userspace. If provided, use a stub 369 373 already in userspace. */ 370 - if (ka->sa.sa_flags & SA_RESTORER) { 371 - regs->pr = (unsigned long) ka->sa.sa_restorer; 374 + if (ksig->ka.sa.sa_flags & SA_RESTORER) { 375 + regs->pr = (unsigned long) ksig->ka.sa.sa_restorer; 372 376 #ifdef CONFIG_VSYSCALL 373 377 } else if (likely(current->mm->context.vdso)) { 374 378 regs->pr = VDSO_SYM(&__kernel_rt_sigreturn); ··· 388 392 } 389 393 390 394 if (err) 391 - goto give_sigsegv; 395 + return -EFAULT; 392 396 393 397 /* Set up registers for signal handler */ 394 398 regs->regs[15] = (unsigned long) frame; ··· 398 402 399 403 if (current->personality & FDPIC_FUNCPTRS) { 400 404 struct fdpic_func_descriptor __user *funcptr = 401 - (struct fdpic_func_descriptor __user *)ka->sa.sa_handler; 405 + (struct fdpic_func_descriptor __user *)ksig->ka.sa.sa_handler; 402 406 403 407 err |= __get_user(regs->pc, &funcptr->text); 404 408 err |= __get_user(regs->regs[12], &funcptr->GOT); 405 409 } else 406 - regs->pc = (unsigned long)ka->sa.sa_handler; 410 + regs->pc = (unsigned long)ksig->ka.sa.sa_handler; 407 411 408 412 if (err) 409 - goto give_sigsegv; 413 + return -EFAULT; 410 414 411 415 set_fs(USER_DS); 412 416 ··· 414 418 current->comm, task_pid_nr(current), frame, regs->pc, regs->pr); 415 419 416 420 return 0; 417 - 418 - give_sigsegv: 419 - force_sigsegv(sig, current); 420 - return -EFAULT; 421 421 } 422 422 423 423 static inline void ··· 447 455 * OK, we're invoking a handler 448 456 */ 449 457 static void 450 - handle_signal(unsigned long sig, struct k_sigaction *ka, siginfo_t *info, 451 - struct pt_regs *regs, unsigned int save_r0) 458 + handle_signal(struct ksignal *ksig, struct pt_regs *regs, unsigned int save_r0) 452 459 { 453 460 sigset_t *oldset = sigmask_to_save(); 454 461 int ret; 455 462 456 463 /* Set up the stack frame */ 457 - if (ka->sa.sa_flags & SA_SIGINFO) 458 - ret = setup_rt_frame(sig, ka, info, oldset, regs); 464 + if (ksig->ka.sa.sa_flags & SA_SIGINFO) 465 + ret = setup_rt_frame(ksig, oldset, regs); 459 466 else 460 - ret = setup_frame(sig, ka, oldset, regs); 467 + ret = setup_frame(ksig, oldset, regs); 461 468 462 - if (ret) 463 - return; 464 - signal_delivered(sig, info, ka, regs, 465 - test_thread_flag(TIF_SINGLESTEP)); 469 + signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLESTEP)); 466 470 } 467 471 468 472 /* ··· 472 484 */ 473 485 static void do_signal(struct pt_regs *regs, unsigned int save_r0) 474 486 { 475 - siginfo_t info; 476 - int signr; 477 - struct k_sigaction ka; 487 + struct ksignal ksig; 478 488 479 489 /* 480 490 * We want the common case to go fast, which ··· 483 497 if (!user_mode(regs)) 484 498 return; 485 499 486 - signr = get_signal_to_deliver(&info, &ka, regs, NULL); 487 - if (signr > 0) { 488 - handle_syscall_restart(save_r0, regs, &ka.sa); 500 + if (get_signal(&ksig)) { 501 + handle_syscall_restart(save_r0, regs, &ksig.ka.sa); 489 502 490 503 /* Whee! Actually deliver the signal. */ 491 - handle_signal(signr, &ka, &info, regs, save_r0); 504 + handle_signal(&ksig, regs, save_r0); 492 505 return; 493 506 } 494 507

+32 -50

arch/sh/kernel/signal_64.c

··· 41 41 #define DEBUG_SIG 0 42 42 43 43 static void 44 - handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka, 45 - struct pt_regs * regs); 44 + handle_signal(struct ksignal *ksig, struct pt_regs *regs); 46 45 47 46 static inline void 48 47 handle_syscall_restart(struct pt_regs *regs, struct sigaction *sa) ··· 81 82 */ 82 83 static void do_signal(struct pt_regs *regs) 83 84 { 84 - siginfo_t info; 85 - int signr; 86 - struct k_sigaction ka; 85 + struct ksignal ksig; 87 86 88 87 /* 89 88 * We want the common case to go fast, which ··· 92 95 if (!user_mode(regs)) 93 96 return; 94 97 95 - signr = get_signal_to_deliver(&info, &ka, regs, 0); 96 - if (signr > 0) { 97 - handle_syscall_restart(regs, &ka.sa); 98 + if (get_signal(&ksig)) { 99 + handle_syscall_restart(regs, &ksig.ka.sa); 98 100 99 101 /* Whee! Actually deliver the signal. */ 100 - handle_signal(signr, &info, &ka, regs); 102 + handle_signal(&ksig, regs); 101 103 return; 102 104 } 103 105 ··· 374 378 void sa_default_restorer(void); /* See comments below */ 375 379 void sa_default_rt_restorer(void); /* See comments below */ 376 380 377 - static int setup_frame(int sig, struct k_sigaction *ka, 378 - sigset_t *set, struct pt_regs *regs) 381 + static int setup_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs) 379 382 { 380 383 struct sigframe __user *frame; 381 - int err = 0; 384 + int err = 0, sig = ksig->sig; 382 385 int signal; 383 386 384 - frame = get_sigframe(ka, regs->regs[REG_SP], sizeof(*frame)); 387 + frame = get_sigframe(&ksig->ka, regs->regs[REG_SP], sizeof(*frame)); 385 388 386 389 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame))) 387 - goto give_sigsegv; 390 + return -EFAULT; 388 391 389 392 signal = current_thread_info()->exec_domain 390 393 && current_thread_info()->exec_domain->signal_invmap ··· 395 400 396 401 /* Give up earlier as i386, in case */ 397 402 if (err) 398 - goto give_sigsegv; 403 + return -EFAULT; 399 404 400 405 if (_NSIG_WORDS > 1) { 401 406 err |= __copy_to_user(frame->extramask, &set->sig[1], ··· 403 408 404 409 /* Give up earlier as i386, in case */ 405 410 if (err) 406 - goto give_sigsegv; 411 + return -EFAULT; 407 412 408 413 /* Set up to return from userspace. If provided, use a stub 409 414 already in userspace. */ 410 - if (ka->sa.sa_flags & SA_RESTORER) { 415 + if (ksig->ka.sa.sa_flags & SA_RESTORER) { 411 416 /* 412 417 * On SH5 all edited pointers are subject to NEFF 413 418 */ 414 419 DEREF_REG_PR = neff_sign_extend((unsigned long) 415 - ka->sa.sa_restorer | 0x1); 420 + ksig->ka->sa.sa_restorer | 0x1); 416 421 } else { 417 422 /* 418 423 * Different approach on SH5. ··· 430 435 431 436 if (__copy_to_user(frame->retcode, 432 437 (void *)((unsigned long)sa_default_restorer & (~1)), 16) != 0) 433 - goto give_sigsegv; 438 + return -EFAULT; 434 439 435 440 /* Cohere the trampoline with the I-cache. */ 436 441 flush_cache_sigtramp(DEREF_REG_PR-1); ··· 455 460 regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->sc; 456 461 regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->sc; 457 462 458 - regs->pc = neff_sign_extend((unsigned long)ka->sa.sa_handler); 463 + regs->pc = neff_sign_extend((unsigned long)ksig->ka.sa.sa_handler); 459 464 460 465 set_fs(USER_DS); 461 466 ··· 466 471 DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff); 467 472 468 473 return 0; 469 - 470 - give_sigsegv: 471 - force_sigsegv(sig, current); 472 - return -EFAULT; 473 474 } 474 475 475 - static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info, 476 - sigset_t *set, struct pt_regs *regs) 476 + static int setup_rt_frame(struct ksignal *kig, sigset_t *set, 477 + struct pt_regs *regs) 477 478 { 478 479 struct rt_sigframe __user *frame; 479 - int err = 0; 480 + int err = 0, sig = ksig->sig; 480 481 int signal; 481 482 482 - frame = get_sigframe(ka, regs->regs[REG_SP], sizeof(*frame)); 483 + frame = get_sigframe(&ksig->ka, regs->regs[REG_SP], sizeof(*frame)); 483 484 484 485 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame))) 485 - goto give_sigsegv; 486 + return -EFAULT; 486 487 487 488 signal = current_thread_info()->exec_domain 488 489 && current_thread_info()->exec_domain->signal_invmap ··· 488 497 489 498 err |= __put_user(&frame->info, &frame->pinfo); 490 499 err |= __put_user(&frame->uc, &frame->puc); 491 - err |= copy_siginfo_to_user(&frame->info, info); 500 + err |= copy_siginfo_to_user(&frame->info, &ksig->info); 492 501 493 502 /* Give up earlier as i386, in case */ 494 503 if (err) 495 - goto give_sigsegv; 504 + return -EFAULT; 496 505 497 506 /* Create the ucontext. */ 498 507 err |= __put_user(0, &frame->uc.uc_flags); ··· 504 513 505 514 /* Give up earlier as i386, in case */ 506 515 if (err) 507 - goto give_sigsegv; 516 + return -EFAULT; 508 517 509 518 /* Set up to return from userspace. If provided, use a stub 510 519 already in userspace. */ 511 - if (ka->sa.sa_flags & SA_RESTORER) { 520 + if (ksig->ka.sa.sa_flags & SA_RESTORER) { 512 521 /* 513 522 * On SH5 all edited pointers are subject to NEFF 514 523 */ 515 524 DEREF_REG_PR = neff_sign_extend((unsigned long) 516 - ka->sa.sa_restorer | 0x1); 525 + ksig->ka.sa.sa_restorer | 0x1); 517 526 } else { 518 527 /* 519 528 * Different approach on SH5. ··· 531 540 532 541 if (__copy_to_user(frame->retcode, 533 542 (void *)((unsigned long)sa_default_rt_restorer & (~1)), 16) != 0) 534 - goto give_sigsegv; 543 + return -EFAULT; 535 544 536 545 /* Cohere the trampoline with the I-cache. */ 537 546 flush_icache_range(DEREF_REG_PR-1, DEREF_REG_PR-1+15); ··· 545 554 regs->regs[REG_ARG1] = signal; /* Arg for signal handler */ 546 555 regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->info; 547 556 regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->uc.uc_mcontext; 548 - regs->pc = neff_sign_extend((unsigned long)ka->sa.sa_handler); 557 + regs->pc = neff_sign_extend((unsigned long)ksig->ka.sa.sa_handler); 549 558 550 559 set_fs(USER_DS); 551 560 ··· 555 564 DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff); 556 565 557 566 return 0; 558 - 559 - give_sigsegv: 560 - force_sigsegv(sig, current); 561 - return -EFAULT; 562 567 } 563 568 564 569 /* 565 570 * OK, we're invoking a handler 566 571 */ 567 572 static void 568 - handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka, 569 - struct pt_regs * regs) 573 + handle_signal(struct ksignal *ksig, struct pt_regs *regs) 570 574 { 571 575 sigset_t *oldset = sigmask_to_save(); 572 576 int ret; 573 577 574 578 /* Set up the stack frame */ 575 - if (ka->sa.sa_flags & SA_SIGINFO) 576 - ret = setup_rt_frame(sig, ka, info, oldset, regs); 579 + if (ksig->ka.sa.sa_flags & SA_SIGINFO) 580 + ret = setup_rt_frame(ksig, oldset, regs); 577 581 else 578 - ret = setup_frame(sig, ka, oldset, regs); 582 + ret = setup_frame(ksig, oldset, regs); 579 583 580 - if (ret) 581 - return; 582 - 583 - signal_delivered(sig, info, ka, regs, 584 - test_thread_flag(TIF_SINGLESTEP)); 584 + signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLESTEP)); 585 585 } 586 586 587 587 asmlinkage void do_notify_resume(struct pt_regs *regs, unsigned long thread_info_flags)