tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

signal: Remove the task parameter from force_sig_fault

As synchronous exceptions really only make sense against the current
task (otherwise how are you synchronous) remove the task parameter
from from force_sig_fault to make it explicit that is what is going
on.

The two known exceptions that deliver a synchronous exception to a
stopped ptraced task have already been changed to
force_sig_fault_to_task.

The callers have been changed with the following emacs regular expression
(with obvious variations on the architectures that take more arguments)
to avoid typos:

force_sig_fault[(]\([^,]+\)[,]\([^,]+\)[,]\([^,]+\)[,]\W+current[)]
->
force_sig_fault(\1,\2,\3)

Signed-off-by: "Eric W. Biederman" <ebiederm@xmission.com>

Eric W. Biederman 2e1661d2 91ca180d

+137 -151
+1 -1
arch/alpha/kernel/traps.c
··· 402 402 { 403 403 die_if_kernel("Instruction fault", regs, 0, NULL); 404 404 405 - force_sig_fault(SIGILL, ILL_ILLOPC, (void __user *)regs->pc, 0, current); 405 + force_sig_fault(SIGILL, ILL_ILLOPC, (void __user *)regs->pc, 0); 406 406 } 407 407 408 408
+2 -2
arch/alpha/mm/fault.c
··· 221 221 up_read(&mm->mmap_sem); 222 222 /* Send a sigbus, regardless of whether we were in kernel 223 223 or user mode. */ 224 - force_sig_fault(SIGBUS, BUS_ADRERR, (void __user *) address, 0, current); 224 + force_sig_fault(SIGBUS, BUS_ADRERR, (void __user *) address, 0); 225 225 if (!user_mode(regs)) 226 226 goto no_context; 227 227 return; 228 228 229 229 do_sigsegv: 230 - force_sig_fault(SIGSEGV, si_code, (void __user *) address, 0, current); 230 + force_sig_fault(SIGSEGV, si_code, (void __user *) address, 0); 231 231 return; 232 232 233 233 #ifdef CONFIG_ALPHA_LARGE_VMALLOC
+1 -1
arch/arc/kernel/traps.c
··· 50 50 51 51 tsk->thread.fault_address = (__force unsigned int)addr; 52 52 53 - force_sig_fault(signo, si_code, addr, current); 53 + force_sig_fault(signo, si_code, addr); 54 54 55 55 } else { 56 56 /* If not due to copy_(to|from)_user, we are doomed */
+2 -2
arch/arc/mm/fault.c
··· 202 202 /* User mode accesses just cause a SIGSEGV */ 203 203 if (user_mode(regs)) { 204 204 tsk->thread.fault_address = address; 205 - force_sig_fault(SIGSEGV, si_code, (void __user *)address, current); 205 + force_sig_fault(SIGSEGV, si_code, (void __user *)address); 206 206 return; 207 207 } 208 208 ··· 237 237 goto no_context; 238 238 239 239 tsk->thread.fault_address = address; 240 - force_sig_fault(SIGBUS, BUS_ADRERR, (void __user *)address, current); 240 + force_sig_fault(SIGBUS, BUS_ADRERR, (void __user *)address); 241 241 }
+1 -1
arch/arm/kernel/ptrace.c
··· 204 204 void ptrace_break(struct pt_regs *regs) 205 205 { 206 206 force_sig_fault(SIGTRAP, TRAP_BRKPT, 207 - (void __user *)instruction_pointer(regs), current); 207 + (void __user *)instruction_pointer(regs)); 208 208 } 209 209 210 210 static int break_trap(struct pt_regs *regs, unsigned int instr)
+1 -1
arch/arm/kernel/traps.c
··· 372 372 current->thread.error_code = err; 373 373 current->thread.trap_no = trap; 374 374 375 - force_sig_fault(signo, si_code, addr, current); 375 + force_sig_fault(signo, si_code, addr); 376 376 } else { 377 377 die(str, regs, err); 378 378 }
+1 -1
arch/arm/mm/alignment.c
··· 948 948 goto fixup; 949 949 950 950 if (ai_usermode & UM_SIGNAL) { 951 - force_sig_fault(SIGBUS, BUS_ADRALN, (void __user *)addr, current); 951 + force_sig_fault(SIGBUS, BUS_ADRALN, (void __user *)addr); 952 952 } else { 953 953 /* 954 954 * We're about to disable the alignment trap and return to
+1 -1
arch/arm/mm/fault.c
··· 184 184 tsk->thread.address = addr; 185 185 tsk->thread.error_code = fsr; 186 186 tsk->thread.trap_no = 14; 187 - force_sig_fault(sig, code, (void __user *)addr, current); 187 + force_sig_fault(sig, code, (void __user *)addr); 188 188 } 189 189 190 190 void do_bad_area(unsigned long addr, unsigned int fsr, struct pt_regs *regs)
+1 -1
arch/arm64/kernel/traps.c
··· 259 259 if (signo == SIGKILL) 260 260 force_sig(SIGKILL); 261 261 else 262 - force_sig_fault(signo, code, addr, current); 262 + force_sig_fault(signo, code, addr); 263 263 } 264 264 265 265 void arm64_force_sig_mceerr(int code, void __user *addr, short lsb,
+1 -1
arch/c6x/kernel/traps.c
··· 253 253 die_if_kernel(except_info->kernel_str, regs, addr); 254 254 255 255 force_sig_fault(except_info->signo, except_info->code, 256 - (void __user *)addr, current); 256 + (void __user *)addr); 257 257 } 258 258 259 259 /*
+1 -1
arch/csky/abiv1/alignment.c
··· 283 283 do_exit(SIGKILL); 284 284 } 285 285 286 - force_sig_fault(SIGBUS, BUS_ADRALN, (void __user *)addr, current); 286 + force_sig_fault(SIGBUS, BUS_ADRALN, (void __user *)addr); 287 287 } 288 288 289 289 static struct ctl_table alignment_tbl[4] = {
+1 -1
arch/csky/abiv2/fpu.c
··· 124 124 code = FPE_FLTRES; 125 125 } 126 126 127 - force_sig_fault(sig, code, (void __user *)regs->pc, current); 127 + force_sig_fault(sig, code, (void __user *)regs->pc); 128 128 } 129 129 130 130 #define FMFVR_FPU_REGS(vrx, vry) \
+1 -1
arch/csky/kernel/traps.c
··· 106 106 pr_err("User mode Bus Error\n"); 107 107 show_regs(regs); 108 108 109 - force_sig_fault(SIGSEGV, 0, (void __user *)regs->pc, current); 109 + force_sig_fault(SIGSEGV, 0, (void __user *)regs->pc); 110 110 } 111 111 112 112 #define USR_BKPT 0x1464
+2 -2
arch/csky/mm/fault.c
··· 179 179 bad_area_nosemaphore: 180 180 /* User mode accesses just cause a SIGSEGV */ 181 181 if (user_mode(regs)) { 182 - force_sig_fault(SIGSEGV, si_code, (void __user *)address, current); 182 + force_sig_fault(SIGSEGV, si_code, (void __user *)address); 183 183 return; 184 184 } 185 185 ··· 212 212 if (!user_mode(regs)) 213 213 goto no_context; 214 214 215 - force_sig_fault(SIGBUS, BUS_ADRERR, (void __user *)address, current); 215 + force_sig_fault(SIGBUS, BUS_ADRERR, (void __user *)address); 216 216 }
+1 -1
arch/hexagon/kernel/traps.c
··· 420 420 * may want to use a different trap0 flavor. 421 421 */ 422 422 force_sig_fault(SIGTRAP, TRAP_BRKPT, 423 - (void __user *) pt_elr(regs), current); 423 + (void __user *) pt_elr(regs)); 424 424 } else { 425 425 #ifdef CONFIG_KGDB 426 426 kgdb_handle_exception(pt_cause(regs), SIGTRAP,
+2 -2
arch/hexagon/mm/vm_fault.c
··· 148 148 si_signo = SIGSEGV; 149 149 si_code = SEGV_ACCERR; 150 150 } 151 - force_sig_fault(si_signo, si_code, (void __user *)address, current); 151 + force_sig_fault(si_signo, si_code, (void __user *)address); 152 152 return; 153 153 154 154 bad_area: 155 155 up_read(&mm->mmap_sem); 156 156 157 157 if (user_mode(regs)) { 158 - force_sig_fault(SIGSEGV, si_code, (void __user *)address, current); 158 + force_sig_fault(SIGSEGV, si_code, (void __user *)address); 159 159 return; 160 160 } 161 161 /* Kernel-mode fault falls through */
+3 -3
arch/ia64/kernel/brl_emu.c
··· 197 197 */ 198 198 printk(KERN_DEBUG "Woah! Unimplemented Instruction Address Trap!\n"); 199 199 force_sig_fault(SIGILL, ILL_BADIADDR, (void __user *)NULL, 200 - 0, 0, 0, current); 200 + 0, 0, 0); 201 201 } else if (ia64_psr(regs)->tb) { 202 202 /* 203 203 * Branch Tracing is enabled. 204 204 * Force a taken branch signal. 205 205 */ 206 206 force_sig_fault(SIGTRAP, TRAP_BRANCH, (void __user *)NULL, 207 - 0, 0, 0, current); 207 + 0, 0, 0); 208 208 } else if (ia64_psr(regs)->ss) { 209 209 /* 210 210 * Single Step is enabled. 211 211 * Force a trace signal. 212 212 */ 213 213 force_sig_fault(SIGTRAP, TRAP_TRACE, (void __user *)NULL, 214 - 0, 0, 0, current); 214 + 0, 0, 0); 215 215 } 216 216 return rv; 217 217 }
+9 -9
arch/ia64/kernel/traps.c
··· 176 176 } 177 177 force_sig_fault(sig, code, 178 178 (void __user *) (regs->cr_iip + ia64_psr(regs)->ri), 179 - break_num, 0 /* clear __ISR_VALID */, 0, current); 179 + break_num, 0 /* clear __ISR_VALID */, 0); 180 180 } 181 181 182 182 /* ··· 353 353 } 354 354 force_sig_fault(SIGFPE, si_code, 355 355 (void __user *) (regs->cr_iip + ia64_psr(regs)->ri), 356 - 0, __ISR_VALID, isr, current); 356 + 0, __ISR_VALID, isr); 357 357 } 358 358 } else { 359 359 if (exception == -1) { ··· 373 373 } 374 374 force_sig_fault(SIGFPE, si_code, 375 375 (void __user *) (regs->cr_iip + ia64_psr(regs)->ri), 376 - 0, __ISR_VALID, isr, current); 376 + 0, __ISR_VALID, isr); 377 377 } 378 378 } 379 379 return 0; ··· 408 408 409 409 force_sig_fault(SIGILL, ILL_ILLOPC, 410 410 (void __user *) (regs.cr_iip + ia64_psr(&regs)->ri), 411 - 0, 0, 0, current); 411 + 0, 0, 0); 412 412 return rv; 413 413 } 414 414 ··· 483 483 + ia64_psr(&regs)->ri); 484 484 } 485 485 force_sig_fault(sig, code, addr, 486 - vector, __ISR_VALID, isr, current); 486 + vector, __ISR_VALID, isr); 487 487 return; 488 488 } else if (ia64_done_with_exception(&regs)) 489 489 return; ··· 493 493 case 31: /* Unsupported Data Reference */ 494 494 if (user_mode(&regs)) { 495 495 force_sig_fault(SIGILL, ILL_ILLOPN, (void __user *) iip, 496 - vector, __ISR_VALID, isr, current); 496 + vector, __ISR_VALID, isr); 497 497 return; 498 498 } 499 499 sprintf(buf, "Unsupported data reference"); ··· 542 542 == NOTIFY_STOP) 543 543 return; 544 544 force_sig_fault(SIGTRAP, si_code, (void __user *) ifa, 545 - 0, __ISR_VALID, isr, current); 545 + 0, __ISR_VALID, isr); 546 546 return; 547 547 548 548 case 32: /* fp fault */ ··· 550 550 result = handle_fpu_swa((vector == 32) ? 1 : 0, &regs, isr); 551 551 if ((result < 0) || (current->thread.flags & IA64_THREAD_FPEMU_SIGFPE)) { 552 552 force_sig_fault(SIGFPE, FPE_FLTINV, (void __user *) iip, 553 - 0, __ISR_VALID, isr, current); 553 + 0, __ISR_VALID, isr); 554 554 } 555 555 return; 556 556 ··· 578 578 if (user_mode(&regs)) { 579 579 force_sig_fault(SIGILL, ILL_BADIADDR, 580 580 (void __user *) iip, 581 - 0, 0, 0, current); 581 + 0, 0, 0); 582 582 return; 583 583 } 584 584 sprintf(buf, "Unimplemented Instruction Address fault");
+1 -1
arch/ia64/kernel/unaligned.c
··· 1537 1537 } 1538 1538 force_sigbus: 1539 1539 force_sig_fault(SIGBUS, BUS_ADRALN, (void __user *) ifa, 1540 - 0, 0, 0, current); 1540 + 0, 0, 0); 1541 1541 goto done; 1542 1542 }
+1 -1
arch/ia64/mm/fault.c
··· 249 249 } 250 250 if (user_mode(regs)) { 251 251 force_sig_fault(signal, code, (void __user *) address, 252 - 0, __ISR_VALID, isr, current); 252 + 0, __ISR_VALID, isr); 253 253 return; 254 254 } 255 255
+2 -2
arch/m68k/kernel/traps.c
··· 1127 1127 addr = (void __user*) fp->un.fmtb.daddr; 1128 1128 break; 1129 1129 } 1130 - force_sig_fault(sig, si_code, addr, current); 1130 + force_sig_fault(sig, si_code, addr); 1131 1131 } 1132 1132 1133 1133 void die_if_kernel (char *str, struct pt_regs *fp, int nr) ··· 1159 1159 #ifdef CONFIG_M68KFPU_EMU 1160 1160 asmlinkage void fpemu_signal(int signal, int code, void *addr) 1161 1161 { 1162 - force_sig_fault(signal, code, addr, current); 1162 + force_sig_fault(signal, code, addr); 1163 1163 } 1164 1164 #endif
+2 -2
arch/m68k/mm/fault.c
··· 30 30 pr_debug("send_fault_sig: %p,%d,%d\n", addr, signo, si_code); 31 31 32 32 if (user_mode(regs)) { 33 - force_sig_fault(signo, si_code, addr, current); 33 + force_sig_fault(signo, si_code, addr); 34 34 } else { 35 35 if (fixup_exception(regs)) 36 36 return -1; 37 37 38 38 //if (signo == SIGBUS) 39 - // force_sig_fault(si_signo, si_code, addr, current); 39 + // force_sig_fault(si_signo, si_code, addr); 40 40 41 41 /* 42 42 * Oops. The kernel tried to access some bad page. We'll have to
+1 -1
arch/microblaze/kernel/exceptions.c
··· 63 63 if (kernel_mode(regs)) 64 64 die("Exception in kernel mode", regs, signr); 65 65 66 - force_sig_fault(signr, code, (void __user *)addr, current); 66 + force_sig_fault(signr, code, (void __user *)addr); 67 67 } 68 68 69 69 asmlinkage void full_exception(struct pt_regs *regs, unsigned int type,
+1 -1
arch/microblaze/mm/fault.c
··· 289 289 do_sigbus: 290 290 up_read(&mm->mmap_sem); 291 291 if (user_mode(regs)) { 292 - force_sig_fault(SIGBUS, BUS_ADRERR, (void __user *)address, current); 292 + force_sig_fault(SIGBUS, BUS_ADRERR, (void __user *)address); 293 293 return; 294 294 } 295 295 bad_page_fault(regs, address, SIGBUS);
+6 -6
arch/mips/kernel/traps.c
··· 705 705 prev_state = exception_enter(); 706 706 die_if_kernel("Integer overflow", regs); 707 707 708 - force_sig_fault(SIGFPE, FPE_INTOVF, (void __user *)regs->cp0_epc, current); 708 + force_sig_fault(SIGFPE, FPE_INTOVF, (void __user *)regs->cp0_epc); 709 709 exception_exit(prev_state); 710 710 } 711 711 ··· 750 750 return 1; 751 751 752 752 case SIGBUS: 753 - force_sig_fault(SIGBUS, BUS_ADRERR, fault_addr, current); 753 + force_sig_fault(SIGBUS, BUS_ADRERR, fault_addr); 754 754 return 1; 755 755 756 756 case SIGSEGV: ··· 761 761 else 762 762 si_code = SEGV_MAPERR; 763 763 up_read(&current->mm->mmap_sem); 764 - force_sig_fault(SIGSEGV, si_code, fault_addr, current); 764 + force_sig_fault(SIGSEGV, si_code, fault_addr); 765 765 return 1; 766 766 767 767 default: ··· 943 943 die_if_kernel(b, regs); 944 944 force_sig_fault(SIGFPE, 945 945 code == BRK_DIVZERO ? FPE_INTDIV : FPE_INTOVF, 946 - (void __user *) regs->cp0_epc, current); 946 + (void __user *) regs->cp0_epc); 947 947 break; 948 948 case BRK_BUG: 949 949 die_if_kernel("Kernel bug detected", regs); ··· 968 968 scnprintf(b, sizeof(b), "%s instruction in kernel code", str); 969 969 die_if_kernel(b, regs); 970 970 if (si_code) { 971 - force_sig_fault(SIGTRAP, si_code, NULL, current); 971 + force_sig_fault(SIGTRAP, si_code, NULL); 972 972 } else { 973 973 force_sig(SIGTRAP); 974 974 } ··· 1521 1521 if (test_tsk_thread_flag(current, TIF_LOAD_WATCH)) { 1522 1522 mips_read_watch_registers(); 1523 1523 local_irq_enable(); 1524 - force_sig_fault(SIGTRAP, TRAP_HWBKPT, NULL, current); 1524 + force_sig_fault(SIGTRAP, TRAP_HWBKPT, NULL); 1525 1525 } else { 1526 1526 mips_clear_watch_registers(); 1527 1527 local_irq_enable();
+2 -2
arch/mips/mm/fault.c
··· 223 223 pr_cont("\n"); 224 224 } 225 225 current->thread.trap_nr = (regs->cp0_cause >> 2) & 0x1f; 226 - force_sig_fault(SIGSEGV, si_code, (void __user *)address, current); 226 + force_sig_fault(SIGSEGV, si_code, (void __user *)address); 227 227 return; 228 228 } 229 229 ··· 279 279 #endif 280 280 current->thread.trap_nr = (regs->cp0_cause >> 2) & 0x1f; 281 281 tsk->thread.cp0_badvaddr = address; 282 - force_sig_fault(SIGBUS, BUS_ADRERR, (void __user *)address, current); 282 + force_sig_fault(SIGBUS, BUS_ADRERR, (void __user *)address); 283 283 284 284 return; 285 285 #ifndef CONFIG_64BIT
+1 -1
arch/nds32/kernel/fpu.c
··· 246 246 } 247 247 248 248 force_sig_fault(si_signo, si_code, 249 - (void __user *)instruction_pointer(regs), current); 249 + (void __user *)instruction_pointer(regs)); 250 250 done: 251 251 own_fpu(); 252 252 }
+2 -2
arch/nds32/kernel/traps.c
··· 205 205 } 206 206 207 207 force_sig_fault(SIGILL, ILL_ILLTRP, 208 - (void __user *)instruction_pointer(regs) - 4, current); 208 + (void __user *)instruction_pointer(regs) - 4); 209 209 die_if_kernel("Oops - bad syscall", regs, n); 210 210 return regs->uregs[0]; 211 211 } ··· 263 263 tsk->thread.error_code = error_code; 264 264 265 265 force_sig_fault(SIGTRAP, si_code, 266 - (void __user *)instruction_pointer(regs), current); 266 + (void __user *)instruction_pointer(regs)); 267 267 } 268 268 269 269 void do_debug_trap(unsigned long entry, unsigned long addr,
+2 -2
arch/nds32/mm/fault.c
··· 271 271 tsk->thread.address = addr; 272 272 tsk->thread.error_code = error_code; 273 273 tsk->thread.trap_no = entry; 274 - force_sig_fault(SIGSEGV, si_code, (void __user *)addr, current); 274 + force_sig_fault(SIGSEGV, si_code, (void __user *)addr); 275 275 return; 276 276 } 277 277 ··· 340 340 tsk->thread.address = addr; 341 341 tsk->thread.error_code = error_code; 342 342 tsk->thread.trap_no = entry; 343 - force_sig_fault(SIGBUS, BUS_ADRERR, (void __user *)addr, current); 343 + force_sig_fault(SIGBUS, BUS_ADRERR, (void __user *)addr); 344 344 345 345 return; 346 346
+1 -1
arch/nios2/kernel/traps.c
··· 26 26 27 27 static void _send_sig(int signo, int code, unsigned long addr) 28 28 { 29 - force_sig_fault(signo, code, (void __user *) addr, current); 29 + force_sig_fault(signo, code, (void __user *) addr); 30 30 } 31 31 32 32 void die(const char *str, struct pt_regs *regs, long err)
+4 -4
arch/openrisc/kernel/traps.c
··· 249 249 250 250 asmlinkage void do_trap(struct pt_regs *regs, unsigned long address) 251 251 { 252 - force_sig_fault(SIGTRAP, TRAP_TRACE, (void __user *)address, current); 252 + force_sig_fault(SIGTRAP, TRAP_TRACE, (void __user *)address); 253 253 254 254 regs->pc += 4; 255 255 } ··· 258 258 { 259 259 if (user_mode(regs)) { 260 260 /* Send a SIGBUS */ 261 - force_sig_fault(SIGBUS, BUS_ADRALN, (void __user *)address, current); 261 + force_sig_fault(SIGBUS, BUS_ADRALN, (void __user *)address); 262 262 } else { 263 263 printk("KERNEL: Unaligned Access 0x%.8lx\n", address); 264 264 show_registers(regs); ··· 271 271 { 272 272 if (user_mode(regs)) { 273 273 /* Send a SIGBUS */ 274 - force_sig_fault(SIGBUS, BUS_ADRERR, (void __user *)address, current); 274 + force_sig_fault(SIGBUS, BUS_ADRERR, (void __user *)address); 275 275 } else { /* Kernel mode */ 276 276 printk("KERNEL: Bus error (SIGBUS) 0x%.8lx\n", address); 277 277 show_registers(regs); ··· 466 466 467 467 if (user_mode(regs)) { 468 468 /* Send a SIGILL */ 469 - force_sig_fault(SIGILL, ILL_ILLOPC, (void __user *)address, current); 469 + force_sig_fault(SIGILL, ILL_ILLOPC, (void __user *)address); 470 470 } else { /* Kernel mode */ 471 471 printk("KERNEL: Illegal instruction (SIGILL) 0x%.8lx\n", 472 472 address);
+2 -2
arch/openrisc/mm/fault.c
··· 213 213 /* User mode accesses just cause a SIGSEGV */ 214 214 215 215 if (user_mode(regs)) { 216 - force_sig_fault(SIGSEGV, si_code, (void __user *)address, current); 216 + force_sig_fault(SIGSEGV, si_code, (void __user *)address); 217 217 return; 218 218 } 219 219 ··· 278 278 * Send a sigbus, regardless of whether we were in kernel 279 279 * or user mode. 280 280 */ 281 - force_sig_fault(SIGBUS, BUS_ADRERR, (void __user *)address, current); 281 + force_sig_fault(SIGBUS, BUS_ADRERR, (void __user *)address); 282 282 283 283 /* Kernel mode? Handle exceptions or die */ 284 284 if (!user_mode(regs))
+7 -7
arch/parisc/kernel/traps.c
··· 275 275 static void handle_gdb_break(struct pt_regs *regs, int wot) 276 276 { 277 277 force_sig_fault(SIGTRAP, wot, 278 - (void __user *) (regs->iaoq[0] & ~3), current); 278 + (void __user *) (regs->iaoq[0] & ~3)); 279 279 } 280 280 281 281 static void handle_break(struct pt_regs *regs) ··· 609 609 si_code = ILL_PRVREG; 610 610 give_sigill: 611 611 force_sig_fault(SIGILL, si_code, 612 - (void __user *) regs->iaoq[0], current); 612 + (void __user *) regs->iaoq[0]); 613 613 return; 614 614 615 615 case 12: 616 616 /* Overflow Trap, let the userland signal handler do the cleanup */ 617 617 force_sig_fault(SIGFPE, FPE_INTOVF, 618 - (void __user *) regs->iaoq[0], current); 618 + (void __user *) regs->iaoq[0]); 619 619 return; 620 620 621 621 case 13: ··· 627 627 * to by si_addr. 628 628 */ 629 629 force_sig_fault(SIGFPE, FPE_CONDTRAP, 630 - (void __user *) regs->iaoq[0], current); 630 + (void __user *) regs->iaoq[0]); 631 631 return; 632 632 } 633 633 /* The kernel doesn't want to handle condition codes */ ··· 739 739 force_sig_fault(SIGSEGV, SEGV_MAPERR, 740 740 (code == 7)? 741 741 ((void __user *) regs->iaoq[0]) : 742 - ((void __user *) regs->ior), current); 742 + ((void __user *) regs->ior)); 743 743 return; 744 744 745 745 case 28: ··· 754 754 task_pid_nr(current), current->comm); 755 755 /* SIGBUS, for lack of a better one. */ 756 756 force_sig_fault(SIGBUS, BUS_OBJERR, 757 - (void __user *)regs->ior, current); 757 + (void __user *)regs->ior); 758 758 return; 759 759 } 760 760 pdc_chassis_send_status(PDC_CHASSIS_DIRECT_PANIC); ··· 770 770 code, fault_space, 771 771 task_pid_nr(current), current->comm); 772 772 force_sig_fault(SIGSEGV, SEGV_MAPERR, 773 - (void __user *)regs->ior, current); 773 + (void __user *)regs->ior); 774 774 return; 775 775 } 776 776 }
+2 -2
arch/parisc/kernel/unaligned.c
··· 690 690 if (ret == ERR_PAGEFAULT) 691 691 { 692 692 force_sig_fault(SIGSEGV, SEGV_MAPERR, 693 - (void __user *)regs->ior, current); 693 + (void __user *)regs->ior); 694 694 } 695 695 else 696 696 { 697 697 force_sigbus: 698 698 /* couldn't handle it ... */ 699 699 force_sig_fault(SIGBUS, BUS_ADRALN, 700 - (void __user *)regs->ior, current); 700 + (void __user *)regs->ior); 701 701 } 702 702 703 703 return;
+1 -1
arch/parisc/math-emu/driver.c
··· 117 117 memcpy(regs->fr, frcopy, sizeof regs->fr); 118 118 if (signalcode != 0) { 119 119 force_sig_fault(signalcode >> 24, signalcode & 0xffffff, 120 - (void __user *) regs->iaoq[0], current); 120 + (void __user *) regs->iaoq[0]); 121 121 return -1; 122 122 } 123 123
+1 -1
arch/parisc/mm/fault.c
··· 409 409 #endif 410 410 show_signal_msg(regs, code, address, tsk, vma); 411 411 412 - force_sig_fault(signo, si_code, (void __user *) address, current); 412 + force_sig_fault(signo, si_code, (void __user *) address); 413 413 return; 414 414 } 415 415
+1 -1
arch/powerpc/kernel/process.c
··· 643 643 hw_breakpoint_disable(); 644 644 645 645 /* Deliver the signal to userspace */ 646 - force_sig_fault(SIGTRAP, TRAP_HWBKPT, (void __user *)address, current); 646 + force_sig_fault(SIGTRAP, TRAP_HWBKPT, (void __user *)address); 647 647 } 648 648 #endif /* CONFIG_PPC_ADV_DEBUG_REGS */ 649 649
+2 -2
arch/powerpc/kernel/traps.c
··· 301 301 302 302 void user_single_step_report(struct pt_regs *regs) 303 303 { 304 - force_sig_fault(SIGTRAP, TRAP_TRACE, (void __user *)regs->nip, current); 304 + force_sig_fault(SIGTRAP, TRAP_TRACE, (void __user *)regs->nip); 305 305 } 306 306 307 307 static void show_signal_msg(int signr, struct pt_regs *regs, int code, ··· 367 367 if (!exception_common(signr, regs, code, addr)) 368 368 return; 369 369 370 - force_sig_fault(signr, code, (void __user *)addr, current); 370 + force_sig_fault(signr, code, (void __user *)addr); 371 371 } 372 372 373 373 /*
+1 -1
arch/powerpc/mm/fault.c
··· 187 187 } 188 188 189 189 #endif 190 - force_sig_fault(SIGBUS, BUS_ADRERR, (void __user *)address, current); 190 + force_sig_fault(SIGBUS, BUS_ADRERR, (void __user *)address); 191 191 return 0; 192 192 } 193 193
+4 -5
arch/powerpc/platforms/cell/spufs/fault.c
··· 44 44 45 45 switch (type) { 46 46 case SPE_EVENT_INVALID_DMA: 47 - force_sig_fault(SIGBUS, BUS_OBJERR, NULL, current); 47 + force_sig_fault(SIGBUS, BUS_OBJERR, NULL); 48 48 break; 49 49 case SPE_EVENT_SPE_DATA_STORAGE: 50 50 ctx->ops->restart_dma(ctx); 51 - force_sig_fault(SIGSEGV, SEGV_ACCERR, (void __user *)ea, 52 - current); 51 + force_sig_fault(SIGSEGV, SEGV_ACCERR, (void __user *)ea); 53 52 break; 54 53 case SPE_EVENT_DMA_ALIGNMENT: 55 54 /* DAR isn't set for an alignment fault :( */ 56 - force_sig_fault(SIGBUS, BUS_ADRALN, NULL, current); 55 + force_sig_fault(SIGBUS, BUS_ADRALN, NULL); 57 56 break; 58 57 case SPE_EVENT_SPE_ERROR: 59 58 force_sig_fault( 60 59 SIGILL, ILL_ILLOPC, 61 60 (void __user *)(unsigned long) 62 - ctx->ops->npc_read(ctx) - 4, current); 61 + ctx->ops->npc_read(ctx) - 4); 63 62 break; 64 63 } 65 64 }
+2 -2
arch/riscv/kernel/traps.c
··· 76 76 show_regs(regs); 77 77 } 78 78 79 - force_sig_fault(signo, code, (void __user *)addr, current); 79 + force_sig_fault(signo, code, (void __user *)addr); 80 80 } 81 81 82 82 static void do_trap_error(struct pt_regs *regs, int signo, int code, ··· 149 149 } 150 150 #endif /* CONFIG_GENERIC_BUG */ 151 151 152 - force_sig_fault(SIGTRAP, TRAP_BRKPT, (void __user *)(regs->sepc), current); 152 + force_sig_fault(SIGTRAP, TRAP_BRKPT, (void __user *)(regs->sepc)); 153 153 } 154 154 155 155 #ifdef CONFIG_GENERIC_BUG
+3 -3
arch/s390/kernel/traps.c
··· 45 45 void do_report_trap(struct pt_regs *regs, int si_signo, int si_code, char *str) 46 46 { 47 47 if (user_mode(regs)) { 48 - force_sig_fault(si_signo, si_code, get_trap_ip(regs), current); 48 + force_sig_fault(si_signo, si_code, get_trap_ip(regs)); 49 49 report_user_fault(regs, si_signo, 0); 50 50 } else { 51 51 const struct exception_table_entry *fixup; ··· 79 79 if (!current->ptrace) 80 80 return; 81 81 force_sig_fault(SIGTRAP, TRAP_HWBKPT, 82 - (void __force __user *) current->thread.per_event.address, current); 82 + (void __force __user *) current->thread.per_event.address); 83 83 } 84 84 NOKPROBE_SYMBOL(do_per_trap); 85 85 ··· 165 165 return; 166 166 if (*((__u16 *) opcode) == S390_BREAKPOINT_U16) { 167 167 if (current->ptrace) 168 - force_sig_fault(SIGTRAP, TRAP_BRKPT, location, current); 168 + force_sig_fault(SIGTRAP, TRAP_BRKPT, location); 169 169 else 170 170 signal = SIGILL; 171 171 #ifdef CONFIG_UPROBES
+2 -4
arch/s390/mm/fault.c
··· 243 243 { 244 244 report_user_fault(regs, SIGSEGV, 1); 245 245 force_sig_fault(SIGSEGV, si_code, 246 - (void __user *)(regs->int_parm_long & __FAIL_ADDR_MASK), 247 - current); 246 + (void __user *)(regs->int_parm_long & __FAIL_ADDR_MASK)); 248 247 } 249 248 250 249 const struct exception_table_entry *s390_search_extables(unsigned long addr) ··· 304 305 * or user mode. 305 306 */ 306 307 force_sig_fault(SIGBUS, BUS_ADRERR, 307 - (void __user *)(regs->int_parm_long & __FAIL_ADDR_MASK), 308 - current); 308 + (void __user *)(regs->int_parm_long & __FAIL_ADDR_MASK)); 309 309 } 310 310 311 311 static noinline int signal_return(struct pt_regs *regs)
+1 -1
arch/sh/kernel/hw_breakpoint.c
··· 338 338 /* Deliver the signal to userspace */ 339 339 if (!arch_check_bp_in_kernelspace(&bp->hw.info)) { 340 340 force_sig_fault(SIGTRAP, TRAP_HWBKPT, 341 - (void __user *)NULL, current); 341 + (void __user *)NULL); 342 342 } 343 343 344 344 rcu_read_unlock();
+2 -2
arch/sh/kernel/traps_32.c
··· 533 533 "access (PC %lx PR %lx)\n", current->comm, regs->pc, 534 534 regs->pr); 535 535 536 - force_sig_fault(SIGBUS, si_code, (void __user *)address, current); 536 + force_sig_fault(SIGBUS, si_code, (void __user *)address); 537 537 } else { 538 538 inc_unaligned_kernel_access(); 539 539 ··· 603 603 /* Let gcc know unhandled cases don't make it past here */ 604 604 return; 605 605 } 606 - force_sig_fault(SIGFPE, code, NULL, current); 606 + force_sig_fault(SIGFPE, code, NULL); 607 607 } 608 608 #endif 609 609
+1 -1
arch/sh/math-emu/math.c
··· 560 560 task_thread_info(tsk)->status |= TS_USEDFPU; 561 561 } else { 562 562 force_sig_fault(SIGFPE, FPE_FLTINV, 563 - (void __user *)regs->pc, current); 563 + (void __user *)regs->pc); 564 564 } 565 565 566 566 regs->pc = nextpc;
+1 -1
arch/sh/mm/fault.c
··· 41 41 static void 42 42 force_sig_info_fault(int si_signo, int si_code, unsigned long address) 43 43 { 44 - force_sig_fault(si_signo, si_code, (void __user *)address, current); 44 + force_sig_fault(si_signo, si_code, (void __user *)address); 45 45 } 46 46 47 47 /*
+1 -1
arch/sparc/kernel/process_64.c
··· 519 519 520 520 static void stack_unaligned(unsigned long sp) 521 521 { 522 - force_sig_fault(SIGBUS, BUS_ADRALN, (void __user *) sp, 0, current); 522 + force_sig_fault(SIGBUS, BUS_ADRALN, (void __user *) sp, 0); 523 523 } 524 524 525 525 static const char uwfault32[] = KERN_INFO \
+1 -1
arch/sparc/kernel/sys_sparc_32.c
··· 151 151 #ifdef DEBUG_SPARC_BREAKPOINT 152 152 printk ("TRAP: Entering kernel PC=%x, nPC=%x\n", regs->pc, regs->npc); 153 153 #endif 154 - force_sig_fault(SIGTRAP, TRAP_BRKPT, (void __user *)regs->pc, 0, current); 154 + force_sig_fault(SIGTRAP, TRAP_BRKPT, (void __user *)regs->pc, 0); 155 155 156 156 #ifdef DEBUG_SPARC_BREAKPOINT 157 157 printk ("TRAP: Returning to space: PC=%x nPC=%x\n", regs->pc, regs->npc);
+1 -1
arch/sparc/kernel/sys_sparc_64.c
··· 511 511 #ifdef DEBUG_SPARC_BREAKPOINT 512 512 printk ("TRAP: Entering kernel PC=%lx, nPC=%lx\n", regs->tpc, regs->tnpc); 513 513 #endif 514 - force_sig_fault(SIGTRAP, TRAP_BRKPT, (void __user *)regs->tpc, 0, current); 514 + force_sig_fault(SIGTRAP, TRAP_BRKPT, (void __user *)regs->tpc, 0); 515 515 #ifdef DEBUG_SPARC_BREAKPOINT 516 516 printk ("TRAP: Returning to space: PC=%lx nPC=%lx\n", regs->tpc, regs->tnpc); 517 517 #endif
+2 -2
arch/sparc/kernel/traps_32.c
··· 103 103 die_if_kernel("Kernel bad trap", regs); 104 104 105 105 force_sig_fault(SIGILL, ILL_ILLTRP, 106 - (void __user *)regs->pc, type - 0x80, current); 106 + (void __user *)regs->pc, type - 0x80); 107 107 } 108 108 109 109 void do_illegal_instruction(struct pt_regs *regs, unsigned long pc, unsigned long npc, ··· 327 327 printk("Register Access Exception at PC %08lx NPC %08lx PSR %08lx\n", 328 328 pc, npc, psr); 329 329 #endif 330 - force_sig_fault(SIGBUS, BUS_OBJERR, (void __user *)pc, 0, current); 330 + force_sig_fault(SIGBUS, BUS_OBJERR, (void __user *)pc, 0); 331 331 } 332 332 333 333 void handle_cp_disabled(struct pt_regs *regs, unsigned long pc, unsigned long npc,
+18 -21
arch/sparc/kernel/traps_64.c
··· 107 107 regs->tnpc &= 0xffffffff; 108 108 } 109 109 force_sig_fault(SIGILL, ILL_ILLTRP, 110 - (void __user *)regs->tpc, lvl, current); 110 + (void __user *)regs->tpc, lvl); 111 111 } 112 112 113 113 void bad_trap_tl1(struct pt_regs *regs, long lvl) ··· 201 201 regs->tnpc &= 0xffffffff; 202 202 } 203 203 force_sig_fault(SIGSEGV, SEGV_MAPERR, 204 - (void __user *)regs->tpc, 0, current); 204 + (void __user *)regs->tpc, 0); 205 205 out: 206 206 exception_exit(prev_state); 207 207 } ··· 236 236 regs->tpc &= 0xffffffff; 237 237 regs->tnpc &= 0xffffffff; 238 238 } 239 - force_sig_fault(SIGSEGV, SEGV_MAPERR, (void __user *) addr, 0, current); 239 + force_sig_fault(SIGSEGV, SEGV_MAPERR, (void __user *) addr, 0); 240 240 } 241 241 242 242 void sun4v_insn_access_exception_tl1(struct pt_regs *regs, unsigned long addr, unsigned long type_ctx) ··· 321 321 if (is_no_fault_exception(regs)) 322 322 return; 323 323 324 - force_sig_fault(SIGSEGV, SEGV_MAPERR, (void __user *)sfar, 0, current); 324 + force_sig_fault(SIGSEGV, SEGV_MAPERR, (void __user *)sfar, 0); 325 325 out: 326 326 exception_exit(prev_state); 327 327 } ··· 385 385 */ 386 386 switch (type) { 387 387 case HV_FAULT_TYPE_INV_ASI: 388 - force_sig_fault(SIGILL, ILL_ILLADR, (void __user *)addr, 0, 389 - current); 388 + force_sig_fault(SIGILL, ILL_ILLADR, (void __user *)addr, 0); 390 389 break; 391 390 case HV_FAULT_TYPE_MCD_DIS: 392 - force_sig_fault(SIGSEGV, SEGV_ACCADI, (void __user *)addr, 0, 393 - current); 391 + force_sig_fault(SIGSEGV, SEGV_ACCADI, (void __user *)addr, 0); 394 392 break; 395 393 default: 396 - force_sig_fault(SIGSEGV, SEGV_MAPERR, (void __user *)addr, 0, 397 - current); 394 + force_sig_fault(SIGSEGV, SEGV_MAPERR, (void __user *)addr, 0); 398 395 break; 399 396 } 400 397 } ··· 568 571 regs->tpc &= 0xffffffff; 569 572 regs->tnpc &= 0xffffffff; 570 573 } 571 - force_sig_fault(SIGBUS, BUS_OBJERR, (void *)0, 0, current); 574 + force_sig_fault(SIGBUS, BUS_OBJERR, (void *)0, 0); 572 575 } 573 576 574 577 void spitfire_access_error(struct pt_regs *regs, unsigned long status_encoded, unsigned long afar) ··· 2070 2073 * code 2071 2074 */ 2072 2075 force_sig_fault(SIGSEGV, SEGV_ADIDERR, (void __user *)ent.err_raddr, 2073 - 0, current); 2076 + 0); 2074 2077 } 2075 2078 2076 2079 /* We run with %pil set to PIL_NORMAL_MAX and PSTATE_IE enabled in %pstate. ··· 2184 2187 } 2185 2188 if (attrs & SUN4V_ERR_ATTRS_PIO) { 2186 2189 force_sig_fault(SIGBUS, BUS_ADRERR, 2187 - (void __user *)sun4v_get_vaddr(regs), 0, current); 2190 + (void __user *)sun4v_get_vaddr(regs), 0); 2188 2191 return true; 2189 2192 } 2190 2193 ··· 2341 2344 code = FPE_FLTRES; 2342 2345 } 2343 2346 force_sig_fault(SIGFPE, code, 2344 - (void __user *)regs->tpc, 0, current); 2347 + (void __user *)regs->tpc, 0); 2345 2348 } 2346 2349 } 2347 2350 ··· 2396 2399 regs->tnpc &= 0xffffffff; 2397 2400 } 2398 2401 force_sig_fault(SIGEMT, EMT_TAGOVF, 2399 - (void __user *)regs->tpc, 0, current); 2402 + (void __user *)regs->tpc, 0); 2400 2403 out: 2401 2404 exception_exit(prev_state); 2402 2405 } ··· 2416 2419 regs->tnpc &= 0xffffffff; 2417 2420 } 2418 2421 force_sig_fault(SIGFPE, FPE_INTDIV, 2419 - (void __user *)regs->tpc, 0, current); 2422 + (void __user *)regs->tpc, 0); 2420 2423 out: 2421 2424 exception_exit(prev_state); 2422 2425 } ··· 2612 2615 } 2613 2616 } 2614 2617 } 2615 - force_sig_fault(SIGILL, ILL_ILLOPC, (void __user *)pc, 0, current); 2618 + force_sig_fault(SIGILL, ILL_ILLOPC, (void __user *)pc, 0); 2616 2619 out: 2617 2620 exception_exit(prev_state); 2618 2621 } ··· 2632 2635 if (is_no_fault_exception(regs)) 2633 2636 return; 2634 2637 2635 - force_sig_fault(SIGBUS, BUS_ADRALN, (void __user *)sfar, 0, current); 2638 + force_sig_fault(SIGBUS, BUS_ADRALN, (void __user *)sfar, 0); 2636 2639 out: 2637 2640 exception_exit(prev_state); 2638 2641 } ··· 2650 2653 if (is_no_fault_exception(regs)) 2651 2654 return; 2652 2655 2653 - force_sig_fault(SIGBUS, BUS_ADRALN, (void __user *) addr, 0, current); 2656 + force_sig_fault(SIGBUS, BUS_ADRALN, (void __user *) addr, 0); 2654 2657 } 2655 2658 2656 2659 /* sun4v_mem_corrupt_detect_precise() - Handle precise exception on an ADI ··· 2697 2700 regs->tpc &= 0xffffffff; 2698 2701 regs->tnpc &= 0xffffffff; 2699 2702 } 2700 - force_sig_fault(SIGSEGV, SEGV_ADIPERR, (void __user *)addr, 0, current); 2703 + force_sig_fault(SIGSEGV, SEGV_ADIPERR, (void __user *)addr, 0); 2701 2704 } 2702 2705 2703 2706 void do_privop(struct pt_regs *regs) ··· 2713 2716 regs->tnpc &= 0xffffffff; 2714 2717 } 2715 2718 force_sig_fault(SIGILL, ILL_PRVOPC, 2716 - (void __user *)regs->tpc, 0, current); 2719 + (void __user *)regs->tpc, 0); 2717 2720 out: 2718 2721 exception_exit(prev_state); 2719 2722 }
+1 -1
arch/sparc/mm/fault_32.c
··· 131 131 show_signal_msg(regs, sig, code, 132 132 addr, current); 133 133 134 - force_sig_fault(sig, code, (void __user *) addr, 0, current); 134 + force_sig_fault(sig, code, (void __user *) addr, 0); 135 135 } 136 136 137 137 static unsigned long compute_si_addr(struct pt_regs *regs, int text_fault)
+1 -1
arch/sparc/mm/fault_64.c
··· 187 187 if (unlikely(show_unhandled_signals)) 188 188 show_signal_msg(regs, sig, code, addr, current); 189 189 190 - force_sig_fault(sig, code, (void __user *) addr, 0, current); 190 + force_sig_fault(sig, code, (void __user *) addr, 0); 191 191 } 192 192 193 193 static unsigned int get_fault_insn(struct pt_regs *regs, unsigned int insn)
+1 -2
arch/um/kernel/ptrace.c
··· 117 117 /* Send us the fake SIGTRAP */ 118 118 force_sig_fault(SIGTRAP, TRAP_BRKPT, 119 119 /* User-mode eip? */ 120 - UPT_IS_USER(regs) ? (void __user *) UPT_IP(regs) : NULL, 121 - current); 120 + UPT_IS_USER(regs) ? (void __user *) UPT_IP(regs) : NULL); 122 121 } 123 122 124 123 /*
+4 -8
arch/um/kernel/trap.c
··· 163 163 static void bad_segv(struct faultinfo fi, unsigned long ip) 164 164 { 165 165 current->thread.arch.faultinfo = fi; 166 - force_sig_fault(SIGSEGV, SEGV_ACCERR, (void __user *) FAULT_ADDRESS(fi), 167 - current); 166 + force_sig_fault(SIGSEGV, SEGV_ACCERR, (void __user *) FAULT_ADDRESS(fi)); 168 167 } 169 168 170 169 void fatal_sigsegv(void) ··· 267 268 268 269 if (err == -EACCES) { 269 270 current->thread.arch.faultinfo = fi; 270 - force_sig_fault(SIGBUS, BUS_ADRERR, (void __user *)address, 271 - current); 271 + force_sig_fault(SIGBUS, BUS_ADRERR, (void __user *)address); 272 272 } else { 273 273 BUG_ON(err != -EFAULT); 274 274 current->thread.arch.faultinfo = fi; 275 - force_sig_fault(SIGSEGV, si_code, (void __user *) address, 276 - current); 275 + force_sig_fault(SIGSEGV, si_code, (void __user *) address); 277 276 } 278 277 279 278 out: ··· 301 304 if ((err == 0) && (siginfo_layout(sig, code) == SIL_FAULT)) { 302 305 struct faultinfo *fi = UPT_FAULTINFO(regs); 303 306 current->thread.arch.faultinfo = *fi; 304 - force_sig_fault(sig, code, (void __user *)FAULT_ADDRESS(*fi), 305 - current); 307 + force_sig_fault(sig, code, (void __user *)FAULT_ADDRESS(*fi)); 306 308 } else { 307 309 printk(KERN_ERR "Attempted to relay unknown signal %d (si_code = %d) with errno %d\n", 308 310 sig, code, err);
+1 -1
arch/unicore32/kernel/traps.c
··· 248 248 current->thread.error_code = err; 249 249 current->thread.trap_no = trap; 250 250 251 - force_sig_fault(sig, code, addr, current); 251 + force_sig_fault(sig, code, addr); 252 252 } else 253 253 die(str, regs, err); 254 254 }
+1 -1
arch/unicore32/mm/fault.c
··· 124 124 tsk->thread.address = addr; 125 125 tsk->thread.error_code = fsr; 126 126 tsk->thread.trap_no = 14; 127 - force_sig_fault(sig, code, (void __user *)addr, current); 127 + force_sig_fault(sig, code, (void __user *)addr); 128 128 } 129 129 130 130 void do_bad_area(unsigned long addr, unsigned int fsr, struct pt_regs *regs)
+1 -1
arch/x86/entry/vsyscall/vsyscall_64.c
··· 106 106 thread->cr2 = ptr; 107 107 thread->trap_nr = X86_TRAP_PF; 108 108 109 - force_sig_fault(SIGSEGV, SEGV_MAPERR, (void __user *)ptr, current); 109 + force_sig_fault(SIGSEGV, SEGV_MAPERR, (void __user *)ptr); 110 110 return false; 111 111 } else { 112 112 return true;
+1 -1
arch/x86/kernel/ptrace.c
··· 1369 1369 1370 1370 /* Send us the fake SIGTRAP */ 1371 1371 force_sig_fault(SIGTRAP, si_code, 1372 - user_mode(regs) ? (void __user *)regs->ip : NULL, current); 1372 + user_mode(regs) ? (void __user *)regs->ip : NULL); 1373 1373 } 1374 1374 1375 1375 void user_single_step_report(struct pt_regs *regs)
+2 -2
arch/x86/kernel/traps.c
··· 256 256 if (!sicode) 257 257 force_sig(signr); 258 258 else 259 - force_sig_fault(signr, sicode, addr, current); 259 + force_sig_fault(signr, sicode, addr); 260 260 } 261 261 NOKPROBE_SYMBOL(do_trap); 262 262 ··· 856 856 return; 857 857 858 858 force_sig_fault(SIGFPE, si_code, 859 - (void __user *)uprobe_get_trap_addr(regs), current); 859 + (void __user *)uprobe_get_trap_addr(regs)); 860 860 } 861 861 862 862 dotraplinkage void do_coprocessor_error(struct pt_regs *regs, long error_code)
+1 -1
arch/x86/kernel/umip.c
··· 277 277 tsk->thread.error_code = X86_PF_USER | X86_PF_WRITE; 278 278 tsk->thread.trap_nr = X86_TRAP_PF; 279 279 280 - force_sig_fault(SIGSEGV, SEGV_MAPERR, addr, current); 280 + force_sig_fault(SIGSEGV, SEGV_MAPERR, addr); 281 281 282 282 if (!(show_unhandled_signals && unhandled_signal(tsk, SIGSEGV))) 283 283 return;
+3 -4
arch/x86/mm/fault.c
··· 756 756 set_signal_archinfo(address, error_code); 757 757 758 758 /* XXX: hwpoison faults will set the wrong code. */ 759 - force_sig_fault(signal, si_code, (void __user *)address, 760 - current); 759 + force_sig_fault(signal, si_code, (void __user *)address); 761 760 } 762 761 763 762 /* ··· 917 918 if (si_code == SEGV_PKUERR) 918 919 force_sig_pkuerr((void __user *)address, pkey); 919 920 920 - force_sig_fault(SIGSEGV, si_code, (void __user *)address, current); 921 + force_sig_fault(SIGSEGV, si_code, (void __user *)address); 921 922 922 923 return; 923 924 } ··· 1043 1044 return; 1044 1045 } 1045 1046 #endif 1046 - force_sig_fault(SIGBUS, BUS_ADRERR, (void __user *)address, current); 1047 + force_sig_fault(SIGBUS, BUS_ADRERR, (void __user *)address); 1047 1048 } 1048 1049 1049 1050 static noinline void
+1 -1
arch/xtensa/kernel/traps.c
··· 330 330 "(pid = %d, pc = %#010lx)\n", 331 331 regs->excvaddr, current->comm, 332 332 task_pid_nr(current), regs->pc); 333 - force_sig_fault(SIGBUS, BUS_ADRALN, (void *) regs->excvaddr, current); 333 + force_sig_fault(SIGBUS, BUS_ADRALN, (void *) regs->excvaddr); 334 334 } 335 335 #endif 336 336
+2 -2
arch/xtensa/mm/fault.c
··· 157 157 if (user_mode(regs)) { 158 158 current->thread.bad_vaddr = address; 159 159 current->thread.error_code = is_write; 160 - force_sig_fault(SIGSEGV, code, (void *) address, current); 160 + force_sig_fault(SIGSEGV, code, (void *) address); 161 161 return; 162 162 } 163 163 bad_page_fault(regs, address, SIGSEGV); ··· 182 182 * or user mode. 183 183 */ 184 184 current->thread.bad_vaddr = address; 185 - force_sig_fault(SIGBUS, BUS_ADRERR, (void *) address, current); 185 + force_sig_fault(SIGBUS, BUS_ADRERR, (void *) address); 186 186 187 187 /* Kernel mode? Handle exceptions or die */ 188 188 if (!user_mode(regs))
+1 -2
include/linux/sched/signal.h
··· 313 313 , struct task_struct *t); 314 314 int force_sig_fault(int sig, int code, void __user *addr 315 315 ___ARCH_SI_TRAPNO(int trapno) 316 - ___ARCH_SI_IA64(int imm, unsigned int flags, unsigned long isr) 317 - , struct task_struct *t); 316 + ___ARCH_SI_IA64(int imm, unsigned int flags, unsigned long isr)); 318 317 int send_sig_fault(int sig, int code, void __user *addr 319 318 ___ARCH_SI_TRAPNO(int trapno) 320 319 ___ARCH_SI_IA64(int imm, unsigned int flags, unsigned long isr)
+2 -3
kernel/signal.c
··· 1645 1645 1646 1646 int force_sig_fault(int sig, int code, void __user *addr 1647 1647 ___ARCH_SI_TRAPNO(int trapno) 1648 - ___ARCH_SI_IA64(int imm, unsigned int flags, unsigned long isr) 1649 - , struct task_struct *t) 1648 + ___ARCH_SI_IA64(int imm, unsigned int flags, unsigned long isr)) 1650 1649 { 1651 1650 return force_sig_fault_to_task(sig, code, addr 1652 1651 ___ARCH_SI_TRAPNO(trapno) 1653 - ___ARCH_SI_IA64(imm, flags, isr), t); 1652 + ___ARCH_SI_IA64(imm, flags, isr), current); 1654 1653 } 1655 1654 1656 1655 int send_sig_fault(int sig, int code, void __user *addr