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

[PATCH] convert that currently tests _NSIG directly to use valid_signal()

Convert most of the current code that uses _NSIG directly to instead use
valid_signal(). This avoids gcc -W warnings and off-by-one errors.

Signed-off-by: Jesper Juhl <juhl-lkml@dif.dk>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

authored by

Jesper Juhl and committed by
Linus Torvalds 7ed20e1a e5bdd883

+90 -59
+3 -2
arch/alpha/kernel/ptrace.c
··· 14 14 #include <linux/user.h> 15 15 #include <linux/slab.h> 16 16 #include <linux/security.h> 17 + #include <linux/signal.h> 17 18 18 19 #include <asm/uaccess.h> 19 20 #include <asm/pgtable.h> ··· 336 335 /* continue and stop at next (return from) syscall */ 337 336 case PTRACE_CONT: /* restart after signal. */ 338 337 ret = -EIO; 339 - if ((unsigned long) data > _NSIG) 338 + if (!valid_signal(data)) 340 339 break; 341 340 if (request == PTRACE_SYSCALL) 342 341 set_tsk_thread_flag(child, TIF_SYSCALL_TRACE); ··· 366 365 367 366 case PTRACE_SINGLESTEP: /* execute single instruction. */ 368 367 ret = -EIO; 369 - if ((unsigned long) data > _NSIG) 368 + if (!valid_signal(data)) 370 369 break; 371 370 /* Mark single stepping. */ 372 371 child->thread_info->bpt_nsaved = -1;
+3 -2
arch/arm/kernel/ptrace.c
··· 19 19 #include <linux/user.h> 20 20 #include <linux/security.h> 21 21 #include <linux/init.h> 22 + #include <linux/signal.h> 22 23 23 24 #include <asm/uaccess.h> 24 25 #include <asm/pgtable.h> ··· 694 693 case PTRACE_SYSCALL: 695 694 case PTRACE_CONT: 696 695 ret = -EIO; 697 - if ((unsigned long) data > _NSIG) 696 + if (!valid_signal(data)) 698 697 break; 699 698 if (request == PTRACE_SYSCALL) 700 699 set_tsk_thread_flag(child, TIF_SYSCALL_TRACE); ··· 729 728 */ 730 729 case PTRACE_SINGLESTEP: 731 730 ret = -EIO; 732 - if ((unsigned long) data > _NSIG) 731 + if (!valid_signal(data)) 733 732 break; 734 733 child->ptrace |= PT_SINGLESTEP; 735 734 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
+3 -2
arch/arm26/kernel/ptrace.c
··· 18 18 #include <linux/ptrace.h> 19 19 #include <linux/user.h> 20 20 #include <linux/security.h> 21 + #include <linux/signal.h> 21 22 22 23 #include <asm/uaccess.h> 23 24 #include <asm/pgtable.h> ··· 592 591 case PTRACE_SYSCALL: 593 592 case PTRACE_CONT: 594 593 ret = -EIO; 595 - if ((unsigned long) data > _NSIG) 594 + if (!valid_signal(data)) 596 595 break; 597 596 if (request == PTRACE_SYSCALL) 598 597 set_tsk_thread_flag(child, TIF_SYSCALL_TRACE); ··· 627 626 */ 628 627 case PTRACE_SINGLESTEP: 629 628 ret = -EIO; 630 - if ((unsigned long) data > _NSIG) 629 + if (!valid_signal(data)) 631 630 break; 632 631 child->ptrace |= PT_SINGLESTEP; 633 632 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
+3 -2
arch/cris/arch-v10/kernel/ptrace.c
··· 10 10 #include <linux/errno.h> 11 11 #include <linux/ptrace.h> 12 12 #include <linux/user.h> 13 + #include <linux/signal.h> 13 14 14 15 #include <asm/uaccess.h> 15 16 #include <asm/page.h> ··· 185 184 case PTRACE_CONT: 186 185 ret = -EIO; 187 186 188 - if ((unsigned long) data > _NSIG) 187 + if (!valid_signal(data)) 189 188 break; 190 189 191 190 if (request == PTRACE_SYSCALL) { ··· 220 219 case PTRACE_SINGLESTEP: 221 220 ret = -EIO; 222 221 223 - if ((unsigned long) data > _NSIG) 222 + if (!valid_signal(data)) 224 223 break; 225 224 226 225 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
+3 -2
arch/frv/kernel/ptrace.c
··· 20 20 #include <linux/user.h> 21 21 #include <linux/config.h> 22 22 #include <linux/security.h> 23 + #include <linux/signal.h> 23 24 24 25 #include <asm/uaccess.h> 25 26 #include <asm/page.h> ··· 240 239 case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall */ 241 240 case PTRACE_CONT: /* restart after signal. */ 242 241 ret = -EIO; 243 - if ((unsigned long) data > _NSIG) 242 + if (!valid_signal(data)) 244 243 break; 245 244 if (request == PTRACE_SYSCALL) 246 245 set_tsk_thread_flag(child, TIF_SYSCALL_TRACE); ··· 268 267 269 268 case PTRACE_SINGLESTEP: /* set the trap flag. */ 270 269 ret = -EIO; 271 - if ((unsigned long) data > _NSIG) 270 + if (!valid_signal(data)) 272 271 break; 273 272 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); 274 273 ptrace_enable(child);
+3 -2
arch/h8300/kernel/ptrace.c
··· 24 24 #include <linux/ptrace.h> 25 25 #include <linux/user.h> 26 26 #include <linux/config.h> 27 + #include <linux/signal.h> 27 28 28 29 #include <asm/uaccess.h> 29 30 #include <asm/page.h> ··· 172 171 case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall */ 173 172 case PTRACE_CONT: { /* restart after signal. */ 174 173 ret = -EIO; 175 - if ((unsigned long) data >= _NSIG) 174 + if (!valid_signal(data)) 176 175 break ; 177 176 if (request == PTRACE_SYSCALL) 178 177 set_tsk_thread_flag(child, TIF_SYSCALL_TRACE); ··· 203 202 204 203 case PTRACE_SINGLESTEP: { /* set the trap flag. */ 205 204 ret = -EIO; 206 - if ((unsigned long) data > _NSIG) 205 + if (!valid_signal(data)) 207 206 break; 208 207 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); 209 208 child->exit_code = data;
+3 -2
arch/i386/kernel/ptrace.c
··· 16 16 #include <linux/security.h> 17 17 #include <linux/audit.h> 18 18 #include <linux/seccomp.h> 19 + #include <linux/signal.h> 19 20 20 21 #include <asm/uaccess.h> 21 22 #include <asm/pgtable.h> ··· 512 511 case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall */ 513 512 case PTRACE_CONT: /* restart after signal. */ 514 513 ret = -EIO; 515 - if ((unsigned long) data > _NSIG) 514 + if (!valid_signal(data)) 516 515 break; 517 516 if (request == PTRACE_SYSCALL) { 518 517 set_tsk_thread_flag(child, TIF_SYSCALL_TRACE); ··· 544 543 545 544 case PTRACE_SINGLESTEP: /* set the trap flag. */ 546 545 ret = -EIO; 547 - if ((unsigned long) data > _NSIG) 546 + if (!valid_signal(data)) 548 547 break; 549 548 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); 550 549 set_singlestep(child);
+3 -2
arch/ia64/kernel/ptrace.c
··· 17 17 #include <linux/user.h> 18 18 #include <linux/security.h> 19 19 #include <linux/audit.h> 20 + #include <linux/signal.h> 20 21 21 22 #include <asm/pgtable.h> 22 23 #include <asm/processor.h> ··· 1482 1481 case PTRACE_CONT: 1483 1482 /* restart after signal. */ 1484 1483 ret = -EIO; 1485 - if (data > _NSIG) 1484 + if (!valid_signal(data)) 1486 1485 goto out_tsk; 1487 1486 if (request == PTRACE_SYSCALL) 1488 1487 set_tsk_thread_flag(child, TIF_SYSCALL_TRACE); ··· 1521 1520 /* let child execute for one instruction */ 1522 1521 case PTRACE_SINGLEBLOCK: 1523 1522 ret = -EIO; 1524 - if (data > _NSIG) 1523 + if (!valid_signal(data)) 1525 1524 goto out_tsk; 1526 1525 1527 1526 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
+3 -2
arch/m32r/kernel/ptrace.c
··· 24 24 #include <linux/ptrace.h> 25 25 #include <linux/user.h> 26 26 #include <linux/string.h> 27 + #include <linux/signal.h> 27 28 28 29 #include <asm/cacheflush.h> 29 30 #include <asm/io.h> ··· 666 665 case PTRACE_SYSCALL: 667 666 case PTRACE_CONT: 668 667 ret = -EIO; 669 - if ((unsigned long) data > _NSIG) 668 + if (!valid_signal(data)) 670 669 break; 671 670 if (request == PTRACE_SYSCALL) 672 671 set_tsk_thread_flag(child, TIF_SYSCALL_TRACE); ··· 701 700 unsigned long pc, insn; 702 701 703 702 ret = -EIO; 704 - if ((unsigned long) data > _NSIG) 703 + if (!valid_signal(data)) 705 704 break; 706 705 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); 707 706 if ((child->ptrace & PT_DTRACE) == 0) {
+3 -2
arch/m68k/kernel/ptrace.c
··· 19 19 #include <linux/ptrace.h> 20 20 #include <linux/user.h> 21 21 #include <linux/config.h> 22 + #include <linux/signal.h> 22 23 23 24 #include <asm/uaccess.h> 24 25 #include <asm/page.h> ··· 252 251 long tmp; 253 252 254 253 ret = -EIO; 255 - if ((unsigned long) data > _NSIG) 254 + if (!valid_signal(data)) 256 255 break; 257 256 if (request == PTRACE_SYSCALL) { 258 257 child->thread.work.syscall_trace = ~0; ··· 293 292 long tmp; 294 293 295 294 ret = -EIO; 296 - if ((unsigned long) data > _NSIG) 295 + if (!valid_signal(data)) 297 296 break; 298 297 child->thread.work.syscall_trace = 0; 299 298 tmp = get_reg(child, PT_SR) | (TRACE_BITS << 16);
+3 -2
arch/m68knommu/kernel/ptrace.c
··· 19 19 #include <linux/ptrace.h> 20 20 #include <linux/user.h> 21 21 #include <linux/config.h> 22 + #include <linux/signal.h> 22 23 23 24 #include <asm/uaccess.h> 24 25 #include <asm/page.h> ··· 241 240 long tmp; 242 241 243 242 ret = -EIO; 244 - if ((unsigned long) data > _NSIG) 243 + if (!valid_signal(data)) 245 244 break; 246 245 if (request == PTRACE_SYSCALL) 247 246 set_tsk_thread_flag(child, TIF_SYSCALL_TRACE); ··· 279 278 long tmp; 280 279 281 280 ret = -EIO; 282 - if ((unsigned long) data > _NSIG) 281 + if (!valid_signal(data)) 283 282 break; 284 283 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); 285 284 tmp = get_reg(child, PT_SR) | (TRACE_BITS << 16);
+2 -1
arch/mips/kernel/ptrace.c
··· 26 26 #include <linux/smp_lock.h> 27 27 #include <linux/user.h> 28 28 #include <linux/security.h> 29 + #include <linux/signal.h> 29 30 30 31 #include <asm/cpu.h> 31 32 #include <asm/fpu.h> ··· 258 257 case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall */ 259 258 case PTRACE_CONT: { /* restart after signal. */ 260 259 ret = -EIO; 261 - if ((unsigned long) data > _NSIG) 260 + if (!valid_signal(data)) 262 261 break; 263 262 if (request == PTRACE_SYSCALL) { 264 263 set_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
+2 -1
arch/mips/kernel/ptrace32.c
··· 24 24 #include <linux/smp_lock.h> 25 25 #include <linux/user.h> 26 26 #include <linux/security.h> 27 + #include <linux/signal.h> 27 28 28 29 #include <asm/cpu.h> 29 30 #include <asm/fpu.h> ··· 242 241 case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall */ 243 242 case PTRACE_CONT: { /* restart after signal. */ 244 243 ret = -EIO; 245 - if ((unsigned int) data > _NSIG) 244 + if (!valid_signal(data)) 246 245 break; 247 246 if (request == PTRACE_SYSCALL) { 248 247 set_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
+4 -3
arch/parisc/kernel/ptrace.c
··· 17 17 #include <linux/personality.h> 18 18 #include <linux/security.h> 19 19 #include <linux/compat.h> 20 + #include <linux/signal.h> 20 21 21 22 #include <asm/uaccess.h> 22 23 #include <asm/pgtable.h> ··· 286 285 ret = -EIO; 287 286 DBG("sys_ptrace(%s)\n", 288 287 request == PTRACE_SYSCALL ? "SYSCALL" : "CONT"); 289 - if ((unsigned long) data > _NSIG) 288 + if (!valid_signal(data)) 290 289 goto out_tsk; 291 290 child->ptrace &= ~(PT_SINGLESTEP|PT_BLOCKSTEP); 292 291 if (request == PTRACE_SYSCALL) { ··· 312 311 case PTRACE_SINGLEBLOCK: 313 312 DBG("sys_ptrace(SINGLEBLOCK)\n"); 314 313 ret = -EIO; 315 - if ((unsigned long) data > _NSIG) 314 + if (!valid_signal(data)) 316 315 goto out_tsk; 317 316 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); 318 317 child->ptrace &= ~PT_SINGLESTEP; ··· 329 328 case PTRACE_SINGLESTEP: 330 329 DBG("sys_ptrace(SINGLESTEP)\n"); 331 330 ret = -EIO; 332 - if ((unsigned long) data > _NSIG) 331 + if (!valid_signal(data)) 333 332 goto out_tsk; 334 333 335 334 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
+3 -2
arch/ppc/kernel/ptrace.c
··· 26 26 #include <linux/ptrace.h> 27 27 #include <linux/user.h> 28 28 #include <linux/security.h> 29 + #include <linux/signal.h> 29 30 30 31 #include <asm/uaccess.h> 31 32 #include <asm/page.h> ··· 357 356 case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall */ 358 357 case PTRACE_CONT: { /* restart after signal. */ 359 358 ret = -EIO; 360 - if ((unsigned long) data > _NSIG) 359 + if (!valid_signal(data)) 361 360 break; 362 361 if (request == PTRACE_SYSCALL) { 363 362 set_tsk_thread_flag(child, TIF_SYSCALL_TRACE); ··· 390 389 391 390 case PTRACE_SINGLESTEP: { /* set the trap flag. */ 392 391 ret = -EIO; 393 - if ((unsigned long) data > _NSIG) 392 + if (!valid_signal(data)) 394 393 break; 395 394 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); 396 395 set_single_step(child);
+3 -2
arch/ppc64/kernel/ptrace.c
··· 28 28 #include <linux/security.h> 29 29 #include <linux/audit.h> 30 30 #include <linux/seccomp.h> 31 + #include <linux/signal.h> 31 32 32 33 #include <asm/uaccess.h> 33 34 #include <asm/page.h> ··· 163 162 case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall */ 164 163 case PTRACE_CONT: { /* restart after signal. */ 165 164 ret = -EIO; 166 - if ((unsigned long) data > _NSIG) 165 + if (!valid_signal(data)) 167 166 break; 168 167 if (request == PTRACE_SYSCALL) 169 168 set_tsk_thread_flag(child, TIF_SYSCALL_TRACE); ··· 195 194 196 195 case PTRACE_SINGLESTEP: { /* set the trap flag. */ 197 196 ret = -EIO; 198 - if ((unsigned long) data > _NSIG) 197 + if (!valid_signal(data)) 199 198 break; 200 199 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); 201 200 set_single_step(child);
+3 -2
arch/ppc64/kernel/ptrace32.c
··· 26 26 #include <linux/ptrace.h> 27 27 #include <linux/user.h> 28 28 #include <linux/security.h> 29 + #include <linux/signal.h> 29 30 30 31 #include <asm/uaccess.h> 31 32 #include <asm/page.h> ··· 294 293 case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall */ 295 294 case PTRACE_CONT: { /* restart after signal. */ 296 295 ret = -EIO; 297 - if ((unsigned long) data > _NSIG) 296 + if (!valid_signal(data)) 298 297 break; 299 298 if (request == PTRACE_SYSCALL) 300 299 set_tsk_thread_flag(child, TIF_SYSCALL_TRACE); ··· 326 325 327 326 case PTRACE_SINGLESTEP: { /* set the trap flag. */ 328 327 ret = -EIO; 329 - if ((unsigned long) data > _NSIG) 328 + if (!valid_signal(data)) 330 329 break; 331 330 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); 332 331 set_single_step(child);
+3 -2
arch/s390/kernel/ptrace.c
··· 32 32 #include <linux/user.h> 33 33 #include <linux/security.h> 34 34 #include <linux/audit.h> 35 + #include <linux/signal.h> 35 36 36 37 #include <asm/segment.h> 37 38 #include <asm/page.h> ··· 610 609 /* continue and stop at next (return from) syscall */ 611 610 case PTRACE_CONT: 612 611 /* restart after signal. */ 613 - if ((unsigned long) data >= _NSIG) 612 + if (!valid_signal(data)) 614 613 return -EIO; 615 614 if (request == PTRACE_SYSCALL) 616 615 set_tsk_thread_flag(child, TIF_SYSCALL_TRACE); ··· 638 637 639 638 case PTRACE_SINGLESTEP: 640 639 /* set the trap flag. */ 641 - if ((unsigned long) data >= _NSIG) 640 + if (!valid_signal(data)) 642 641 return -EIO; 643 642 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); 644 643 child->exit_code = data;
+3 -2
arch/sh/kernel/ptrace.c
··· 20 20 #include <linux/user.h> 21 21 #include <linux/slab.h> 22 22 #include <linux/security.h> 23 + #include <linux/signal.h> 23 24 24 25 #include <asm/io.h> 25 26 #include <asm/uaccess.h> ··· 198 197 case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall */ 199 198 case PTRACE_CONT: { /* restart after signal. */ 200 199 ret = -EIO; 201 - if ((unsigned long) data > _NSIG) 200 + if (!valid_signal(data)) 202 201 break; 203 202 if (request == PTRACE_SYSCALL) 204 203 set_tsk_thread_flag(child, TIF_SYSCALL_TRACE); ··· 229 228 struct pt_regs *dummy = NULL; 230 229 231 230 ret = -EIO; 232 - if ((unsigned long) data > _NSIG) 231 + if (!valid_signal(data)) 233 232 break; 234 233 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); 235 234 if ((child->ptrace & PT_DTRACE) == 0) {
+3 -2
arch/sh64/kernel/ptrace.c
··· 27 27 #include <linux/errno.h> 28 28 #include <linux/ptrace.h> 29 29 #include <linux/user.h> 30 + #include <linux/signal.h> 30 31 31 32 #include <asm/io.h> 32 33 #include <asm/uaccess.h> ··· 256 255 case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall */ 257 256 case PTRACE_CONT: { /* restart after signal. */ 258 257 ret = -EIO; 259 - if ((unsigned long) data > _NSIG) 258 + if (!valid_signal(data)) 260 259 break; 261 260 if (request == PTRACE_SYSCALL) 262 261 set_tsk_thread_flag(child, TIF_SYSCALL_TRACE); ··· 286 285 struct pt_regs *regs; 287 286 288 287 ret = -EIO; 289 - if ((unsigned long) data > _NSIG) 288 + if (!valid_signal(data)) 290 289 break; 291 290 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); 292 291 if ((child->ptrace & PT_DTRACE) == 0) {
+2 -1
arch/sparc/kernel/ptrace.c
··· 18 18 #include <linux/smp.h> 19 19 #include <linux/smp_lock.h> 20 20 #include <linux/security.h> 21 + #include <linux/signal.h> 21 22 22 23 #include <asm/pgtable.h> 23 24 #include <asm/system.h> ··· 527 526 addr = 1; 528 527 529 528 case PTRACE_CONT: { /* restart after signal. */ 530 - if (data > _NSIG) { 529 + if (!valid_signal(data)) { 531 530 pt_error_return(regs, EIO); 532 531 goto out_tsk; 533 532 }
+2 -1
arch/sparc64/kernel/ptrace.c
··· 19 19 #include <linux/smp.h> 20 20 #include <linux/smp_lock.h> 21 21 #include <linux/security.h> 22 + #include <linux/signal.h> 22 23 23 24 #include <asm/asi.h> 24 25 #include <asm/pgtable.h> ··· 560 559 addr = 1; 561 560 562 561 case PTRACE_CONT: { /* restart after signal. */ 563 - if (data > _NSIG) { 562 + if (!valid_signal(data)) { 564 563 pt_error_return(regs, EIO); 565 564 goto out_tsk; 566 565 }
+2 -2
arch/um/kernel/ptrace.c
··· 143 143 case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall */ 144 144 case PTRACE_CONT: { /* restart after signal. */ 145 145 ret = -EIO; 146 - if ((unsigned long) data > _NSIG) 146 + if (!valid_signal(data)) 147 147 break; 148 148 149 149 child->ptrace &= ~PT_DTRACE; ··· 179 179 180 180 case PTRACE_SINGLESTEP: { /* set the trap flag. */ 181 181 ret = -EIO; 182 - if ((unsigned long) data > _NSIG) 182 + if (!valid_signal(data)) 183 183 break; 184 184 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); 185 185 child->ptrace |= PT_DTRACE;
+2 -1
arch/v850/kernel/ptrace.c
··· 23 23 #include <linux/sched.h> 24 24 #include <linux/smp_lock.h> 25 25 #include <linux/ptrace.h> 26 + #include <linux/signal.h> 26 27 27 28 #include <asm/errno.h> 28 29 #include <asm/ptrace.h> ··· 209 208 /* Execute a single instruction. */ 210 209 case PTRACE_SINGLESTEP: 211 210 rval = -EIO; 212 - if ((unsigned long) data > _NSIG) 211 + if (!valid_signal(data)) 213 212 break; 214 213 215 214 /* Turn CHILD's single-step flag on or off. */
+3 -2
arch/x86_64/kernel/ptrace.c
··· 18 18 #include <linux/security.h> 19 19 #include <linux/audit.h> 20 20 #include <linux/seccomp.h> 21 + #include <linux/signal.h> 21 22 22 23 #include <asm/uaccess.h> 23 24 #include <asm/pgtable.h> ··· 468 467 case PTRACE_CONT: /* restart after signal. */ 469 468 470 469 ret = -EIO; 471 - if ((unsigned long) data > _NSIG) 470 + if (!valid_signal(data)) 472 471 break; 473 472 if (request == PTRACE_SYSCALL) 474 473 set_tsk_thread_flag(child,TIF_SYSCALL_TRACE); ··· 530 529 531 530 case PTRACE_SINGLESTEP: /* set the trap flag. */ 532 531 ret = -EIO; 533 - if ((unsigned long) data > _NSIG) 532 + if (!valid_signal(data)) 534 533 break; 535 534 clear_tsk_thread_flag(child,TIF_SYSCALL_TRACE); 536 535 set_singlestep(child);
+2 -1
drivers/char/vt_ioctl.c
··· 24 24 #include <linux/major.h> 25 25 #include <linux/fs.h> 26 26 #include <linux/console.h> 27 + #include <linux/signal.h> 27 28 28 29 #include <asm/io.h> 29 30 #include <asm/uaccess.h> ··· 642 641 extern int spawnpid, spawnsig; 643 642 if (!perm || !capable(CAP_KILL)) 644 643 return -EPERM; 645 - if (arg < 1 || arg > _NSIG || arg == SIGKILL) 644 + if (!valid_signal(arg) || arg < 1 || arg == SIGKILL) 646 645 return -EINVAL; 647 646 spawnpid = current->pid; 648 647 spawnsig = arg;
+2 -1
fs/fcntl.c
··· 15 15 #include <linux/module.h> 16 16 #include <linux/security.h> 17 17 #include <linux/ptrace.h> 18 + #include <linux/signal.h> 18 19 19 20 #include <asm/poll.h> 20 21 #include <asm/siginfo.h> ··· 309 308 break; 310 309 case F_SETSIG: 311 310 /* arg == 0 restores default behaviour. */ 312 - if (arg < 0 || arg > _NSIG) { 311 + if (!valid_signal(arg)) { 313 312 break; 314 313 } 315 314 err = 0;
+2 -2
ipc/mqueue.c
··· 23 23 #include <linux/skbuff.h> 24 24 #include <linux/netlink.h> 25 25 #include <linux/syscalls.h> 26 + #include <linux/signal.h> 26 27 #include <net/sock.h> 27 28 #include "util.h" 28 29 ··· 977 976 notification.sigev_notify != SIGEV_THREAD)) 978 977 return -EINVAL; 979 978 if (notification.sigev_notify == SIGEV_SIGNAL && 980 - (notification.sigev_signo < 0 || 981 - notification.sigev_signo > _NSIG)) { 979 + !valid_signal(notification.sigev_signo)) { 982 980 return -EINVAL; 983 981 } 984 982 if (notification.sigev_notify == SIGEV_THREAD) {
+3 -2
kernel/exit.c
··· 27 27 #include <linux/mempolicy.h> 28 28 #include <linux/cpuset.h> 29 29 #include <linux/syscalls.h> 30 + #include <linux/signal.h> 30 31 31 32 #include <asm/uaccess.h> 32 33 #include <asm/unistd.h> ··· 278 277 */ 279 278 int allow_signal(int sig) 280 279 { 281 - if (sig < 1 || sig > _NSIG) 280 + if (!valid_signal(sig) || sig < 1) 282 281 return -EINVAL; 283 282 284 283 spin_lock_irq(&current->sighand->siglock); ··· 299 298 300 299 int disallow_signal(int sig) 301 300 { 302 - if (sig < 1 || sig > _NSIG) 301 + if (!valid_signal(sig) || sig < 1) 303 302 return -EINVAL; 304 303 305 304 spin_lock_irq(&current->sighand->siglock);
+2 -1
kernel/futex.c
··· 39 39 #include <linux/mount.h> 40 40 #include <linux/pagemap.h> 41 41 #include <linux/syscalls.h> 42 + #include <linux/signal.h> 42 43 43 44 #define FUTEX_HASHBITS (CONFIG_BASE_SMALL ? 4 : 8) 44 45 ··· 655 654 int ret, err; 656 655 657 656 ret = -EINVAL; 658 - if (signal < 0 || signal > _NSIG) 657 + if (!valid_signal(signal)) 659 658 goto out; 660 659 661 660 ret = get_unused_fd();
+2 -1
kernel/ptrace.c
··· 16 16 #include <linux/smp_lock.h> 17 17 #include <linux/ptrace.h> 18 18 #include <linux/security.h> 19 + #include <linux/signal.h> 19 20 20 21 #include <asm/pgtable.h> 21 22 #include <asm/uaccess.h> ··· 167 166 168 167 int ptrace_detach(struct task_struct *child, unsigned int data) 169 168 { 170 - if ((unsigned long) data > _NSIG) 169 + if (!valid_signal(data)) 171 170 return -EIO; 172 171 173 172 /* Architecture-specific hardware disable .. */
+5 -4
kernel/signal.c
··· 23 23 #include <linux/syscalls.h> 24 24 #include <linux/ptrace.h> 25 25 #include <linux/posix-timers.h> 26 + #include <linux/signal.h> 26 27 #include <asm/param.h> 27 28 #include <asm/uaccess.h> 28 29 #include <asm/unistd.h> ··· 647 646 struct task_struct *t) 648 647 { 649 648 int error = -EINVAL; 650 - if (sig < 0 || sig > _NSIG) 649 + if (!valid_signal(sig)) 651 650 return error; 652 651 error = -EPERM; 653 652 if ((!info || ((unsigned long)info != 1 && ··· 1246 1245 * Make sure legacy kernel users don't send in bad values 1247 1246 * (normal paths check this in check_kill_permission). 1248 1247 */ 1249 - if (sig < 0 || sig > _NSIG) 1248 + if (!valid_signal(sig)) 1250 1249 return -EINVAL; 1251 1250 1252 1251 /* ··· 1521 1520 if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN) 1522 1521 sig = 0; 1523 1522 } 1524 - if (sig > 0 && sig <= _NSIG) 1523 + if (valid_signal(sig) && sig > 0) 1525 1524 __group_send_sig_info(sig, &info, tsk->parent); 1526 1525 __wake_up_parent(tsk, tsk->parent); 1527 1526 spin_unlock_irqrestore(&psig->siglock, flags); ··· 2365 2364 { 2366 2365 struct k_sigaction *k; 2367 2366 2368 - if (sig < 1 || sig > _NSIG || (act && sig_kernel_only(sig))) 2367 + if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig))) 2369 2368 return -EINVAL; 2370 2369 2371 2370 k = &current->sighand->action[sig-1];
+2 -1
kernel/sys.c
··· 25 25 #include <linux/dcookies.h> 26 26 #include <linux/suspend.h> 27 27 #include <linux/tty.h> 28 + #include <linux/signal.h> 28 29 29 30 #include <linux/compat.h> 30 31 #include <linux/syscalls.h> ··· 1638 1637 switch (option) { 1639 1638 case PR_SET_PDEATHSIG: 1640 1639 sig = arg2; 1641 - if (sig < 0 || sig > _NSIG) { 1640 + if (!valid_signal(sig)) { 1642 1641 error = -EINVAL; 1643 1642 break; 1644 1643 }