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

um: Switch printk calls to adhere to correct coding style

This means having the string literal in one line and using __func__
where appropriate.

Signed-off-by: Benjamin Berg <benjamin@sipsolutions.net>
Signed-off-by: Richard Weinberger <richard@nod.at>

authored by

Benjamin Berg and committed by
Richard Weinberger d119595f 8f88c73a

+69 -75
+2 -2
arch/um/kernel/exec.c
··· 29 29 30 30 ret = unmap(&current->mm->context.id, 0, TASK_SIZE, 1, &data); 31 31 if (ret) { 32 - printk(KERN_ERR "flush_thread - clearing address space failed, " 33 - "err = %d\n", ret); 32 + printk(KERN_ERR "%s - clearing address space failed, err = %d\n", 33 + __func__, ret); 34 34 force_sig(SIGKILL); 35 35 } 36 36 get_safe_registers(current_pt_regs()->regs.gp,
+8 -11
arch/um/os-Linux/skas/mem.c
··· 60 60 printk(UM_KERN_ERR "Registers - \n"); 61 61 for (i = 0; i < MAX_REG_NR; i++) 62 62 printk(UM_KERN_ERR "\t%d\t0x%lx\n", i, syscall_regs[i]); 63 - panic("do_syscall_stub : PTRACE_SETREGS failed, errno = %d\n", 64 - -n); 63 + panic("%s : PTRACE_SETREGS failed, errno = %d\n", 64 + __func__, -n); 65 65 } 66 66 67 67 err = ptrace(PTRACE_CONT, pid, 0, 0); ··· 81 81 offset = *((unsigned long *) mm_idp->stack + 1); 82 82 if (offset) { 83 83 data = (unsigned long *)(mm_idp->stack + offset - STUB_DATA); 84 - printk(UM_KERN_ERR "do_syscall_stub : ret = %ld, offset = %ld, " 85 - "data = %p\n", ret, offset, data); 84 + printk(UM_KERN_ERR "%s : ret = %ld, offset = %ld, data = %p\n", 85 + __func__, ret, offset, data); 86 86 syscall = (unsigned long *)((unsigned long)data + data[0]); 87 - printk(UM_KERN_ERR "do_syscall_stub: syscall %ld failed, " 88 - "return value = 0x%lx, expected return value = 0x%lx\n", 89 - syscall[0], ret, syscall[7]); 90 - printk(UM_KERN_ERR " syscall parameters: " 91 - "0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx\n", 87 + printk(UM_KERN_ERR "%s: syscall %ld failed, return value = 0x%lx, expected return value = 0x%lx\n", 88 + __func__, syscall[0], ret, syscall[7]); 89 + printk(UM_KERN_ERR " syscall parameters: 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx\n", 92 90 syscall[1], syscall[2], syscall[3], 93 91 syscall[4], syscall[5], syscall[6]); 94 92 for (n = 1; n < data[0]/sizeof(long); n++) { 95 93 if (n == 1) 96 - printk(UM_KERN_ERR " additional syscall " 97 - "data:"); 94 + printk(UM_KERN_ERR " additional syscall data:"); 98 95 if (n % 4 == 1) 99 96 printk("\n" UM_KERN_ERR " "); 100 97 printk(" 0x%lx", data[n]);
+59 -62
arch/um/os-Linux/skas/process.c
··· 118 118 119 119 err = ptrace(PTRACE_CONT, pid, 0, 0); 120 120 if (err) { 121 - printk(UM_KERN_ERR "wait_stub_done : continue failed, " 122 - "errno = %d\n", errno); 121 + printk(UM_KERN_ERR "%s : continue failed, errno = %d\n", 122 + __func__, errno); 123 123 fatal_sigsegv(); 124 124 } 125 125 } ··· 130 130 bad_wait: 131 131 err = ptrace_dump_regs(pid); 132 132 if (err) 133 - printk(UM_KERN_ERR "Failed to get registers from stub, " 134 - "errno = %d\n", -err); 135 - printk(UM_KERN_ERR "wait_stub_done : failed to wait for SIGTRAP, " 136 - "pid = %d, n = %d, errno = %d, status = 0x%x\n", pid, n, errno, 137 - status); 133 + printk(UM_KERN_ERR "Failed to get registers from stub, errno = %d\n", 134 + -err); 135 + printk(UM_KERN_ERR "%s : failed to wait for SIGTRAP, pid = %d, n = %d, errno = %d, status = 0x%x\n", 136 + __func__, pid, n, errno, status); 138 137 fatal_sigsegv(); 139 138 } 140 139 ··· 194 195 err = ptrace(PTRACE_POKEUSER, pid, PT_SYSCALL_NR_OFFSET, 195 196 __NR_getpid); 196 197 if (err < 0) { 197 - printk(UM_KERN_ERR "handle_trap - nullifying syscall " 198 - "failed, errno = %d\n", errno); 198 + printk(UM_KERN_ERR "%s - nullifying syscall failed, errno = %d\n", 199 + __func__, errno); 199 200 fatal_sigsegv(); 200 201 } 201 202 202 203 err = ptrace(PTRACE_SYSCALL, pid, 0, 0); 203 204 if (err < 0) { 204 - printk(UM_KERN_ERR "handle_trap - continuing to end of " 205 - "syscall failed, errno = %d\n", errno); 205 + printk(UM_KERN_ERR "%s - continuing to end of syscall failed, errno = %d\n", 206 + __func__, errno); 206 207 fatal_sigsegv(); 207 208 } 208 209 ··· 211 212 (WSTOPSIG(status) != SIGTRAP + 0x80)) { 212 213 err = ptrace_dump_regs(pid); 213 214 if (err) 214 - printk(UM_KERN_ERR "Failed to get registers " 215 - "from process, errno = %d\n", -err); 216 - printk(UM_KERN_ERR "handle_trap - failed to wait at " 217 - "end of syscall, errno = %d, status = %d\n", 218 - errno, status); 215 + printk(UM_KERN_ERR "Failed to get registers from process, errno = %d\n", 216 + -err); 217 + printk(UM_KERN_ERR "%s - failed to wait at end of syscall, errno = %d, status = %d\n", 218 + __func__, errno, status); 219 219 fatal_sigsegv(); 220 220 } 221 221 } ··· 254 256 addr = mmap64((void *) STUB_CODE, UM_KERN_PAGE_SIZE, 255 257 PROT_EXEC, MAP_FIXED | MAP_PRIVATE, fd, offset); 256 258 if (addr == MAP_FAILED) { 257 - printk(UM_KERN_ERR "mapping mmap stub at 0x%lx failed, " 258 - "errno = %d\n", STUB_CODE, errno); 259 + printk(UM_KERN_ERR "mapping mmap stub at 0x%lx failed, errno = %d\n", 260 + STUB_CODE, errno); 259 261 exit(1); 260 262 } 261 263 ··· 265 267 UM_KERN_PAGE_SIZE, PROT_READ | PROT_WRITE, 266 268 MAP_FIXED | MAP_SHARED, fd, offset); 267 269 if (addr == MAP_FAILED) { 268 - printk(UM_KERN_ERR "mapping segfault stack " 269 - "at 0x%lx failed, errno = %d\n", 270 + printk(UM_KERN_ERR "mapping segfault stack at 0x%lx failed, errno = %d\n", 270 271 STUB_DATA, errno); 271 272 exit(1); 272 273 } ··· 283 286 sa.sa_sigaction = (void *) v; 284 287 sa.sa_restorer = NULL; 285 288 if (sigaction(SIGSEGV, &sa, NULL) < 0) { 286 - printk(UM_KERN_ERR "userspace_tramp - setting SIGSEGV " 287 - "handler failed - errno = %d\n", errno); 289 + printk(UM_KERN_ERR "%s - setting SIGSEGV handler failed - errno = %d\n", 290 + __func__, errno); 288 291 exit(1); 289 292 } 290 293 } ··· 319 322 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); 320 323 if (stack == MAP_FAILED) { 321 324 err = -errno; 322 - printk(UM_KERN_ERR "start_userspace : mmap failed, " 323 - "errno = %d\n", errno); 325 + printk(UM_KERN_ERR "%s : mmap failed, errno = %d\n", 326 + __func__, errno); 324 327 return err; 325 328 } 326 329 ··· 333 336 pid = clone(userspace_tramp, (void *) sp, flags, (void *) stub_stack); 334 337 if (pid < 0) { 335 338 err = -errno; 336 - printk(UM_KERN_ERR "start_userspace : clone failed, " 337 - "errno = %d\n", errno); 339 + printk(UM_KERN_ERR "%s : clone failed, errno = %d\n", 340 + __func__, errno); 338 341 return err; 339 342 } 340 343 ··· 342 345 CATCH_EINTR(n = waitpid(pid, &status, WUNTRACED | __WALL)); 343 346 if (n < 0) { 344 347 err = -errno; 345 - printk(UM_KERN_ERR "start_userspace : wait failed, " 346 - "errno = %d\n", errno); 348 + printk(UM_KERN_ERR "%s : wait failed, errno = %d\n", 349 + __func__, errno); 347 350 goto out_kill; 348 351 } 349 352 } while (WIFSTOPPED(status) && (WSTOPSIG(status) == SIGALRM)); 350 353 351 354 if (!WIFSTOPPED(status) || (WSTOPSIG(status) != SIGSTOP)) { 352 355 err = -EINVAL; 353 - printk(UM_KERN_ERR "start_userspace : expected SIGSTOP, got " 354 - "status = %d\n", status); 356 + printk(UM_KERN_ERR "%s : expected SIGSTOP, got status = %d\n", 357 + __func__, status); 355 358 goto out_kill; 356 359 } 357 360 358 361 if (ptrace(PTRACE_OLDSETOPTIONS, pid, NULL, 359 362 (void *) PTRACE_O_TRACESYSGOOD) < 0) { 360 363 err = -errno; 361 - printk(UM_KERN_ERR "start_userspace : PTRACE_OLDSETOPTIONS " 362 - "failed, errno = %d\n", errno); 364 + printk(UM_KERN_ERR "%s : PTRACE_OLDSETOPTIONS failed, errno = %d\n", 365 + __func__, errno); 363 366 goto out_kill; 364 367 } 365 368 366 369 if (munmap(stack, UM_KERN_PAGE_SIZE) < 0) { 367 370 err = -errno; 368 - printk(UM_KERN_ERR "start_userspace : munmap failed, " 369 - "errno = %d\n", errno); 371 + printk(UM_KERN_ERR "%s : munmap failed, errno = %d\n", 372 + __func__, errno); 370 373 goto out_kill; 371 374 } 372 375 ··· 400 403 * just kill the process. 401 404 */ 402 405 if (ptrace(PTRACE_SETREGS, pid, 0, regs->gp)) { 403 - printk(UM_KERN_ERR "userspace - ptrace set regs " 404 - "failed, errno = %d\n", errno); 406 + printk(UM_KERN_ERR "%s - ptrace set regs failed, errno = %d\n", 407 + __func__, errno); 405 408 fatal_sigsegv(); 406 409 } 407 410 408 411 if (put_fp_registers(pid, regs->fp)) { 409 - printk(UM_KERN_ERR "userspace - ptrace set fp regs " 410 - "failed, errno = %d\n", errno); 412 + printk(UM_KERN_ERR "%s - ptrace set fp regs failed, errno = %d\n", 413 + __func__, errno); 411 414 fatal_sigsegv(); 412 415 } 413 416 ··· 418 421 singlestepping(NULL)); 419 422 420 423 if (ptrace(op, pid, 0, 0)) { 421 - printk(UM_KERN_ERR "userspace - ptrace continue " 422 - "failed, op = %d, errno = %d\n", op, errno); 424 + printk(UM_KERN_ERR "%s - ptrace continue failed, op = %d, errno = %d\n", 425 + __func__, op, errno); 423 426 fatal_sigsegv(); 424 427 } 425 428 426 429 CATCH_EINTR(err = waitpid(pid, &status, WUNTRACED | __WALL)); 427 430 if (err < 0) { 428 - printk(UM_KERN_ERR "userspace - wait failed, " 429 - "errno = %d\n", errno); 431 + printk(UM_KERN_ERR "%s - wait failed, errno = %d\n", 432 + __func__, errno); 430 433 fatal_sigsegv(); 431 434 } 432 435 433 436 regs->is_user = 1; 434 437 if (ptrace(PTRACE_GETREGS, pid, 0, regs->gp)) { 435 - printk(UM_KERN_ERR "userspace - PTRACE_GETREGS failed, " 436 - "errno = %d\n", errno); 438 + printk(UM_KERN_ERR "%s - PTRACE_GETREGS failed, errno = %d\n", 439 + __func__, errno); 437 440 fatal_sigsegv(); 438 441 } 439 442 440 443 if (get_fp_registers(pid, regs->fp)) { 441 - printk(UM_KERN_ERR "userspace - get_fp_registers failed, " 442 - "errno = %d\n", errno); 444 + printk(UM_KERN_ERR "%s - get_fp_registers failed, errno = %d\n", 445 + __func__, errno); 443 446 fatal_sigsegv(); 444 447 } 445 448 ··· 491 494 unblock_signals_trace(); 492 495 break; 493 496 default: 494 - printk(UM_KERN_ERR "userspace - child stopped " 495 - "with signal %d\n", sig); 497 + printk(UM_KERN_ERR "%s - child stopped with signal %d\n", 498 + __func__, sig); 496 499 fatal_sigsegv(); 497 500 } 498 501 pid = userspace_pid[0]; ··· 552 555 err = ptrace_setregs(pid, thread_regs); 553 556 if (err < 0) { 554 557 err = -errno; 555 - printk(UM_KERN_ERR "copy_context_skas0 : PTRACE_SETREGS " 556 - "failed, pid = %d, errno = %d\n", pid, -err); 558 + printk(UM_KERN_ERR "%s : PTRACE_SETREGS failed, pid = %d, errno = %d\n", 559 + __func__, pid, -err); 557 560 return err; 558 561 } 559 562 560 563 err = put_fp_registers(pid, thread_fp_regs); 561 564 if (err < 0) { 562 - printk(UM_KERN_ERR "copy_context_skas0 : put_fp_registers " 563 - "failed, pid = %d, err = %d\n", pid, err); 565 + printk(UM_KERN_ERR "%s : put_fp_registers failed, pid = %d, err = %d\n", 566 + __func__, pid, err); 564 567 return err; 565 568 } 566 569 ··· 571 574 err = ptrace(PTRACE_CONT, pid, 0, 0); 572 575 if (err) { 573 576 err = -errno; 574 - printk(UM_KERN_ERR "Failed to continue new process, pid = %d, " 575 - "errno = %d\n", pid, errno); 577 + printk(UM_KERN_ERR "Failed to continue new process, pid = %d, errno = %d\n", 578 + pid, errno); 576 579 return err; 577 580 } 578 581 ··· 580 583 581 584 pid = data->parent_err; 582 585 if (pid < 0) { 583 - printk(UM_KERN_ERR "copy_context_skas0 - stub-parent reports " 584 - "error %d\n", -pid); 586 + printk(UM_KERN_ERR "%s - stub-parent reports error %d\n", 587 + __func__, -pid); 585 588 return pid; 586 589 } 587 590 ··· 591 594 */ 592 595 wait_stub_done(pid); 593 596 if (child_data->child_err != STUB_DATA) { 594 - printk(UM_KERN_ERR "copy_context_skas0 - stub-child %d reports " 595 - "error %ld\n", pid, data->child_err); 597 + printk(UM_KERN_ERR "%s - stub-child %d reports error %ld\n", 598 + __func__, pid, data->child_err); 596 599 err = data->child_err; 597 600 goto out_kill; 598 601 } ··· 600 603 if (ptrace(PTRACE_OLDSETOPTIONS, pid, NULL, 601 604 (void *)PTRACE_O_TRACESYSGOOD) < 0) { 602 605 err = -errno; 603 - printk(UM_KERN_ERR "copy_context_skas0 : PTRACE_OLDSETOPTIONS " 604 - "failed, errno = %d\n", errno); 606 + printk(UM_KERN_ERR "%s : PTRACE_OLDSETOPTIONS failed, errno = %d\n", 607 + __func__, errno); 605 608 goto out_kill; 606 609 } 607 610 ··· 669 672 kmalloc_ok = 0; 670 673 return 1; 671 674 default: 672 - printk(UM_KERN_ERR "Bad sigsetjmp return in " 673 - "start_idle_thread - %d\n", n); 675 + printk(UM_KERN_ERR "Bad sigsetjmp return in %s - %d\n", 676 + __func__, n); 674 677 fatal_sigsegv(); 675 678 } 676 679 longjmp(*switch_buf, 1);