1 /* 2 * linux/kernel/sys.c 3 * 4 * Copyright (C) 1991, 1992 Linus Torvalds 5 */ 6 7 #include <linux/module.h> 8 #include <linux/mm.h> 9 #include <linux/utsname.h> 10 #include <linux/mman.h> 11 #include <linux/smp_lock.h> 12 #include <linux/notifier.h> 13 #include <linux/reboot.h> 14 #include <linux/prctl.h> 15 #include <linux/highuid.h> 16 #include <linux/fs.h> 17 #include <linux/resource.h> 18 #include <linux/kernel.h> 19 #include <linux/kexec.h> 20 #include <linux/workqueue.h> 21 #include <linux/capability.h> 22 #include <linux/device.h> 23 #include <linux/key.h> 24 #include <linux/times.h> 25 #include <linux/posix-timers.h> 26 #include <linux/security.h> 27 #include <linux/dcookies.h> 28 #include <linux/suspend.h> 29 #include <linux/tty.h> 30 #include <linux/signal.h> 31 #include <linux/cn_proc.h> 32 #include <linux/getcpu.h> 33 #include <linux/task_io_accounting_ops.h> 34 #include <linux/seccomp.h> 35 #include <linux/cpu.h> 36 #include <linux/ptrace.h> 37 38 #include <linux/compat.h> 39 #include <linux/syscalls.h> 40 #include <linux/kprobes.h> 41 #include <linux/user_namespace.h> 42 43 #include <asm/uaccess.h> 44 #include <asm/io.h> 45 #include <asm/unistd.h> 46 47 #ifndef SET_UNALIGN_CTL 48 # define SET_UNALIGN_CTL(a,b) (-EINVAL) 49 #endif 50 #ifndef GET_UNALIGN_CTL 51 # define GET_UNALIGN_CTL(a,b) (-EINVAL) 52 #endif 53 #ifndef SET_FPEMU_CTL 54 # define SET_FPEMU_CTL(a,b) (-EINVAL) 55 #endif 56 #ifndef GET_FPEMU_CTL 57 # define GET_FPEMU_CTL(a,b) (-EINVAL) 58 #endif 59 #ifndef SET_FPEXC_CTL 60 # define SET_FPEXC_CTL(a,b) (-EINVAL) 61 #endif 62 #ifndef GET_FPEXC_CTL 63 # define GET_FPEXC_CTL(a,b) (-EINVAL) 64 #endif 65 #ifndef GET_ENDIAN 66 # define GET_ENDIAN(a,b) (-EINVAL) 67 #endif 68 #ifndef SET_ENDIAN 69 # define SET_ENDIAN(a,b) (-EINVAL) 70 #endif 71 #ifndef GET_TSC_CTL 72 # define GET_TSC_CTL(a) (-EINVAL) 73 #endif 74 #ifndef SET_TSC_CTL 75 # define SET_TSC_CTL(a) (-EINVAL) 76 #endif 77 78 /* 79 * this is where the system-wide overflow UID and GID are defined, for 80 * architectures that now have 32-bit UID/GID but didn't in the past 81 */ 82 83 int overflowuid = DEFAULT_OVERFLOWUID; 84 int overflowgid = DEFAULT_OVERFLOWGID; 85 86 #ifdef CONFIG_UID16 87 EXPORT_SYMBOL(overflowuid); 88 EXPORT_SYMBOL(overflowgid); 89 #endif 90 91 /* 92 * the same as above, but for filesystems which can only store a 16-bit 93 * UID and GID. as such, this is needed on all architectures 94 */ 95 96 int fs_overflowuid = DEFAULT_FS_OVERFLOWUID; 97 int fs_overflowgid = DEFAULT_FS_OVERFLOWUID; 98 99 EXPORT_SYMBOL(fs_overflowuid); 100 EXPORT_SYMBOL(fs_overflowgid); 101 102 /* 103 * this indicates whether you can reboot with ctrl-alt-del: the default is yes 104 */ 105 106 int C_A_D = 1; 107 struct pid *cad_pid; 108 EXPORT_SYMBOL(cad_pid); 109 110 /* 111 * If set, this is used for preparing the system to power off. 112 */ 113 114 void (*pm_power_off_prepare)(void); 115 116 /* 117 * set the priority of a task 118 * - the caller must hold the RCU read lock 119 */ 120 static int set_one_prio(struct task_struct *p, int niceval, int error) 121 { 122 const struct cred *cred = current_cred(), *pcred = __task_cred(p); 123 int no_nice; 124 125 if (pcred->uid != cred->euid && 126 pcred->euid != cred->euid && !capable(CAP_SYS_NICE)) { 127 error = -EPERM; 128 goto out; 129 } 130 if (niceval < task_nice(p) && !can_nice(p, niceval)) { 131 error = -EACCES; 132 goto out; 133 } 134 no_nice = security_task_setnice(p, niceval); 135 if (no_nice) { 136 error = no_nice; 137 goto out; 138 } 139 if (error == -ESRCH) 140 error = 0; 141 set_user_nice(p, niceval); 142 out: 143 return error; 144 } 145 146 SYSCALL_DEFINE3(setpriority, int, which, int, who, int, niceval) 147 { 148 struct task_struct *g, *p; 149 struct user_struct *user; 150 const struct cred *cred = current_cred(); 151 int error = -EINVAL; 152 struct pid *pgrp; 153 154 if (which > PRIO_USER || which < PRIO_PROCESS) 155 goto out; 156 157 /* normalize: avoid signed division (rounding problems) */ 158 error = -ESRCH; 159 if (niceval < -20) 160 niceval = -20; 161 if (niceval > 19) 162 niceval = 19; 163 164 read_lock(&tasklist_lock); 165 switch (which) { 166 case PRIO_PROCESS: 167 if (who) 168 p = find_task_by_vpid(who); 169 else 170 p = current; 171 if (p) 172 error = set_one_prio(p, niceval, error); 173 break; 174 case PRIO_PGRP: 175 if (who) 176 pgrp = find_vpid(who); 177 else 178 pgrp = task_pgrp(current); 179 do_each_pid_thread(pgrp, PIDTYPE_PGID, p) { 180 error = set_one_prio(p, niceval, error); 181 } while_each_pid_thread(pgrp, PIDTYPE_PGID, p); 182 break; 183 case PRIO_USER: 184 user = (struct user_struct *) cred->user; 185 if (!who) 186 who = cred->uid; 187 else if ((who != cred->uid) && 188 !(user = find_user(who))) 189 goto out_unlock; /* No processes for this user */ 190 191 do_each_thread(g, p) 192 if (__task_cred(p)->uid == who) 193 error = set_one_prio(p, niceval, error); 194 while_each_thread(g, p); 195 if (who != cred->uid) 196 free_uid(user); /* For find_user() */ 197 break; 198 } 199 out_unlock: 200 read_unlock(&tasklist_lock); 201 out: 202 return error; 203 } 204 205 /* 206 * Ugh. To avoid negative return values, "getpriority()" will 207 * not return the normal nice-value, but a negated value that 208 * has been offset by 20 (ie it returns 40..1 instead of -20..19) 209 * to stay compatible. 210 */ 211 SYSCALL_DEFINE2(getpriority, int, which, int, who) 212 { 213 struct task_struct *g, *p; 214 struct user_struct *user; 215 const struct cred *cred = current_cred(); 216 long niceval, retval = -ESRCH; 217 struct pid *pgrp; 218 219 if (which > PRIO_USER || which < PRIO_PROCESS) 220 return -EINVAL; 221 222 read_lock(&tasklist_lock); 223 switch (which) { 224 case PRIO_PROCESS: 225 if (who) 226 p = find_task_by_vpid(who); 227 else 228 p = current; 229 if (p) { 230 niceval = 20 - task_nice(p); 231 if (niceval > retval) 232 retval = niceval; 233 } 234 break; 235 case PRIO_PGRP: 236 if (who) 237 pgrp = find_vpid(who); 238 else 239 pgrp = task_pgrp(current); 240 do_each_pid_thread(pgrp, PIDTYPE_PGID, p) { 241 niceval = 20 - task_nice(p); 242 if (niceval > retval) 243 retval = niceval; 244 } while_each_pid_thread(pgrp, PIDTYPE_PGID, p); 245 break; 246 case PRIO_USER: 247 user = (struct user_struct *) cred->user; 248 if (!who) 249 who = cred->uid; 250 else if ((who != cred->uid) && 251 !(user = find_user(who))) 252 goto out_unlock; /* No processes for this user */ 253 254 do_each_thread(g, p) 255 if (__task_cred(p)->uid == who) { 256 niceval = 20 - task_nice(p); 257 if (niceval > retval) 258 retval = niceval; 259 } 260 while_each_thread(g, p); 261 if (who != cred->uid) 262 free_uid(user); /* for find_user() */ 263 break; 264 } 265 out_unlock: 266 read_unlock(&tasklist_lock); 267 268 return retval; 269 } 270 271 /** 272 * emergency_restart - reboot the system 273 * 274 * Without shutting down any hardware or taking any locks 275 * reboot the system. This is called when we know we are in 276 * trouble so this is our best effort to reboot. This is 277 * safe to call in interrupt context. 278 */ 279 void emergency_restart(void) 280 { 281 machine_emergency_restart(); 282 } 283 EXPORT_SYMBOL_GPL(emergency_restart); 284 285 void kernel_restart_prepare(char *cmd) 286 { 287 blocking_notifier_call_chain(&reboot_notifier_list, SYS_RESTART, cmd); 288 system_state = SYSTEM_RESTART; 289 device_shutdown(); 290 sysdev_shutdown(); 291 } 292 293 /** 294 * kernel_restart - reboot the system 295 * @cmd: pointer to buffer containing command to execute for restart 296 * or %NULL 297 * 298 * Shutdown everything and perform a clean reboot. 299 * This is not safe to call in interrupt context. 300 */ 301 void kernel_restart(char *cmd) 302 { 303 kernel_restart_prepare(cmd); 304 if (!cmd) 305 printk(KERN_EMERG "Restarting system.\n"); 306 else 307 printk(KERN_EMERG "Restarting system with command '%s'.\n", cmd); 308 machine_restart(cmd); 309 } 310 EXPORT_SYMBOL_GPL(kernel_restart); 311 312 static void kernel_shutdown_prepare(enum system_states state) 313 { 314 blocking_notifier_call_chain(&reboot_notifier_list, 315 (state == SYSTEM_HALT)?SYS_HALT:SYS_POWER_OFF, NULL); 316 system_state = state; 317 device_shutdown(); 318 } 319 /** 320 * kernel_halt - halt the system 321 * 322 * Shutdown everything and perform a clean system halt. 323 */ 324 void kernel_halt(void) 325 { 326 kernel_shutdown_prepare(SYSTEM_HALT); 327 sysdev_shutdown(); 328 printk(KERN_EMERG "System halted.\n"); 329 machine_halt(); 330 } 331 332 EXPORT_SYMBOL_GPL(kernel_halt); 333 334 /** 335 * kernel_power_off - power_off the system 336 * 337 * Shutdown everything and perform a clean system power_off. 338 */ 339 void kernel_power_off(void) 340 { 341 kernel_shutdown_prepare(SYSTEM_POWER_OFF); 342 if (pm_power_off_prepare) 343 pm_power_off_prepare(); 344 disable_nonboot_cpus(); 345 sysdev_shutdown(); 346 printk(KERN_EMERG "Power down.\n"); 347 machine_power_off(); 348 } 349 EXPORT_SYMBOL_GPL(kernel_power_off); 350 /* 351 * Reboot system call: for obvious reasons only root may call it, 352 * and even root needs to set up some magic numbers in the registers 353 * so that some mistake won't make this reboot the whole machine. 354 * You can also set the meaning of the ctrl-alt-del-key here. 355 * 356 * reboot doesn't sync: do that yourself before calling this. 357 */ 358 SYSCALL_DEFINE4(reboot, int, magic1, int, magic2, unsigned int, cmd, 359 void __user *, arg) 360 { 361 char buffer[256]; 362 363 /* We only trust the superuser with rebooting the system. */ 364 if (!capable(CAP_SYS_BOOT)) 365 return -EPERM; 366 367 /* For safety, we require "magic" arguments. */ 368 if (magic1 != LINUX_REBOOT_MAGIC1 || 369 (magic2 != LINUX_REBOOT_MAGIC2 && 370 magic2 != LINUX_REBOOT_MAGIC2A && 371 magic2 != LINUX_REBOOT_MAGIC2B && 372 magic2 != LINUX_REBOOT_MAGIC2C)) 373 return -EINVAL; 374 375 /* Instead of trying to make the power_off code look like 376 * halt when pm_power_off is not set do it the easy way. 377 */ 378 if ((cmd == LINUX_REBOOT_CMD_POWER_OFF) && !pm_power_off) 379 cmd = LINUX_REBOOT_CMD_HALT; 380 381 lock_kernel(); 382 switch (cmd) { 383 case LINUX_REBOOT_CMD_RESTART: 384 kernel_restart(NULL); 385 break; 386 387 case LINUX_REBOOT_CMD_CAD_ON: 388 C_A_D = 1; 389 break; 390 391 case LINUX_REBOOT_CMD_CAD_OFF: 392 C_A_D = 0; 393 break; 394 395 case LINUX_REBOOT_CMD_HALT: 396 kernel_halt(); 397 unlock_kernel(); 398 do_exit(0); 399 break; 400 401 case LINUX_REBOOT_CMD_POWER_OFF: 402 kernel_power_off(); 403 unlock_kernel(); 404 do_exit(0); 405 break; 406 407 case LINUX_REBOOT_CMD_RESTART2: 408 if (strncpy_from_user(&buffer[0], arg, sizeof(buffer) - 1) < 0) { 409 unlock_kernel(); 410 return -EFAULT; 411 } 412 buffer[sizeof(buffer) - 1] = '\0'; 413 414 kernel_restart(buffer); 415 break; 416 417 #ifdef CONFIG_KEXEC 418 case LINUX_REBOOT_CMD_KEXEC: 419 { 420 int ret; 421 ret = kernel_kexec(); 422 unlock_kernel(); 423 return ret; 424 } 425 #endif 426 427 #ifdef CONFIG_HIBERNATION 428 case LINUX_REBOOT_CMD_SW_SUSPEND: 429 { 430 int ret = hibernate(); 431 unlock_kernel(); 432 return ret; 433 } 434 #endif 435 436 default: 437 unlock_kernel(); 438 return -EINVAL; 439 } 440 unlock_kernel(); 441 return 0; 442 } 443 444 static void deferred_cad(struct work_struct *dummy) 445 { 446 kernel_restart(NULL); 447 } 448 449 /* 450 * This function gets called by ctrl-alt-del - ie the keyboard interrupt. 451 * As it's called within an interrupt, it may NOT sync: the only choice 452 * is whether to reboot at once, or just ignore the ctrl-alt-del. 453 */ 454 void ctrl_alt_del(void) 455 { 456 static DECLARE_WORK(cad_work, deferred_cad); 457 458 if (C_A_D) 459 schedule_work(&cad_work); 460 else 461 kill_cad_pid(SIGINT, 1); 462 } 463 464 /* 465 * Unprivileged users may change the real gid to the effective gid 466 * or vice versa. (BSD-style) 467 * 468 * If you set the real gid at all, or set the effective gid to a value not 469 * equal to the real gid, then the saved gid is set to the new effective gid. 470 * 471 * This makes it possible for a setgid program to completely drop its 472 * privileges, which is often a useful assertion to make when you are doing 473 * a security audit over a program. 474 * 475 * The general idea is that a program which uses just setregid() will be 476 * 100% compatible with BSD. A program which uses just setgid() will be 477 * 100% compatible with POSIX with saved IDs. 478 * 479 * SMP: There are not races, the GIDs are checked only by filesystem 480 * operations (as far as semantic preservation is concerned). 481 */ 482 SYSCALL_DEFINE2(setregid, gid_t, rgid, gid_t, egid) 483 { 484 const struct cred *old; 485 struct cred *new; 486 int retval; 487 488 new = prepare_creds(); 489 if (!new) 490 return -ENOMEM; 491 old = current_cred(); 492 493 retval = security_task_setgid(rgid, egid, (gid_t)-1, LSM_SETID_RE); 494 if (retval) 495 goto error; 496 497 retval = -EPERM; 498 if (rgid != (gid_t) -1) { 499 if (old->gid == rgid || 500 old->egid == rgid || 501 capable(CAP_SETGID)) 502 new->gid = rgid; 503 else 504 goto error; 505 } 506 if (egid != (gid_t) -1) { 507 if (old->gid == egid || 508 old->egid == egid || 509 old->sgid == egid || 510 capable(CAP_SETGID)) 511 new->egid = egid; 512 else 513 goto error; 514 } 515 516 if (rgid != (gid_t) -1 || 517 (egid != (gid_t) -1 && egid != old->gid)) 518 new->sgid = new->egid; 519 new->fsgid = new->egid; 520 521 return commit_creds(new); 522 523 error: 524 abort_creds(new); 525 return retval; 526 } 527 528 /* 529 * setgid() is implemented like SysV w/ SAVED_IDS 530 * 531 * SMP: Same implicit races as above. 532 */ 533 SYSCALL_DEFINE1(setgid, gid_t, gid) 534 { 535 const struct cred *old; 536 struct cred *new; 537 int retval; 538 539 new = prepare_creds(); 540 if (!new) 541 return -ENOMEM; 542 old = current_cred(); 543 544 retval = security_task_setgid(gid, (gid_t)-1, (gid_t)-1, LSM_SETID_ID); 545 if (retval) 546 goto error; 547 548 retval = -EPERM; 549 if (capable(CAP_SETGID)) 550 new->gid = new->egid = new->sgid = new->fsgid = gid; 551 else if (gid == old->gid || gid == old->sgid) 552 new->egid = new->fsgid = gid; 553 else 554 goto error; 555 556 return commit_creds(new); 557 558 error: 559 abort_creds(new); 560 return retval; 561 } 562 563 /* 564 * change the user struct in a credentials set to match the new UID 565 */ 566 static int set_user(struct cred *new) 567 { 568 struct user_struct *new_user; 569 570 new_user = alloc_uid(current_user_ns(), new->uid); 571 if (!new_user) 572 return -EAGAIN; 573 574 if (atomic_read(&new_user->processes) >= 575 current->signal->rlim[RLIMIT_NPROC].rlim_cur && 576 new_user != INIT_USER) { 577 free_uid(new_user); 578 return -EAGAIN; 579 } 580 581 free_uid(new->user); 582 new->user = new_user; 583 return 0; 584 } 585 586 /* 587 * Unprivileged users may change the real uid to the effective uid 588 * or vice versa. (BSD-style) 589 * 590 * If you set the real uid at all, or set the effective uid to a value not 591 * equal to the real uid, then the saved uid is set to the new effective uid. 592 * 593 * This makes it possible for a setuid program to completely drop its 594 * privileges, which is often a useful assertion to make when you are doing 595 * a security audit over a program. 596 * 597 * The general idea is that a program which uses just setreuid() will be 598 * 100% compatible with BSD. A program which uses just setuid() will be 599 * 100% compatible with POSIX with saved IDs. 600 */ 601 SYSCALL_DEFINE2(setreuid, uid_t, ruid, uid_t, euid) 602 { 603 const struct cred *old; 604 struct cred *new; 605 int retval; 606 607 new = prepare_creds(); 608 if (!new) 609 return -ENOMEM; 610 old = current_cred(); 611 612 retval = security_task_setuid(ruid, euid, (uid_t)-1, LSM_SETID_RE); 613 if (retval) 614 goto error; 615 616 retval = -EPERM; 617 if (ruid != (uid_t) -1) { 618 new->uid = ruid; 619 if (old->uid != ruid && 620 old->euid != ruid && 621 !capable(CAP_SETUID)) 622 goto error; 623 } 624 625 if (euid != (uid_t) -1) { 626 new->euid = euid; 627 if (old->uid != euid && 628 old->euid != euid && 629 old->suid != euid && 630 !capable(CAP_SETUID)) 631 goto error; 632 } 633 634 retval = -EAGAIN; 635 if (new->uid != old->uid && set_user(new) < 0) 636 goto error; 637 638 if (ruid != (uid_t) -1 || 639 (euid != (uid_t) -1 && euid != old->uid)) 640 new->suid = new->euid; 641 new->fsuid = new->euid; 642 643 retval = security_task_fix_setuid(new, old, LSM_SETID_RE); 644 if (retval < 0) 645 goto error; 646 647 return commit_creds(new); 648 649 error: 650 abort_creds(new); 651 return retval; 652 } 653 654 /* 655 * setuid() is implemented like SysV with SAVED_IDS 656 * 657 * Note that SAVED_ID's is deficient in that a setuid root program 658 * like sendmail, for example, cannot set its uid to be a normal 659 * user and then switch back, because if you're root, setuid() sets 660 * the saved uid too. If you don't like this, blame the bright people 661 * in the POSIX committee and/or USG. Note that the BSD-style setreuid() 662 * will allow a root program to temporarily drop privileges and be able to 663 * regain them by swapping the real and effective uid. 664 */ 665 SYSCALL_DEFINE1(setuid, uid_t, uid) 666 { 667 const struct cred *old; 668 struct cred *new; 669 int retval; 670 671 new = prepare_creds(); 672 if (!new) 673 return -ENOMEM; 674 old = current_cred(); 675 676 retval = security_task_setuid(uid, (uid_t)-1, (uid_t)-1, LSM_SETID_ID); 677 if (retval) 678 goto error; 679 680 retval = -EPERM; 681 if (capable(CAP_SETUID)) { 682 new->suid = new->uid = uid; 683 if (uid != old->uid && set_user(new) < 0) { 684 retval = -EAGAIN; 685 goto error; 686 } 687 } else if (uid != old->uid && uid != new->suid) { 688 goto error; 689 } 690 691 new->fsuid = new->euid = uid; 692 693 retval = security_task_fix_setuid(new, old, LSM_SETID_ID); 694 if (retval < 0) 695 goto error; 696 697 return commit_creds(new); 698 699 error: 700 abort_creds(new); 701 return retval; 702 } 703 704 705 /* 706 * This function implements a generic ability to update ruid, euid, 707 * and suid. This allows you to implement the 4.4 compatible seteuid(). 708 */ 709 SYSCALL_DEFINE3(setresuid, uid_t, ruid, uid_t, euid, uid_t, suid) 710 { 711 const struct cred *old; 712 struct cred *new; 713 int retval; 714 715 new = prepare_creds(); 716 if (!new) 717 return -ENOMEM; 718 719 retval = security_task_setuid(ruid, euid, suid, LSM_SETID_RES); 720 if (retval) 721 goto error; 722 old = current_cred(); 723 724 retval = -EPERM; 725 if (!capable(CAP_SETUID)) { 726 if (ruid != (uid_t) -1 && ruid != old->uid && 727 ruid != old->euid && ruid != old->suid) 728 goto error; 729 if (euid != (uid_t) -1 && euid != old->uid && 730 euid != old->euid && euid != old->suid) 731 goto error; 732 if (suid != (uid_t) -1 && suid != old->uid && 733 suid != old->euid && suid != old->suid) 734 goto error; 735 } 736 737 retval = -EAGAIN; 738 if (ruid != (uid_t) -1) { 739 new->uid = ruid; 740 if (ruid != old->uid && set_user(new) < 0) 741 goto error; 742 } 743 if (euid != (uid_t) -1) 744 new->euid = euid; 745 if (suid != (uid_t) -1) 746 new->suid = suid; 747 new->fsuid = new->euid; 748 749 retval = security_task_fix_setuid(new, old, LSM_SETID_RES); 750 if (retval < 0) 751 goto error; 752 753 return commit_creds(new); 754 755 error: 756 abort_creds(new); 757 return retval; 758 } 759 760 SYSCALL_DEFINE3(getresuid, uid_t __user *, ruid, uid_t __user *, euid, uid_t __user *, suid) 761 { 762 const struct cred *cred = current_cred(); 763 int retval; 764 765 if (!(retval = put_user(cred->uid, ruid)) && 766 !(retval = put_user(cred->euid, euid))) 767 retval = put_user(cred->suid, suid); 768 769 return retval; 770 } 771 772 /* 773 * Same as above, but for rgid, egid, sgid. 774 */ 775 SYSCALL_DEFINE3(setresgid, gid_t, rgid, gid_t, egid, gid_t, sgid) 776 { 777 const struct cred *old; 778 struct cred *new; 779 int retval; 780 781 new = prepare_creds(); 782 if (!new) 783 return -ENOMEM; 784 old = current_cred(); 785 786 retval = security_task_setgid(rgid, egid, sgid, LSM_SETID_RES); 787 if (retval) 788 goto error; 789 790 retval = -EPERM; 791 if (!capable(CAP_SETGID)) { 792 if (rgid != (gid_t) -1 && rgid != old->gid && 793 rgid != old->egid && rgid != old->sgid) 794 goto error; 795 if (egid != (gid_t) -1 && egid != old->gid && 796 egid != old->egid && egid != old->sgid) 797 goto error; 798 if (sgid != (gid_t) -1 && sgid != old->gid && 799 sgid != old->egid && sgid != old->sgid) 800 goto error; 801 } 802 803 if (rgid != (gid_t) -1) 804 new->gid = rgid; 805 if (egid != (gid_t) -1) 806 new->egid = egid; 807 if (sgid != (gid_t) -1) 808 new->sgid = sgid; 809 new->fsgid = new->egid; 810 811 return commit_creds(new); 812 813 error: 814 abort_creds(new); 815 return retval; 816 } 817 818 SYSCALL_DEFINE3(getresgid, gid_t __user *, rgid, gid_t __user *, egid, gid_t __user *, sgid) 819 { 820 const struct cred *cred = current_cred(); 821 int retval; 822 823 if (!(retval = put_user(cred->gid, rgid)) && 824 !(retval = put_user(cred->egid, egid))) 825 retval = put_user(cred->sgid, sgid); 826 827 return retval; 828 } 829 830 831 /* 832 * "setfsuid()" sets the fsuid - the uid used for filesystem checks. This 833 * is used for "access()" and for the NFS daemon (letting nfsd stay at 834 * whatever uid it wants to). It normally shadows "euid", except when 835 * explicitly set by setfsuid() or for access.. 836 */ 837 SYSCALL_DEFINE1(setfsuid, uid_t, uid) 838 { 839 const struct cred *old; 840 struct cred *new; 841 uid_t old_fsuid; 842 843 new = prepare_creds(); 844 if (!new) 845 return current_fsuid(); 846 old = current_cred(); 847 old_fsuid = old->fsuid; 848 849 if (security_task_setuid(uid, (uid_t)-1, (uid_t)-1, LSM_SETID_FS) < 0) 850 goto error; 851 852 if (uid == old->uid || uid == old->euid || 853 uid == old->suid || uid == old->fsuid || 854 capable(CAP_SETUID)) { 855 if (uid != old_fsuid) { 856 new->fsuid = uid; 857 if (security_task_fix_setuid(new, old, LSM_SETID_FS) == 0) 858 goto change_okay; 859 } 860 } 861 862 error: 863 abort_creds(new); 864 return old_fsuid; 865 866 change_okay: 867 commit_creds(new); 868 return old_fsuid; 869 } 870 871 /* 872 * Samma på svenska.. 873 */ 874 SYSCALL_DEFINE1(setfsgid, gid_t, gid) 875 { 876 const struct cred *old; 877 struct cred *new; 878 gid_t old_fsgid; 879 880 new = prepare_creds(); 881 if (!new) 882 return current_fsgid(); 883 old = current_cred(); 884 old_fsgid = old->fsgid; 885 886 if (security_task_setgid(gid, (gid_t)-1, (gid_t)-1, LSM_SETID_FS)) 887 goto error; 888 889 if (gid == old->gid || gid == old->egid || 890 gid == old->sgid || gid == old->fsgid || 891 capable(CAP_SETGID)) { 892 if (gid != old_fsgid) { 893 new->fsgid = gid; 894 goto change_okay; 895 } 896 } 897 898 error: 899 abort_creds(new); 900 return old_fsgid; 901 902 change_okay: 903 commit_creds(new); 904 return old_fsgid; 905 } 906 907 void do_sys_times(struct tms *tms) 908 { 909 struct task_cputime cputime; 910 cputime_t cutime, cstime; 911 912 thread_group_cputime(current, &cputime); 913 spin_lock_irq(¤t->sighand->siglock); 914 cutime = current->signal->cutime; 915 cstime = current->signal->cstime; 916 spin_unlock_irq(¤t->sighand->siglock); 917 tms->tms_utime = cputime_to_clock_t(cputime.utime); 918 tms->tms_stime = cputime_to_clock_t(cputime.stime); 919 tms->tms_cutime = cputime_to_clock_t(cutime); 920 tms->tms_cstime = cputime_to_clock_t(cstime); 921 } 922 923 SYSCALL_DEFINE1(times, struct tms __user *, tbuf) 924 { 925 if (tbuf) { 926 struct tms tmp; 927 928 do_sys_times(&tmp); 929 if (copy_to_user(tbuf, &tmp, sizeof(struct tms))) 930 return -EFAULT; 931 } 932 force_successful_syscall_return(); 933 return (long) jiffies_64_to_clock_t(get_jiffies_64()); 934 } 935 936 /* 937 * This needs some heavy checking ... 938 * I just haven't the stomach for it. I also don't fully 939 * understand sessions/pgrp etc. Let somebody who does explain it. 940 * 941 * OK, I think I have the protection semantics right.... this is really 942 * only important on a multi-user system anyway, to make sure one user 943 * can't send a signal to a process owned by another. -TYT, 12/12/91 944 * 945 * Auch. Had to add the 'did_exec' flag to conform completely to POSIX. 946 * LBT 04.03.94 947 */ 948 SYSCALL_DEFINE2(setpgid, pid_t, pid, pid_t, pgid) 949 { 950 struct task_struct *p; 951 struct task_struct *group_leader = current->group_leader; 952 struct pid *pgrp; 953 int err; 954 955 if (!pid) 956 pid = task_pid_vnr(group_leader); 957 if (!pgid) 958 pgid = pid; 959 if (pgid < 0) 960 return -EINVAL; 961 962 /* From this point forward we keep holding onto the tasklist lock 963 * so that our parent does not change from under us. -DaveM 964 */ 965 write_lock_irq(&tasklist_lock); 966 967 err = -ESRCH; 968 p = find_task_by_vpid(pid); 969 if (!p) 970 goto out; 971 972 err = -EINVAL; 973 if (!thread_group_leader(p)) 974 goto out; 975 976 if (same_thread_group(p->real_parent, group_leader)) { 977 err = -EPERM; 978 if (task_session(p) != task_session(group_leader)) 979 goto out; 980 err = -EACCES; 981 if (p->did_exec) 982 goto out; 983 } else { 984 err = -ESRCH; 985 if (p != group_leader) 986 goto out; 987 } 988 989 err = -EPERM; 990 if (p->signal->leader) 991 goto out; 992 993 pgrp = task_pid(p); 994 if (pgid != pid) { 995 struct task_struct *g; 996 997 pgrp = find_vpid(pgid); 998 g = pid_task(pgrp, PIDTYPE_PGID); 999 if (!g || task_session(g) != task_session(group_leader)) 1000 goto out; 1001 } 1002 1003 err = security_task_setpgid(p, pgid); 1004 if (err) 1005 goto out; 1006 1007 if (task_pgrp(p) != pgrp) { 1008 change_pid(p, PIDTYPE_PGID, pgrp); 1009 set_task_pgrp(p, pid_nr(pgrp)); 1010 } 1011 1012 err = 0; 1013 out: 1014 /* All paths lead to here, thus we are safe. -DaveM */ 1015 write_unlock_irq(&tasklist_lock); 1016 return err; 1017 } 1018 1019 SYSCALL_DEFINE1(getpgid, pid_t, pid) 1020 { 1021 struct task_struct *p; 1022 struct pid *grp; 1023 int retval; 1024 1025 rcu_read_lock(); 1026 if (!pid) 1027 grp = task_pgrp(current); 1028 else { 1029 retval = -ESRCH; 1030 p = find_task_by_vpid(pid); 1031 if (!p) 1032 goto out; 1033 grp = task_pgrp(p); 1034 if (!grp) 1035 goto out; 1036 1037 retval = security_task_getpgid(p); 1038 if (retval) 1039 goto out; 1040 } 1041 retval = pid_vnr(grp); 1042 out: 1043 rcu_read_unlock(); 1044 return retval; 1045 } 1046 1047 #ifdef __ARCH_WANT_SYS_GETPGRP 1048 1049 SYSCALL_DEFINE0(getpgrp) 1050 { 1051 return sys_getpgid(0); 1052 } 1053 1054 #endif 1055 1056 SYSCALL_DEFINE1(getsid, pid_t, pid) 1057 { 1058 struct task_struct *p; 1059 struct pid *sid; 1060 int retval; 1061 1062 rcu_read_lock(); 1063 if (!pid) 1064 sid = task_session(current); 1065 else { 1066 retval = -ESRCH; 1067 p = find_task_by_vpid(pid); 1068 if (!p) 1069 goto out; 1070 sid = task_session(p); 1071 if (!sid) 1072 goto out; 1073 1074 retval = security_task_getsid(p); 1075 if (retval) 1076 goto out; 1077 } 1078 retval = pid_vnr(sid); 1079 out: 1080 rcu_read_unlock(); 1081 return retval; 1082 } 1083 1084 SYSCALL_DEFINE0(setsid) 1085 { 1086 struct task_struct *group_leader = current->group_leader; 1087 struct pid *sid = task_pid(group_leader); 1088 pid_t session = pid_vnr(sid); 1089 int err = -EPERM; 1090 1091 write_lock_irq(&tasklist_lock); 1092 /* Fail if I am already a session leader */ 1093 if (group_leader->signal->leader) 1094 goto out; 1095 1096 /* Fail if a process group id already exists that equals the 1097 * proposed session id. 1098 */ 1099 if (pid_task(sid, PIDTYPE_PGID)) 1100 goto out; 1101 1102 group_leader->signal->leader = 1; 1103 __set_special_pids(sid); 1104 1105 proc_clear_tty(group_leader); 1106 1107 err = session; 1108 out: 1109 write_unlock_irq(&tasklist_lock); 1110 return err; 1111 } 1112 1113 /* 1114 * Supplementary group IDs 1115 */ 1116 1117 /* init to 2 - one for init_task, one to ensure it is never freed */ 1118 struct group_info init_groups = { .usage = ATOMIC_INIT(2) }; 1119 1120 struct group_info *groups_alloc(int gidsetsize) 1121 { 1122 struct group_info *group_info; 1123 int nblocks; 1124 int i; 1125 1126 nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK; 1127 /* Make sure we always allocate at least one indirect block pointer */ 1128 nblocks = nblocks ? : 1; 1129 group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER); 1130 if (!group_info) 1131 return NULL; 1132 group_info->ngroups = gidsetsize; 1133 group_info->nblocks = nblocks; 1134 atomic_set(&group_info->usage, 1); 1135 1136 if (gidsetsize <= NGROUPS_SMALL) 1137 group_info->blocks[0] = group_info->small_block; 1138 else { 1139 for (i = 0; i < nblocks; i++) { 1140 gid_t *b; 1141 b = (void *)__get_free_page(GFP_USER); 1142 if (!b) 1143 goto out_undo_partial_alloc; 1144 group_info->blocks[i] = b; 1145 } 1146 } 1147 return group_info; 1148 1149 out_undo_partial_alloc: 1150 while (--i >= 0) { 1151 free_page((unsigned long)group_info->blocks[i]); 1152 } 1153 kfree(group_info); 1154 return NULL; 1155 } 1156 1157 EXPORT_SYMBOL(groups_alloc); 1158 1159 void groups_free(struct group_info *group_info) 1160 { 1161 if (group_info->blocks[0] != group_info->small_block) { 1162 int i; 1163 for (i = 0; i < group_info->nblocks; i++) 1164 free_page((unsigned long)group_info->blocks[i]); 1165 } 1166 kfree(group_info); 1167 } 1168 1169 EXPORT_SYMBOL(groups_free); 1170 1171 /* export the group_info to a user-space array */ 1172 static int groups_to_user(gid_t __user *grouplist, 1173 const struct group_info *group_info) 1174 { 1175 int i; 1176 unsigned int count = group_info->ngroups; 1177 1178 for (i = 0; i < group_info->nblocks; i++) { 1179 unsigned int cp_count = min(NGROUPS_PER_BLOCK, count); 1180 unsigned int len = cp_count * sizeof(*grouplist); 1181 1182 if (copy_to_user(grouplist, group_info->blocks[i], len)) 1183 return -EFAULT; 1184 1185 grouplist += NGROUPS_PER_BLOCK; 1186 count -= cp_count; 1187 } 1188 return 0; 1189 } 1190 1191 /* fill a group_info from a user-space array - it must be allocated already */ 1192 static int groups_from_user(struct group_info *group_info, 1193 gid_t __user *grouplist) 1194 { 1195 int i; 1196 unsigned int count = group_info->ngroups; 1197 1198 for (i = 0; i < group_info->nblocks; i++) { 1199 unsigned int cp_count = min(NGROUPS_PER_BLOCK, count); 1200 unsigned int len = cp_count * sizeof(*grouplist); 1201 1202 if (copy_from_user(group_info->blocks[i], grouplist, len)) 1203 return -EFAULT; 1204 1205 grouplist += NGROUPS_PER_BLOCK; 1206 count -= cp_count; 1207 } 1208 return 0; 1209 } 1210 1211 /* a simple Shell sort */ 1212 static void groups_sort(struct group_info *group_info) 1213 { 1214 int base, max, stride; 1215 int gidsetsize = group_info->ngroups; 1216 1217 for (stride = 1; stride < gidsetsize; stride = 3 * stride + 1) 1218 ; /* nothing */ 1219 stride /= 3; 1220 1221 while (stride) { 1222 max = gidsetsize - stride; 1223 for (base = 0; base < max; base++) { 1224 int left = base; 1225 int right = left + stride; 1226 gid_t tmp = GROUP_AT(group_info, right); 1227 1228 while (left >= 0 && GROUP_AT(group_info, left) > tmp) { 1229 GROUP_AT(group_info, right) = 1230 GROUP_AT(group_info, left); 1231 right = left; 1232 left -= stride; 1233 } 1234 GROUP_AT(group_info, right) = tmp; 1235 } 1236 stride /= 3; 1237 } 1238 } 1239 1240 /* a simple bsearch */ 1241 int groups_search(const struct group_info *group_info, gid_t grp) 1242 { 1243 unsigned int left, right; 1244 1245 if (!group_info) 1246 return 0; 1247 1248 left = 0; 1249 right = group_info->ngroups; 1250 while (left < right) { 1251 unsigned int mid = (left+right)/2; 1252 int cmp = grp - GROUP_AT(group_info, mid); 1253 if (cmp > 0) 1254 left = mid + 1; 1255 else if (cmp < 0) 1256 right = mid; 1257 else 1258 return 1; 1259 } 1260 return 0; 1261 } 1262 1263 /** 1264 * set_groups - Change a group subscription in a set of credentials 1265 * @new: The newly prepared set of credentials to alter 1266 * @group_info: The group list to install 1267 * 1268 * Validate a group subscription and, if valid, insert it into a set 1269 * of credentials. 1270 */ 1271 int set_groups(struct cred *new, struct group_info *group_info) 1272 { 1273 int retval; 1274 1275 retval = security_task_setgroups(group_info); 1276 if (retval) 1277 return retval; 1278 1279 put_group_info(new->group_info); 1280 groups_sort(group_info); 1281 get_group_info(group_info); 1282 new->group_info = group_info; 1283 return 0; 1284 } 1285 1286 EXPORT_SYMBOL(set_groups); 1287 1288 /** 1289 * set_current_groups - Change current's group subscription 1290 * @group_info: The group list to impose 1291 * 1292 * Validate a group subscription and, if valid, impose it upon current's task 1293 * security record. 1294 */ 1295 int set_current_groups(struct group_info *group_info) 1296 { 1297 struct cred *new; 1298 int ret; 1299 1300 new = prepare_creds(); 1301 if (!new) 1302 return -ENOMEM; 1303 1304 ret = set_groups(new, group_info); 1305 if (ret < 0) { 1306 abort_creds(new); 1307 return ret; 1308 } 1309 1310 return commit_creds(new); 1311 } 1312 1313 EXPORT_SYMBOL(set_current_groups); 1314 1315 SYSCALL_DEFINE2(getgroups, int, gidsetsize, gid_t __user *, grouplist) 1316 { 1317 const struct cred *cred = current_cred(); 1318 int i; 1319 1320 if (gidsetsize < 0) 1321 return -EINVAL; 1322 1323 /* no need to grab task_lock here; it cannot change */ 1324 i = cred->group_info->ngroups; 1325 if (gidsetsize) { 1326 if (i > gidsetsize) { 1327 i = -EINVAL; 1328 goto out; 1329 } 1330 if (groups_to_user(grouplist, cred->group_info)) { 1331 i = -EFAULT; 1332 goto out; 1333 } 1334 } 1335 out: 1336 return i; 1337 } 1338 1339 /* 1340 * SMP: Our groups are copy-on-write. We can set them safely 1341 * without another task interfering. 1342 */ 1343 1344 SYSCALL_DEFINE2(setgroups, int, gidsetsize, gid_t __user *, grouplist) 1345 { 1346 struct group_info *group_info; 1347 int retval; 1348 1349 if (!capable(CAP_SETGID)) 1350 return -EPERM; 1351 if ((unsigned)gidsetsize > NGROUPS_MAX) 1352 return -EINVAL; 1353 1354 group_info = groups_alloc(gidsetsize); 1355 if (!group_info) 1356 return -ENOMEM; 1357 retval = groups_from_user(group_info, grouplist); 1358 if (retval) { 1359 put_group_info(group_info); 1360 return retval; 1361 } 1362 1363 retval = set_current_groups(group_info); 1364 put_group_info(group_info); 1365 1366 return retval; 1367 } 1368 1369 /* 1370 * Check whether we're fsgid/egid or in the supplemental group.. 1371 */ 1372 int in_group_p(gid_t grp) 1373 { 1374 const struct cred *cred = current_cred(); 1375 int retval = 1; 1376 1377 if (grp != cred->fsgid) 1378 retval = groups_search(cred->group_info, grp); 1379 return retval; 1380 } 1381 1382 EXPORT_SYMBOL(in_group_p); 1383 1384 int in_egroup_p(gid_t grp) 1385 { 1386 const struct cred *cred = current_cred(); 1387 int retval = 1; 1388 1389 if (grp != cred->egid) 1390 retval = groups_search(cred->group_info, grp); 1391 return retval; 1392 } 1393 1394 EXPORT_SYMBOL(in_egroup_p); 1395 1396 DECLARE_RWSEM(uts_sem); 1397 1398 SYSCALL_DEFINE1(newuname, struct new_utsname __user *, name) 1399 { 1400 int errno = 0; 1401 1402 down_read(&uts_sem); 1403 if (copy_to_user(name, utsname(), sizeof *name)) 1404 errno = -EFAULT; 1405 up_read(&uts_sem); 1406 return errno; 1407 } 1408 1409 SYSCALL_DEFINE2(sethostname, char __user *, name, int, len) 1410 { 1411 int errno; 1412 char tmp[__NEW_UTS_LEN]; 1413 1414 if (!capable(CAP_SYS_ADMIN)) 1415 return -EPERM; 1416 if (len < 0 || len > __NEW_UTS_LEN) 1417 return -EINVAL; 1418 down_write(&uts_sem); 1419 errno = -EFAULT; 1420 if (!copy_from_user(tmp, name, len)) { 1421 struct new_utsname *u = utsname(); 1422 1423 memcpy(u->nodename, tmp, len); 1424 memset(u->nodename + len, 0, sizeof(u->nodename) - len); 1425 errno = 0; 1426 } 1427 up_write(&uts_sem); 1428 return errno; 1429 } 1430 1431 #ifdef __ARCH_WANT_SYS_GETHOSTNAME 1432 1433 SYSCALL_DEFINE2(gethostname, char __user *, name, int, len) 1434 { 1435 int i, errno; 1436 struct new_utsname *u; 1437 1438 if (len < 0) 1439 return -EINVAL; 1440 down_read(&uts_sem); 1441 u = utsname(); 1442 i = 1 + strlen(u->nodename); 1443 if (i > len) 1444 i = len; 1445 errno = 0; 1446 if (copy_to_user(name, u->nodename, i)) 1447 errno = -EFAULT; 1448 up_read(&uts_sem); 1449 return errno; 1450 } 1451 1452 #endif 1453 1454 /* 1455 * Only setdomainname; getdomainname can be implemented by calling 1456 * uname() 1457 */ 1458 SYSCALL_DEFINE2(setdomainname, char __user *, name, int, len) 1459 { 1460 int errno; 1461 char tmp[__NEW_UTS_LEN]; 1462 1463 if (!capable(CAP_SYS_ADMIN)) 1464 return -EPERM; 1465 if (len < 0 || len > __NEW_UTS_LEN) 1466 return -EINVAL; 1467 1468 down_write(&uts_sem); 1469 errno = -EFAULT; 1470 if (!copy_from_user(tmp, name, len)) { 1471 struct new_utsname *u = utsname(); 1472 1473 memcpy(u->domainname, tmp, len); 1474 memset(u->domainname + len, 0, sizeof(u->domainname) - len); 1475 errno = 0; 1476 } 1477 up_write(&uts_sem); 1478 return errno; 1479 } 1480 1481 SYSCALL_DEFINE2(getrlimit, unsigned int, resource, struct rlimit __user *, rlim) 1482 { 1483 if (resource >= RLIM_NLIMITS) 1484 return -EINVAL; 1485 else { 1486 struct rlimit value; 1487 task_lock(current->group_leader); 1488 value = current->signal->rlim[resource]; 1489 task_unlock(current->group_leader); 1490 return copy_to_user(rlim, &value, sizeof(*rlim)) ? -EFAULT : 0; 1491 } 1492 } 1493 1494 #ifdef __ARCH_WANT_SYS_OLD_GETRLIMIT 1495 1496 /* 1497 * Back compatibility for getrlimit. Needed for some apps. 1498 */ 1499 1500 SYSCALL_DEFINE2(old_getrlimit, unsigned int, resource, 1501 struct rlimit __user *, rlim) 1502 { 1503 struct rlimit x; 1504 if (resource >= RLIM_NLIMITS) 1505 return -EINVAL; 1506 1507 task_lock(current->group_leader); 1508 x = current->signal->rlim[resource]; 1509 task_unlock(current->group_leader); 1510 if (x.rlim_cur > 0x7FFFFFFF) 1511 x.rlim_cur = 0x7FFFFFFF; 1512 if (x.rlim_max > 0x7FFFFFFF) 1513 x.rlim_max = 0x7FFFFFFF; 1514 return copy_to_user(rlim, &x, sizeof(x))?-EFAULT:0; 1515 } 1516 1517 #endif 1518 1519 SYSCALL_DEFINE2(setrlimit, unsigned int, resource, struct rlimit __user *, rlim) 1520 { 1521 struct rlimit new_rlim, *old_rlim; 1522 int retval; 1523 1524 if (resource >= RLIM_NLIMITS) 1525 return -EINVAL; 1526 if (copy_from_user(&new_rlim, rlim, sizeof(*rlim))) 1527 return -EFAULT; 1528 if (new_rlim.rlim_cur > new_rlim.rlim_max) 1529 return -EINVAL; 1530 old_rlim = current->signal->rlim + resource; 1531 if ((new_rlim.rlim_max > old_rlim->rlim_max) && 1532 !capable(CAP_SYS_RESOURCE)) 1533 return -EPERM; 1534 if (resource == RLIMIT_NOFILE && new_rlim.rlim_max > sysctl_nr_open) 1535 return -EPERM; 1536 1537 retval = security_task_setrlimit(resource, &new_rlim); 1538 if (retval) 1539 return retval; 1540 1541 if (resource == RLIMIT_CPU && new_rlim.rlim_cur == 0) { 1542 /* 1543 * The caller is asking for an immediate RLIMIT_CPU 1544 * expiry. But we use the zero value to mean "it was 1545 * never set". So let's cheat and make it one second 1546 * instead 1547 */ 1548 new_rlim.rlim_cur = 1; 1549 } 1550 1551 task_lock(current->group_leader); 1552 *old_rlim = new_rlim; 1553 task_unlock(current->group_leader); 1554 1555 if (resource != RLIMIT_CPU) 1556 goto out; 1557 1558 /* 1559 * RLIMIT_CPU handling. Note that the kernel fails to return an error 1560 * code if it rejected the user's attempt to set RLIMIT_CPU. This is a 1561 * very long-standing error, and fixing it now risks breakage of 1562 * applications, so we live with it 1563 */ 1564 if (new_rlim.rlim_cur == RLIM_INFINITY) 1565 goto out; 1566 1567 update_rlimit_cpu(new_rlim.rlim_cur); 1568 out: 1569 return 0; 1570 } 1571 1572 /* 1573 * It would make sense to put struct rusage in the task_struct, 1574 * except that would make the task_struct be *really big*. After 1575 * task_struct gets moved into malloc'ed memory, it would 1576 * make sense to do this. It will make moving the rest of the information 1577 * a lot simpler! (Which we're not doing right now because we're not 1578 * measuring them yet). 1579 * 1580 * When sampling multiple threads for RUSAGE_SELF, under SMP we might have 1581 * races with threads incrementing their own counters. But since word 1582 * reads are atomic, we either get new values or old values and we don't 1583 * care which for the sums. We always take the siglock to protect reading 1584 * the c* fields from p->signal from races with exit.c updating those 1585 * fields when reaping, so a sample either gets all the additions of a 1586 * given child after it's reaped, or none so this sample is before reaping. 1587 * 1588 * Locking: 1589 * We need to take the siglock for CHILDEREN, SELF and BOTH 1590 * for the cases current multithreaded, non-current single threaded 1591 * non-current multithreaded. Thread traversal is now safe with 1592 * the siglock held. 1593 * Strictly speaking, we donot need to take the siglock if we are current and 1594 * single threaded, as no one else can take our signal_struct away, no one 1595 * else can reap the children to update signal->c* counters, and no one else 1596 * can race with the signal-> fields. If we do not take any lock, the 1597 * signal-> fields could be read out of order while another thread was just 1598 * exiting. So we should place a read memory barrier when we avoid the lock. 1599 * On the writer side, write memory barrier is implied in __exit_signal 1600 * as __exit_signal releases the siglock spinlock after updating the signal-> 1601 * fields. But we don't do this yet to keep things simple. 1602 * 1603 */ 1604 1605 static void accumulate_thread_rusage(struct task_struct *t, struct rusage *r) 1606 { 1607 r->ru_nvcsw += t->nvcsw; 1608 r->ru_nivcsw += t->nivcsw; 1609 r->ru_minflt += t->min_flt; 1610 r->ru_majflt += t->maj_flt; 1611 r->ru_inblock += task_io_get_inblock(t); 1612 r->ru_oublock += task_io_get_oublock(t); 1613 } 1614 1615 static void k_getrusage(struct task_struct *p, int who, struct rusage *r) 1616 { 1617 struct task_struct *t; 1618 unsigned long flags; 1619 cputime_t utime, stime; 1620 struct task_cputime cputime; 1621 1622 memset((char *) r, 0, sizeof *r); 1623 utime = stime = cputime_zero; 1624 1625 if (who == RUSAGE_THREAD) { 1626 utime = task_utime(current); 1627 stime = task_stime(current); 1628 accumulate_thread_rusage(p, r); 1629 goto out; 1630 } 1631 1632 if (!lock_task_sighand(p, &flags)) 1633 return; 1634 1635 switch (who) { 1636 case RUSAGE_BOTH: 1637 case RUSAGE_CHILDREN: 1638 utime = p->signal->cutime; 1639 stime = p->signal->cstime; 1640 r->ru_nvcsw = p->signal->cnvcsw; 1641 r->ru_nivcsw = p->signal->cnivcsw; 1642 r->ru_minflt = p->signal->cmin_flt; 1643 r->ru_majflt = p->signal->cmaj_flt; 1644 r->ru_inblock = p->signal->cinblock; 1645 r->ru_oublock = p->signal->coublock; 1646 1647 if (who == RUSAGE_CHILDREN) 1648 break; 1649 1650 case RUSAGE_SELF: 1651 thread_group_cputime(p, &cputime); 1652 utime = cputime_add(utime, cputime.utime); 1653 stime = cputime_add(stime, cputime.stime); 1654 r->ru_nvcsw += p->signal->nvcsw; 1655 r->ru_nivcsw += p->signal->nivcsw; 1656 r->ru_minflt += p->signal->min_flt; 1657 r->ru_majflt += p->signal->maj_flt; 1658 r->ru_inblock += p->signal->inblock; 1659 r->ru_oublock += p->signal->oublock; 1660 t = p; 1661 do { 1662 accumulate_thread_rusage(t, r); 1663 t = next_thread(t); 1664 } while (t != p); 1665 break; 1666 1667 default: 1668 BUG(); 1669 } 1670 unlock_task_sighand(p, &flags); 1671 1672 out: 1673 cputime_to_timeval(utime, &r->ru_utime); 1674 cputime_to_timeval(stime, &r->ru_stime); 1675 } 1676 1677 int getrusage(struct task_struct *p, int who, struct rusage __user *ru) 1678 { 1679 struct rusage r; 1680 k_getrusage(p, who, &r); 1681 return copy_to_user(ru, &r, sizeof(r)) ? -EFAULT : 0; 1682 } 1683 1684 SYSCALL_DEFINE2(getrusage, int, who, struct rusage __user *, ru) 1685 { 1686 if (who != RUSAGE_SELF && who != RUSAGE_CHILDREN && 1687 who != RUSAGE_THREAD) 1688 return -EINVAL; 1689 return getrusage(current, who, ru); 1690 } 1691 1692 SYSCALL_DEFINE1(umask, int, mask) 1693 { 1694 mask = xchg(¤t->fs->umask, mask & S_IRWXUGO); 1695 return mask; 1696 } 1697 1698 SYSCALL_DEFINE5(prctl, int, option, unsigned long, arg2, unsigned long, arg3, 1699 unsigned long, arg4, unsigned long, arg5) 1700 { 1701 struct task_struct *me = current; 1702 unsigned char comm[sizeof(me->comm)]; 1703 long error; 1704 1705 error = security_task_prctl(option, arg2, arg3, arg4, arg5); 1706 if (error != -ENOSYS) 1707 return error; 1708 1709 error = 0; 1710 switch (option) { 1711 case PR_SET_PDEATHSIG: 1712 if (!valid_signal(arg2)) { 1713 error = -EINVAL; 1714 break; 1715 } 1716 me->pdeath_signal = arg2; 1717 error = 0; 1718 break; 1719 case PR_GET_PDEATHSIG: 1720 error = put_user(me->pdeath_signal, (int __user *)arg2); 1721 break; 1722 case PR_GET_DUMPABLE: 1723 error = get_dumpable(me->mm); 1724 break; 1725 case PR_SET_DUMPABLE: 1726 if (arg2 < 0 || arg2 > 1) { 1727 error = -EINVAL; 1728 break; 1729 } 1730 set_dumpable(me->mm, arg2); 1731 error = 0; 1732 break; 1733 1734 case PR_SET_UNALIGN: 1735 error = SET_UNALIGN_CTL(me, arg2); 1736 break; 1737 case PR_GET_UNALIGN: 1738 error = GET_UNALIGN_CTL(me, arg2); 1739 break; 1740 case PR_SET_FPEMU: 1741 error = SET_FPEMU_CTL(me, arg2); 1742 break; 1743 case PR_GET_FPEMU: 1744 error = GET_FPEMU_CTL(me, arg2); 1745 break; 1746 case PR_SET_FPEXC: 1747 error = SET_FPEXC_CTL(me, arg2); 1748 break; 1749 case PR_GET_FPEXC: 1750 error = GET_FPEXC_CTL(me, arg2); 1751 break; 1752 case PR_GET_TIMING: 1753 error = PR_TIMING_STATISTICAL; 1754 break; 1755 case PR_SET_TIMING: 1756 if (arg2 != PR_TIMING_STATISTICAL) 1757 error = -EINVAL; 1758 else 1759 error = 0; 1760 break; 1761 1762 case PR_SET_NAME: 1763 comm[sizeof(me->comm)-1] = 0; 1764 if (strncpy_from_user(comm, (char __user *)arg2, 1765 sizeof(me->comm) - 1) < 0) 1766 return -EFAULT; 1767 set_task_comm(me, comm); 1768 return 0; 1769 case PR_GET_NAME: 1770 get_task_comm(comm, me); 1771 if (copy_to_user((char __user *)arg2, comm, 1772 sizeof(comm))) 1773 return -EFAULT; 1774 return 0; 1775 case PR_GET_ENDIAN: 1776 error = GET_ENDIAN(me, arg2); 1777 break; 1778 case PR_SET_ENDIAN: 1779 error = SET_ENDIAN(me, arg2); 1780 break; 1781 1782 case PR_GET_SECCOMP: 1783 error = prctl_get_seccomp(); 1784 break; 1785 case PR_SET_SECCOMP: 1786 error = prctl_set_seccomp(arg2); 1787 break; 1788 case PR_GET_TSC: 1789 error = GET_TSC_CTL(arg2); 1790 break; 1791 case PR_SET_TSC: 1792 error = SET_TSC_CTL(arg2); 1793 break; 1794 case PR_GET_TIMERSLACK: 1795 error = current->timer_slack_ns; 1796 break; 1797 case PR_SET_TIMERSLACK: 1798 if (arg2 <= 0) 1799 current->timer_slack_ns = 1800 current->default_timer_slack_ns; 1801 else 1802 current->timer_slack_ns = arg2; 1803 error = 0; 1804 break; 1805 default: 1806 error = -EINVAL; 1807 break; 1808 } 1809 return error; 1810 } 1811 1812 SYSCALL_DEFINE3(getcpu, unsigned __user *, cpup, unsigned __user *, nodep, 1813 struct getcpu_cache __user *, unused) 1814 { 1815 int err = 0; 1816 int cpu = raw_smp_processor_id(); 1817 if (cpup) 1818 err |= put_user(cpu, cpup); 1819 if (nodep) 1820 err |= put_user(cpu_to_node(cpu), nodep); 1821 return err ? -EFAULT : 0; 1822 } 1823 1824 char poweroff_cmd[POWEROFF_CMD_PATH_LEN] = "/sbin/poweroff"; 1825 1826 static void argv_cleanup(char **argv, char **envp) 1827 { 1828 argv_free(argv); 1829 } 1830 1831 /** 1832 * orderly_poweroff - Trigger an orderly system poweroff 1833 * @force: force poweroff if command execution fails 1834 * 1835 * This may be called from any context to trigger a system shutdown. 1836 * If the orderly shutdown fails, it will force an immediate shutdown. 1837 */ 1838 int orderly_poweroff(bool force) 1839 { 1840 int argc; 1841 char **argv = argv_split(GFP_ATOMIC, poweroff_cmd, &argc); 1842 static char *envp[] = { 1843 "HOME=/", 1844 "PATH=/sbin:/bin:/usr/sbin:/usr/bin", 1845 NULL 1846 }; 1847 int ret = -ENOMEM; 1848 struct subprocess_info *info; 1849 1850 if (argv == NULL) { 1851 printk(KERN_WARNING "%s failed to allocate memory for \"%s\"\n", 1852 __func__, poweroff_cmd); 1853 goto out; 1854 } 1855 1856 info = call_usermodehelper_setup(argv[0], argv, envp, GFP_ATOMIC); 1857 if (info == NULL) { 1858 argv_free(argv); 1859 goto out; 1860 } 1861 1862 call_usermodehelper_setcleanup(info, argv_cleanup); 1863 1864 ret = call_usermodehelper_exec(info, UMH_NO_WAIT); 1865 1866 out: 1867 if (ret && force) { 1868 printk(KERN_WARNING "Failed to start orderly shutdown: " 1869 "forcing the issue\n"); 1870 1871 /* I guess this should try to kick off some daemon to 1872 sync and poweroff asap. Or not even bother syncing 1873 if we're doing an emergency shutdown? */ 1874 emergency_sync(); 1875 kernel_power_off(); 1876 } 1877 1878 return ret; 1879 } 1880 EXPORT_SYMBOL_GPL(orderly_poweroff); 1881