4 * Copyright (C) 1991, 1992 Linus Torvalds
7 #include <linux/module.h>
9 #include <linux/utsname.h>
10 #include <linux/mman.h>
11 #include <linux/notifier.h>
12 #include <linux/reboot.h>
13 #include <linux/prctl.h>
14 #include <linux/highuid.h>
16 #include <linux/perf_event.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/personality.h>
37 #include <linux/ptrace.h>
38 #include <linux/fs_struct.h>
39 #include <linux/gfp.h>
40 #include <linux/syscore_ops.h>
42 #include <linux/compat.h>
43 #include <linux/syscalls.h>
44 #include <linux/kprobes.h>
45 #include <linux/user_namespace.h>
47 #include <linux/kmsg_dump.h>
49 #include <asm/uaccess.h>
51 #include <asm/unistd.h>
53 #ifndef SET_UNALIGN_CTL
54 # define SET_UNALIGN_CTL(a,b) (-EINVAL)
56 #ifndef GET_UNALIGN_CTL
57 # define GET_UNALIGN_CTL(a,b) (-EINVAL)
60 # define SET_FPEMU_CTL(a,b) (-EINVAL)
63 # define GET_FPEMU_CTL(a,b) (-EINVAL)
66 # define SET_FPEXC_CTL(a,b) (-EINVAL)
69 # define GET_FPEXC_CTL(a,b) (-EINVAL)
72 # define GET_ENDIAN(a,b) (-EINVAL)
75 # define SET_ENDIAN(a,b) (-EINVAL)
78 # define GET_TSC_CTL(a) (-EINVAL)
81 # define SET_TSC_CTL(a) (-EINVAL)
85 * this is where the system-wide overflow UID and GID are defined, for
86 * architectures that now have 32-bit UID/GID but didn't in the past
89 int overflowuid
= DEFAULT_OVERFLOWUID
;
90 int overflowgid
= DEFAULT_OVERFLOWGID
;
93 EXPORT_SYMBOL(overflowuid
);
94 EXPORT_SYMBOL(overflowgid
);
98 * the same as above, but for filesystems which can only store a 16-bit
99 * UID and GID. as such, this is needed on all architectures
102 int fs_overflowuid
= DEFAULT_FS_OVERFLOWUID
;
103 int fs_overflowgid
= DEFAULT_FS_OVERFLOWUID
;
105 EXPORT_SYMBOL(fs_overflowuid
);
106 EXPORT_SYMBOL(fs_overflowgid
);
109 * this indicates whether you can reboot with ctrl-alt-del: the default is yes
114 EXPORT_SYMBOL(cad_pid
);
117 * If set, this is used for preparing the system to power off.
120 void (*pm_power_off_prepare
)(void);
123 * Returns true if current's euid is same as p's uid or euid,
124 * or has CAP_SYS_NICE to p's user_ns.
126 * Called with rcu_read_lock, creds are safe
128 static bool set_one_prio_perm(struct task_struct
*p
)
130 const struct cred
*cred
= current_cred(), *pcred
= __task_cred(p
);
132 if (pcred
->user
->user_ns
== cred
->user
->user_ns
&&
133 (pcred
->uid
== cred
->euid
||
134 pcred
->euid
== cred
->euid
))
136 if (ns_capable(pcred
->user
->user_ns
, CAP_SYS_NICE
))
142 * set the priority of a task
143 * - the caller must hold the RCU read lock
145 static int set_one_prio(struct task_struct
*p
, int niceval
, int error
)
149 if (!set_one_prio_perm(p
)) {
153 if (niceval
< task_nice(p
) && !can_nice(p
, niceval
)) {
157 no_nice
= security_task_setnice(p
, niceval
);
164 set_user_nice(p
, niceval
);
169 SYSCALL_DEFINE3(setpriority
, int, which
, int, who
, int, niceval
)
171 struct task_struct
*g
, *p
;
172 struct user_struct
*user
;
173 const struct cred
*cred
= current_cred();
177 if (which
> PRIO_USER
|| which
< PRIO_PROCESS
)
180 /* normalize: avoid signed division (rounding problems) */
188 read_lock(&tasklist_lock
);
192 p
= find_task_by_vpid(who
);
196 error
= set_one_prio(p
, niceval
, error
);
200 pgrp
= find_vpid(who
);
202 pgrp
= task_pgrp(current
);
203 do_each_pid_thread(pgrp
, PIDTYPE_PGID
, p
) {
204 error
= set_one_prio(p
, niceval
, error
);
205 } while_each_pid_thread(pgrp
, PIDTYPE_PGID
, p
);
208 user
= (struct user_struct
*) cred
->user
;
211 else if ((who
!= cred
->uid
) &&
212 !(user
= find_user(who
)))
213 goto out_unlock
; /* No processes for this user */
215 do_each_thread(g
, p
) {
216 if (__task_cred(p
)->uid
== who
)
217 error
= set_one_prio(p
, niceval
, error
);
218 } while_each_thread(g
, p
);
219 if (who
!= cred
->uid
)
220 free_uid(user
); /* For find_user() */
224 read_unlock(&tasklist_lock
);
231 * Ugh. To avoid negative return values, "getpriority()" will
232 * not return the normal nice-value, but a negated value that
233 * has been offset by 20 (ie it returns 40..1 instead of -20..19)
234 * to stay compatible.
236 SYSCALL_DEFINE2(getpriority
, int, which
, int, who
)
238 struct task_struct
*g
, *p
;
239 struct user_struct
*user
;
240 const struct cred
*cred
= current_cred();
241 long niceval
, retval
= -ESRCH
;
244 if (which
> PRIO_USER
|| which
< PRIO_PROCESS
)
248 read_lock(&tasklist_lock
);
252 p
= find_task_by_vpid(who
);
256 niceval
= 20 - task_nice(p
);
257 if (niceval
> retval
)
263 pgrp
= find_vpid(who
);
265 pgrp
= task_pgrp(current
);
266 do_each_pid_thread(pgrp
, PIDTYPE_PGID
, p
) {
267 niceval
= 20 - task_nice(p
);
268 if (niceval
> retval
)
270 } while_each_pid_thread(pgrp
, PIDTYPE_PGID
, p
);
273 user
= (struct user_struct
*) cred
->user
;
276 else if ((who
!= cred
->uid
) &&
277 !(user
= find_user(who
)))
278 goto out_unlock
; /* No processes for this user */
280 do_each_thread(g
, p
) {
281 if (__task_cred(p
)->uid
== who
) {
282 niceval
= 20 - task_nice(p
);
283 if (niceval
> retval
)
286 } while_each_thread(g
, p
);
287 if (who
!= cred
->uid
)
288 free_uid(user
); /* for find_user() */
292 read_unlock(&tasklist_lock
);
299 * emergency_restart - reboot the system
301 * Without shutting down any hardware or taking any locks
302 * reboot the system. This is called when we know we are in
303 * trouble so this is our best effort to reboot. This is
304 * safe to call in interrupt context.
306 void emergency_restart(void)
308 kmsg_dump(KMSG_DUMP_EMERG
);
309 machine_emergency_restart();
311 EXPORT_SYMBOL_GPL(emergency_restart
);
313 void kernel_restart_prepare(char *cmd
)
315 blocking_notifier_call_chain(&reboot_notifier_list
, SYS_RESTART
, cmd
);
316 system_state
= SYSTEM_RESTART
;
317 usermodehelper_disable();
324 * kernel_restart - reboot the system
325 * @cmd: pointer to buffer containing command to execute for restart
328 * Shutdown everything and perform a clean reboot.
329 * This is not safe to call in interrupt context.
331 void kernel_restart(char *cmd
)
333 kernel_restart_prepare(cmd
);
335 printk(KERN_EMERG
"Restarting system.\n");
337 printk(KERN_EMERG
"Restarting system with command '%s'.\n", cmd
);
338 kmsg_dump(KMSG_DUMP_RESTART
);
339 machine_restart(cmd
);
341 EXPORT_SYMBOL_GPL(kernel_restart
);
343 static void kernel_shutdown_prepare(enum system_states state
)
345 blocking_notifier_call_chain(&reboot_notifier_list
,
346 (state
== SYSTEM_HALT
)?SYS_HALT
:SYS_POWER_OFF
, NULL
);
347 system_state
= state
;
348 usermodehelper_disable();
352 * kernel_halt - halt the system
354 * Shutdown everything and perform a clean system halt.
356 void kernel_halt(void)
358 kernel_shutdown_prepare(SYSTEM_HALT
);
361 printk(KERN_EMERG
"System halted.\n");
362 kmsg_dump(KMSG_DUMP_HALT
);
366 EXPORT_SYMBOL_GPL(kernel_halt
);
369 * kernel_power_off - power_off the system
371 * Shutdown everything and perform a clean system power_off.
373 void kernel_power_off(void)
375 kernel_shutdown_prepare(SYSTEM_POWER_OFF
);
376 if (pm_power_off_prepare
)
377 pm_power_off_prepare();
378 disable_nonboot_cpus();
381 printk(KERN_EMERG
"Power down.\n");
382 kmsg_dump(KMSG_DUMP_POWEROFF
);
385 EXPORT_SYMBOL_GPL(kernel_power_off
);
387 static DEFINE_MUTEX(reboot_mutex
);
390 * Reboot system call: for obvious reasons only root may call it,
391 * and even root needs to set up some magic numbers in the registers
392 * so that some mistake won't make this reboot the whole machine.
393 * You can also set the meaning of the ctrl-alt-del-key here.
395 * reboot doesn't sync: do that yourself before calling this.
397 SYSCALL_DEFINE4(reboot
, int, magic1
, int, magic2
, unsigned int, cmd
,
403 /* We only trust the superuser with rebooting the system. */
404 if (!capable(CAP_SYS_BOOT
))
407 /* For safety, we require "magic" arguments. */
408 if (magic1
!= LINUX_REBOOT_MAGIC1
||
409 (magic2
!= LINUX_REBOOT_MAGIC2
&&
410 magic2
!= LINUX_REBOOT_MAGIC2A
&&
411 magic2
!= LINUX_REBOOT_MAGIC2B
&&
412 magic2
!= LINUX_REBOOT_MAGIC2C
))
415 /* Instead of trying to make the power_off code look like
416 * halt when pm_power_off is not set do it the easy way.
418 if ((cmd
== LINUX_REBOOT_CMD_POWER_OFF
) && !pm_power_off
)
419 cmd
= LINUX_REBOOT_CMD_HALT
;
421 mutex_lock(&reboot_mutex
);
423 case LINUX_REBOOT_CMD_RESTART
:
424 kernel_restart(NULL
);
427 case LINUX_REBOOT_CMD_CAD_ON
:
431 case LINUX_REBOOT_CMD_CAD_OFF
:
435 case LINUX_REBOOT_CMD_HALT
:
438 panic("cannot halt");
440 case LINUX_REBOOT_CMD_POWER_OFF
:
445 case LINUX_REBOOT_CMD_RESTART2
:
446 if (strncpy_from_user(&buffer
[0], arg
, sizeof(buffer
) - 1) < 0) {
450 buffer
[sizeof(buffer
) - 1] = '\0';
452 kernel_restart(buffer
);
456 case LINUX_REBOOT_CMD_KEXEC
:
457 ret
= kernel_kexec();
461 #ifdef CONFIG_HIBERNATION
462 case LINUX_REBOOT_CMD_SW_SUSPEND
:
471 mutex_unlock(&reboot_mutex
);
475 static void deferred_cad(struct work_struct
*dummy
)
477 kernel_restart(NULL
);
481 * This function gets called by ctrl-alt-del - ie the keyboard interrupt.
482 * As it's called within an interrupt, it may NOT sync: the only choice
483 * is whether to reboot at once, or just ignore the ctrl-alt-del.
485 void ctrl_alt_del(void)
487 static DECLARE_WORK(cad_work
, deferred_cad
);
490 schedule_work(&cad_work
);
492 kill_cad_pid(SIGINT
, 1);
496 * Unprivileged users may change the real gid to the effective gid
497 * or vice versa. (BSD-style)
499 * If you set the real gid at all, or set the effective gid to a value not
500 * equal to the real gid, then the saved gid is set to the new effective gid.
502 * This makes it possible for a setgid program to completely drop its
503 * privileges, which is often a useful assertion to make when you are doing
504 * a security audit over a program.
506 * The general idea is that a program which uses just setregid() will be
507 * 100% compatible with BSD. A program which uses just setgid() will be
508 * 100% compatible with POSIX with saved IDs.
510 * SMP: There are not races, the GIDs are checked only by filesystem
511 * operations (as far as semantic preservation is concerned).
513 SYSCALL_DEFINE2(setregid
, gid_t
, rgid
, gid_t
, egid
)
515 const struct cred
*old
;
519 new = prepare_creds();
522 old
= current_cred();
525 if (rgid
!= (gid_t
) -1) {
526 if (old
->gid
== rgid
||
528 nsown_capable(CAP_SETGID
))
533 if (egid
!= (gid_t
) -1) {
534 if (old
->gid
== egid
||
537 nsown_capable(CAP_SETGID
))
543 if (rgid
!= (gid_t
) -1 ||
544 (egid
!= (gid_t
) -1 && egid
!= old
->gid
))
545 new->sgid
= new->egid
;
546 new->fsgid
= new->egid
;
548 return commit_creds(new);
556 * setgid() is implemented like SysV w/ SAVED_IDS
558 * SMP: Same implicit races as above.
560 SYSCALL_DEFINE1(setgid
, gid_t
, gid
)
562 const struct cred
*old
;
566 new = prepare_creds();
569 old
= current_cred();
572 if (nsown_capable(CAP_SETGID
))
573 new->gid
= new->egid
= new->sgid
= new->fsgid
= gid
;
574 else if (gid
== old
->gid
|| gid
== old
->sgid
)
575 new->egid
= new->fsgid
= gid
;
579 return commit_creds(new);
587 * change the user struct in a credentials set to match the new UID
589 static int set_user(struct cred
*new)
591 struct user_struct
*new_user
;
593 new_user
= alloc_uid(current_user_ns(), new->uid
);
597 if (atomic_read(&new_user
->processes
) >= rlimit(RLIMIT_NPROC
) &&
598 new_user
!= INIT_USER
) {
604 new->user
= new_user
;
609 * Unprivileged users may change the real uid to the effective uid
610 * or vice versa. (BSD-style)
612 * If you set the real uid at all, or set the effective uid to a value not
613 * equal to the real uid, then the saved uid is set to the new effective uid.
615 * This makes it possible for a setuid program to completely drop its
616 * privileges, which is often a useful assertion to make when you are doing
617 * a security audit over a program.
619 * The general idea is that a program which uses just setreuid() will be
620 * 100% compatible with BSD. A program which uses just setuid() will be
621 * 100% compatible with POSIX with saved IDs.
623 SYSCALL_DEFINE2(setreuid
, uid_t
, ruid
, uid_t
, euid
)
625 const struct cred
*old
;
629 new = prepare_creds();
632 old
= current_cred();
635 if (ruid
!= (uid_t
) -1) {
637 if (old
->uid
!= ruid
&&
639 !nsown_capable(CAP_SETUID
))
643 if (euid
!= (uid_t
) -1) {
645 if (old
->uid
!= euid
&&
648 !nsown_capable(CAP_SETUID
))
652 if (new->uid
!= old
->uid
) {
653 retval
= set_user(new);
657 if (ruid
!= (uid_t
) -1 ||
658 (euid
!= (uid_t
) -1 && euid
!= old
->uid
))
659 new->suid
= new->euid
;
660 new->fsuid
= new->euid
;
662 retval
= security_task_fix_setuid(new, old
, LSM_SETID_RE
);
666 return commit_creds(new);
674 * setuid() is implemented like SysV with SAVED_IDS
676 * Note that SAVED_ID's is deficient in that a setuid root program
677 * like sendmail, for example, cannot set its uid to be a normal
678 * user and then switch back, because if you're root, setuid() sets
679 * the saved uid too. If you don't like this, blame the bright people
680 * in the POSIX committee and/or USG. Note that the BSD-style setreuid()
681 * will allow a root program to temporarily drop privileges and be able to
682 * regain them by swapping the real and effective uid.
684 SYSCALL_DEFINE1(setuid
, uid_t
, uid
)
686 const struct cred
*old
;
690 new = prepare_creds();
693 old
= current_cred();
696 if (nsown_capable(CAP_SETUID
)) {
697 new->suid
= new->uid
= uid
;
698 if (uid
!= old
->uid
) {
699 retval
= set_user(new);
703 } else if (uid
!= old
->uid
&& uid
!= new->suid
) {
707 new->fsuid
= new->euid
= uid
;
709 retval
= security_task_fix_setuid(new, old
, LSM_SETID_ID
);
713 return commit_creds(new);
722 * This function implements a generic ability to update ruid, euid,
723 * and suid. This allows you to implement the 4.4 compatible seteuid().
725 SYSCALL_DEFINE3(setresuid
, uid_t
, ruid
, uid_t
, euid
, uid_t
, suid
)
727 const struct cred
*old
;
731 new = prepare_creds();
735 old
= current_cred();
738 if (!nsown_capable(CAP_SETUID
)) {
739 if (ruid
!= (uid_t
) -1 && ruid
!= old
->uid
&&
740 ruid
!= old
->euid
&& ruid
!= old
->suid
)
742 if (euid
!= (uid_t
) -1 && euid
!= old
->uid
&&
743 euid
!= old
->euid
&& euid
!= old
->suid
)
745 if (suid
!= (uid_t
) -1 && suid
!= old
->uid
&&
746 suid
!= old
->euid
&& suid
!= old
->suid
)
750 if (ruid
!= (uid_t
) -1) {
752 if (ruid
!= old
->uid
) {
753 retval
= set_user(new);
758 if (euid
!= (uid_t
) -1)
760 if (suid
!= (uid_t
) -1)
762 new->fsuid
= new->euid
;
764 retval
= security_task_fix_setuid(new, old
, LSM_SETID_RES
);
768 return commit_creds(new);
775 SYSCALL_DEFINE3(getresuid
, uid_t __user
*, ruid
, uid_t __user
*, euid
, uid_t __user
*, suid
)
777 const struct cred
*cred
= current_cred();
780 if (!(retval
= put_user(cred
->uid
, ruid
)) &&
781 !(retval
= put_user(cred
->euid
, euid
)))
782 retval
= put_user(cred
->suid
, suid
);
788 * Same as above, but for rgid, egid, sgid.
790 SYSCALL_DEFINE3(setresgid
, gid_t
, rgid
, gid_t
, egid
, gid_t
, sgid
)
792 const struct cred
*old
;
796 new = prepare_creds();
799 old
= current_cred();
802 if (!nsown_capable(CAP_SETGID
)) {
803 if (rgid
!= (gid_t
) -1 && rgid
!= old
->gid
&&
804 rgid
!= old
->egid
&& rgid
!= old
->sgid
)
806 if (egid
!= (gid_t
) -1 && egid
!= old
->gid
&&
807 egid
!= old
->egid
&& egid
!= old
->sgid
)
809 if (sgid
!= (gid_t
) -1 && sgid
!= old
->gid
&&
810 sgid
!= old
->egid
&& sgid
!= old
->sgid
)
814 if (rgid
!= (gid_t
) -1)
816 if (egid
!= (gid_t
) -1)
818 if (sgid
!= (gid_t
) -1)
820 new->fsgid
= new->egid
;
822 return commit_creds(new);
829 SYSCALL_DEFINE3(getresgid
, gid_t __user
*, rgid
, gid_t __user
*, egid
, gid_t __user
*, sgid
)
831 const struct cred
*cred
= current_cred();
834 if (!(retval
= put_user(cred
->gid
, rgid
)) &&
835 !(retval
= put_user(cred
->egid
, egid
)))
836 retval
= put_user(cred
->sgid
, sgid
);
843 * "setfsuid()" sets the fsuid - the uid used for filesystem checks. This
844 * is used for "access()" and for the NFS daemon (letting nfsd stay at
845 * whatever uid it wants to). It normally shadows "euid", except when
846 * explicitly set by setfsuid() or for access..
848 SYSCALL_DEFINE1(setfsuid
, uid_t
, uid
)
850 const struct cred
*old
;
854 new = prepare_creds();
856 return current_fsuid();
857 old
= current_cred();
858 old_fsuid
= old
->fsuid
;
860 if (uid
== old
->uid
|| uid
== old
->euid
||
861 uid
== old
->suid
|| uid
== old
->fsuid
||
862 nsown_capable(CAP_SETUID
)) {
863 if (uid
!= old_fsuid
) {
865 if (security_task_fix_setuid(new, old
, LSM_SETID_FS
) == 0)
879 * Samma på svenska..
881 SYSCALL_DEFINE1(setfsgid
, gid_t
, gid
)
883 const struct cred
*old
;
887 new = prepare_creds();
889 return current_fsgid();
890 old
= current_cred();
891 old_fsgid
= old
->fsgid
;
893 if (gid
== old
->gid
|| gid
== old
->egid
||
894 gid
== old
->sgid
|| gid
== old
->fsgid
||
895 nsown_capable(CAP_SETGID
)) {
896 if (gid
!= old_fsgid
) {
910 void do_sys_times(struct tms
*tms
)
912 cputime_t tgutime
, tgstime
, cutime
, cstime
;
914 spin_lock_irq(¤t
->sighand
->siglock
);
915 thread_group_times(current
, &tgutime
, &tgstime
);
916 cutime
= current
->signal
->cutime
;
917 cstime
= current
->signal
->cstime
;
918 spin_unlock_irq(¤t
->sighand
->siglock
);
919 tms
->tms_utime
= cputime_to_clock_t(tgutime
);
920 tms
->tms_stime
= cputime_to_clock_t(tgstime
);
921 tms
->tms_cutime
= cputime_to_clock_t(cutime
);
922 tms
->tms_cstime
= cputime_to_clock_t(cstime
);
925 SYSCALL_DEFINE1(times
, struct tms __user
*, tbuf
)
931 if (copy_to_user(tbuf
, &tmp
, sizeof(struct tms
)))
934 force_successful_syscall_return();
935 return (long) jiffies_64_to_clock_t(get_jiffies_64());
939 * This needs some heavy checking ...
940 * I just haven't the stomach for it. I also don't fully
941 * understand sessions/pgrp etc. Let somebody who does explain it.
943 * OK, I think I have the protection semantics right.... this is really
944 * only important on a multi-user system anyway, to make sure one user
945 * can't send a signal to a process owned by another. -TYT, 12/12/91
947 * Auch. Had to add the 'did_exec' flag to conform completely to POSIX.
950 SYSCALL_DEFINE2(setpgid
, pid_t
, pid
, pid_t
, pgid
)
952 struct task_struct
*p
;
953 struct task_struct
*group_leader
= current
->group_leader
;
958 pid
= task_pid_vnr(group_leader
);
965 /* From this point forward we keep holding onto the tasklist lock
966 * so that our parent does not change from under us. -DaveM
968 write_lock_irq(&tasklist_lock
);
971 p
= find_task_by_vpid(pid
);
976 if (!thread_group_leader(p
))
979 if (same_thread_group(p
->real_parent
, group_leader
)) {
981 if (task_session(p
) != task_session(group_leader
))
988 if (p
!= group_leader
)
993 if (p
->signal
->leader
)
998 struct task_struct
*g
;
1000 pgrp
= find_vpid(pgid
);
1001 g
= pid_task(pgrp
, PIDTYPE_PGID
);
1002 if (!g
|| task_session(g
) != task_session(group_leader
))
1006 err
= security_task_setpgid(p
, pgid
);
1010 if (task_pgrp(p
) != pgrp
)
1011 change_pid(p
, PIDTYPE_PGID
, pgrp
);
1015 /* All paths lead to here, thus we are safe. -DaveM */
1016 write_unlock_irq(&tasklist_lock
);
1021 SYSCALL_DEFINE1(getpgid
, pid_t
, pid
)
1023 struct task_struct
*p
;
1029 grp
= task_pgrp(current
);
1032 p
= find_task_by_vpid(pid
);
1039 retval
= security_task_getpgid(p
);
1043 retval
= pid_vnr(grp
);
1049 #ifdef __ARCH_WANT_SYS_GETPGRP
1051 SYSCALL_DEFINE0(getpgrp
)
1053 return sys_getpgid(0);
1058 SYSCALL_DEFINE1(getsid
, pid_t
, pid
)
1060 struct task_struct
*p
;
1066 sid
= task_session(current
);
1069 p
= find_task_by_vpid(pid
);
1072 sid
= task_session(p
);
1076 retval
= security_task_getsid(p
);
1080 retval
= pid_vnr(sid
);
1086 SYSCALL_DEFINE0(setsid
)
1088 struct task_struct
*group_leader
= current
->group_leader
;
1089 struct pid
*sid
= task_pid(group_leader
);
1090 pid_t session
= pid_vnr(sid
);
1093 write_lock_irq(&tasklist_lock
);
1094 /* Fail if I am already a session leader */
1095 if (group_leader
->signal
->leader
)
1098 /* Fail if a process group id already exists that equals the
1099 * proposed session id.
1101 if (pid_task(sid
, PIDTYPE_PGID
))
1104 group_leader
->signal
->leader
= 1;
1105 __set_special_pids(sid
);
1107 proc_clear_tty(group_leader
);
1111 write_unlock_irq(&tasklist_lock
);
1113 proc_sid_connector(group_leader
);
1114 sched_autogroup_create_attach(group_leader
);
1119 DECLARE_RWSEM(uts_sem
);
1121 #ifdef COMPAT_UTS_MACHINE
1122 #define override_architecture(name) \
1123 (personality(current->personality) == PER_LINUX32 && \
1124 copy_to_user(name->machine, COMPAT_UTS_MACHINE, \
1125 sizeof(COMPAT_UTS_MACHINE)))
1127 #define override_architecture(name) 0
1130 SYSCALL_DEFINE1(newuname
, struct new_utsname __user
*, name
)
1134 down_read(&uts_sem
);
1135 if (copy_to_user(name
, utsname(), sizeof *name
))
1139 if (!errno
&& override_architecture(name
))
1144 #ifdef __ARCH_WANT_SYS_OLD_UNAME
1148 SYSCALL_DEFINE1(uname
, struct old_utsname __user
*, name
)
1155 down_read(&uts_sem
);
1156 if (copy_to_user(name
, utsname(), sizeof(*name
)))
1160 if (!error
&& override_architecture(name
))
1165 SYSCALL_DEFINE1(olduname
, struct oldold_utsname __user
*, name
)
1171 if (!access_ok(VERIFY_WRITE
, name
, sizeof(struct oldold_utsname
)))
1174 down_read(&uts_sem
);
1175 error
= __copy_to_user(&name
->sysname
, &utsname()->sysname
,
1177 error
|= __put_user(0, name
->sysname
+ __OLD_UTS_LEN
);
1178 error
|= __copy_to_user(&name
->nodename
, &utsname()->nodename
,
1180 error
|= __put_user(0, name
->nodename
+ __OLD_UTS_LEN
);
1181 error
|= __copy_to_user(&name
->release
, &utsname()->release
,
1183 error
|= __put_user(0, name
->release
+ __OLD_UTS_LEN
);
1184 error
|= __copy_to_user(&name
->version
, &utsname()->version
,
1186 error
|= __put_user(0, name
->version
+ __OLD_UTS_LEN
);
1187 error
|= __copy_to_user(&name
->machine
, &utsname()->machine
,
1189 error
|= __put_user(0, name
->machine
+ __OLD_UTS_LEN
);
1192 if (!error
&& override_architecture(name
))
1194 return error
? -EFAULT
: 0;
1198 SYSCALL_DEFINE2(sethostname
, char __user
*, name
, int, len
)
1201 char tmp
[__NEW_UTS_LEN
];
1203 if (!ns_capable(current
->nsproxy
->uts_ns
->user_ns
, CAP_SYS_ADMIN
))
1206 if (len
< 0 || len
> __NEW_UTS_LEN
)
1208 down_write(&uts_sem
);
1210 if (!copy_from_user(tmp
, name
, len
)) {
1211 struct new_utsname
*u
= utsname();
1213 memcpy(u
->nodename
, tmp
, len
);
1214 memset(u
->nodename
+ len
, 0, sizeof(u
->nodename
) - len
);
1221 #ifdef __ARCH_WANT_SYS_GETHOSTNAME
1223 SYSCALL_DEFINE2(gethostname
, char __user
*, name
, int, len
)
1226 struct new_utsname
*u
;
1230 down_read(&uts_sem
);
1232 i
= 1 + strlen(u
->nodename
);
1236 if (copy_to_user(name
, u
->nodename
, i
))
1245 * Only setdomainname; getdomainname can be implemented by calling
1248 SYSCALL_DEFINE2(setdomainname
, char __user
*, name
, int, len
)
1251 char tmp
[__NEW_UTS_LEN
];
1253 if (!ns_capable(current
->nsproxy
->uts_ns
->user_ns
, CAP_SYS_ADMIN
))
1255 if (len
< 0 || len
> __NEW_UTS_LEN
)
1258 down_write(&uts_sem
);
1260 if (!copy_from_user(tmp
, name
, len
)) {
1261 struct new_utsname
*u
= utsname();
1263 memcpy(u
->domainname
, tmp
, len
);
1264 memset(u
->domainname
+ len
, 0, sizeof(u
->domainname
) - len
);
1271 SYSCALL_DEFINE2(getrlimit
, unsigned int, resource
, struct rlimit __user
*, rlim
)
1273 struct rlimit value
;
1276 ret
= do_prlimit(current
, resource
, NULL
, &value
);
1278 ret
= copy_to_user(rlim
, &value
, sizeof(*rlim
)) ? -EFAULT
: 0;
1283 #ifdef __ARCH_WANT_SYS_OLD_GETRLIMIT
1286 * Back compatibility for getrlimit. Needed for some apps.
1289 SYSCALL_DEFINE2(old_getrlimit
, unsigned int, resource
,
1290 struct rlimit __user
*, rlim
)
1293 if (resource
>= RLIM_NLIMITS
)
1296 task_lock(current
->group_leader
);
1297 x
= current
->signal
->rlim
[resource
];
1298 task_unlock(current
->group_leader
);
1299 if (x
.rlim_cur
> 0x7FFFFFFF)
1300 x
.rlim_cur
= 0x7FFFFFFF;
1301 if (x
.rlim_max
> 0x7FFFFFFF)
1302 x
.rlim_max
= 0x7FFFFFFF;
1303 return copy_to_user(rlim
, &x
, sizeof(x
))?-EFAULT
:0;
1308 static inline bool rlim64_is_infinity(__u64 rlim64
)
1310 #if BITS_PER_LONG < 64
1311 return rlim64
>= ULONG_MAX
;
1313 return rlim64
== RLIM64_INFINITY
;
1317 static void rlim_to_rlim64(const struct rlimit
*rlim
, struct rlimit64
*rlim64
)
1319 if (rlim
->rlim_cur
== RLIM_INFINITY
)
1320 rlim64
->rlim_cur
= RLIM64_INFINITY
;
1322 rlim64
->rlim_cur
= rlim
->rlim_cur
;
1323 if (rlim
->rlim_max
== RLIM_INFINITY
)
1324 rlim64
->rlim_max
= RLIM64_INFINITY
;
1326 rlim64
->rlim_max
= rlim
->rlim_max
;
1329 static void rlim64_to_rlim(const struct rlimit64
*rlim64
, struct rlimit
*rlim
)
1331 if (rlim64_is_infinity(rlim64
->rlim_cur
))
1332 rlim
->rlim_cur
= RLIM_INFINITY
;
1334 rlim
->rlim_cur
= (unsigned long)rlim64
->rlim_cur
;
1335 if (rlim64_is_infinity(rlim64
->rlim_max
))
1336 rlim
->rlim_max
= RLIM_INFINITY
;
1338 rlim
->rlim_max
= (unsigned long)rlim64
->rlim_max
;
1341 /* make sure you are allowed to change @tsk limits before calling this */
1342 int do_prlimit(struct task_struct
*tsk
, unsigned int resource
,
1343 struct rlimit
*new_rlim
, struct rlimit
*old_rlim
)
1345 struct rlimit
*rlim
;
1348 if (resource
>= RLIM_NLIMITS
)
1351 if (new_rlim
->rlim_cur
> new_rlim
->rlim_max
)
1353 if (resource
== RLIMIT_NOFILE
&&
1354 new_rlim
->rlim_max
> sysctl_nr_open
)
1358 /* protect tsk->signal and tsk->sighand from disappearing */
1359 read_lock(&tasklist_lock
);
1360 if (!tsk
->sighand
) {
1365 rlim
= tsk
->signal
->rlim
+ resource
;
1366 task_lock(tsk
->group_leader
);
1368 /* Keep the capable check against init_user_ns until
1369 cgroups can contain all limits */
1370 if (new_rlim
->rlim_max
> rlim
->rlim_max
&&
1371 !capable(CAP_SYS_RESOURCE
))
1374 retval
= security_task_setrlimit(tsk
->group_leader
,
1375 resource
, new_rlim
);
1376 if (resource
== RLIMIT_CPU
&& new_rlim
->rlim_cur
== 0) {
1378 * The caller is asking for an immediate RLIMIT_CPU
1379 * expiry. But we use the zero value to mean "it was
1380 * never set". So let's cheat and make it one second
1383 new_rlim
->rlim_cur
= 1;
1392 task_unlock(tsk
->group_leader
);
1395 * RLIMIT_CPU handling. Note that the kernel fails to return an error
1396 * code if it rejected the user's attempt to set RLIMIT_CPU. This is a
1397 * very long-standing error, and fixing it now risks breakage of
1398 * applications, so we live with it
1400 if (!retval
&& new_rlim
&& resource
== RLIMIT_CPU
&&
1401 new_rlim
->rlim_cur
!= RLIM_INFINITY
)
1402 update_rlimit_cpu(tsk
, new_rlim
->rlim_cur
);
1404 read_unlock(&tasklist_lock
);
1408 /* rcu lock must be held */
1409 static int check_prlimit_permission(struct task_struct
*task
)
1411 const struct cred
*cred
= current_cred(), *tcred
;
1413 if (current
== task
)
1416 tcred
= __task_cred(task
);
1417 if (cred
->user
->user_ns
== tcred
->user
->user_ns
&&
1418 (cred
->uid
== tcred
->euid
&&
1419 cred
->uid
== tcred
->suid
&&
1420 cred
->uid
== tcred
->uid
&&
1421 cred
->gid
== tcred
->egid
&&
1422 cred
->gid
== tcred
->sgid
&&
1423 cred
->gid
== tcred
->gid
))
1425 if (ns_capable(tcred
->user
->user_ns
, CAP_SYS_RESOURCE
))
1431 SYSCALL_DEFINE4(prlimit64
, pid_t
, pid
, unsigned int, resource
,
1432 const struct rlimit64 __user
*, new_rlim
,
1433 struct rlimit64 __user
*, old_rlim
)
1435 struct rlimit64 old64
, new64
;
1436 struct rlimit old
, new;
1437 struct task_struct
*tsk
;
1441 if (copy_from_user(&new64
, new_rlim
, sizeof(new64
)))
1443 rlim64_to_rlim(&new64
, &new);
1447 tsk
= pid
? find_task_by_vpid(pid
) : current
;
1452 ret
= check_prlimit_permission(tsk
);
1457 get_task_struct(tsk
);
1460 ret
= do_prlimit(tsk
, resource
, new_rlim
? &new : NULL
,
1461 old_rlim
? &old
: NULL
);
1463 if (!ret
&& old_rlim
) {
1464 rlim_to_rlim64(&old
, &old64
);
1465 if (copy_to_user(old_rlim
, &old64
, sizeof(old64
)))
1469 put_task_struct(tsk
);
1473 SYSCALL_DEFINE2(setrlimit
, unsigned int, resource
, struct rlimit __user
*, rlim
)
1475 struct rlimit new_rlim
;
1477 if (copy_from_user(&new_rlim
, rlim
, sizeof(*rlim
)))
1479 return do_prlimit(current
, resource
, &new_rlim
, NULL
);
1483 * It would make sense to put struct rusage in the task_struct,
1484 * except that would make the task_struct be *really big*. After
1485 * task_struct gets moved into malloc'ed memory, it would
1486 * make sense to do this. It will make moving the rest of the information
1487 * a lot simpler! (Which we're not doing right now because we're not
1488 * measuring them yet).
1490 * When sampling multiple threads for RUSAGE_SELF, under SMP we might have
1491 * races with threads incrementing their own counters. But since word
1492 * reads are atomic, we either get new values or old values and we don't
1493 * care which for the sums. We always take the siglock to protect reading
1494 * the c* fields from p->signal from races with exit.c updating those
1495 * fields when reaping, so a sample either gets all the additions of a
1496 * given child after it's reaped, or none so this sample is before reaping.
1499 * We need to take the siglock for CHILDEREN, SELF and BOTH
1500 * for the cases current multithreaded, non-current single threaded
1501 * non-current multithreaded. Thread traversal is now safe with
1503 * Strictly speaking, we donot need to take the siglock if we are current and
1504 * single threaded, as no one else can take our signal_struct away, no one
1505 * else can reap the children to update signal->c* counters, and no one else
1506 * can race with the signal-> fields. If we do not take any lock, the
1507 * signal-> fields could be read out of order while another thread was just
1508 * exiting. So we should place a read memory barrier when we avoid the lock.
1509 * On the writer side, write memory barrier is implied in __exit_signal
1510 * as __exit_signal releases the siglock spinlock after updating the signal->
1511 * fields. But we don't do this yet to keep things simple.
1515 static void accumulate_thread_rusage(struct task_struct
*t
, struct rusage
*r
)
1517 r
->ru_nvcsw
+= t
->nvcsw
;
1518 r
->ru_nivcsw
+= t
->nivcsw
;
1519 r
->ru_minflt
+= t
->min_flt
;
1520 r
->ru_majflt
+= t
->maj_flt
;
1521 r
->ru_inblock
+= task_io_get_inblock(t
);
1522 r
->ru_oublock
+= task_io_get_oublock(t
);
1525 static void k_getrusage(struct task_struct
*p
, int who
, struct rusage
*r
)
1527 struct task_struct
*t
;
1528 unsigned long flags
;
1529 cputime_t tgutime
, tgstime
, utime
, stime
;
1530 unsigned long maxrss
= 0;
1532 memset((char *) r
, 0, sizeof *r
);
1533 utime
= stime
= cputime_zero
;
1535 if (who
== RUSAGE_THREAD
) {
1536 task_times(current
, &utime
, &stime
);
1537 accumulate_thread_rusage(p
, r
);
1538 maxrss
= p
->signal
->maxrss
;
1542 if (!lock_task_sighand(p
, &flags
))
1547 case RUSAGE_CHILDREN
:
1548 utime
= p
->signal
->cutime
;
1549 stime
= p
->signal
->cstime
;
1550 r
->ru_nvcsw
= p
->signal
->cnvcsw
;
1551 r
->ru_nivcsw
= p
->signal
->cnivcsw
;
1552 r
->ru_minflt
= p
->signal
->cmin_flt
;
1553 r
->ru_majflt
= p
->signal
->cmaj_flt
;
1554 r
->ru_inblock
= p
->signal
->cinblock
;
1555 r
->ru_oublock
= p
->signal
->coublock
;
1556 maxrss
= p
->signal
->cmaxrss
;
1558 if (who
== RUSAGE_CHILDREN
)
1562 thread_group_times(p
, &tgutime
, &tgstime
);
1563 utime
= cputime_add(utime
, tgutime
);
1564 stime
= cputime_add(stime
, tgstime
);
1565 r
->ru_nvcsw
+= p
->signal
->nvcsw
;
1566 r
->ru_nivcsw
+= p
->signal
->nivcsw
;
1567 r
->ru_minflt
+= p
->signal
->min_flt
;
1568 r
->ru_majflt
+= p
->signal
->maj_flt
;
1569 r
->ru_inblock
+= p
->signal
->inblock
;
1570 r
->ru_oublock
+= p
->signal
->oublock
;
1571 if (maxrss
< p
->signal
->maxrss
)
1572 maxrss
= p
->signal
->maxrss
;
1575 accumulate_thread_rusage(t
, r
);
1583 unlock_task_sighand(p
, &flags
);
1586 cputime_to_timeval(utime
, &r
->ru_utime
);
1587 cputime_to_timeval(stime
, &r
->ru_stime
);
1589 if (who
!= RUSAGE_CHILDREN
) {
1590 struct mm_struct
*mm
= get_task_mm(p
);
1592 setmax_mm_hiwater_rss(&maxrss
, mm
);
1596 r
->ru_maxrss
= maxrss
* (PAGE_SIZE
/ 1024); /* convert pages to KBs */
1599 int getrusage(struct task_struct
*p
, int who
, struct rusage __user
*ru
)
1602 k_getrusage(p
, who
, &r
);
1603 return copy_to_user(ru
, &r
, sizeof(r
)) ? -EFAULT
: 0;
1606 SYSCALL_DEFINE2(getrusage
, int, who
, struct rusage __user
*, ru
)
1608 if (who
!= RUSAGE_SELF
&& who
!= RUSAGE_CHILDREN
&&
1609 who
!= RUSAGE_THREAD
)
1611 return getrusage(current
, who
, ru
);
1614 SYSCALL_DEFINE1(umask
, int, mask
)
1616 mask
= xchg(¤t
->fs
->umask
, mask
& S_IRWXUGO
);
1620 SYSCALL_DEFINE5(prctl
, int, option
, unsigned long, arg2
, unsigned long, arg3
,
1621 unsigned long, arg4
, unsigned long, arg5
)
1623 struct task_struct
*me
= current
;
1624 unsigned char comm
[sizeof(me
->comm
)];
1627 error
= security_task_prctl(option
, arg2
, arg3
, arg4
, arg5
);
1628 if (error
!= -ENOSYS
)
1633 case PR_SET_PDEATHSIG
:
1634 if (!valid_signal(arg2
)) {
1638 me
->pdeath_signal
= arg2
;
1641 case PR_GET_PDEATHSIG
:
1642 error
= put_user(me
->pdeath_signal
, (int __user
*)arg2
);
1644 case PR_GET_DUMPABLE
:
1645 error
= get_dumpable(me
->mm
);
1647 case PR_SET_DUMPABLE
:
1648 if (arg2
< 0 || arg2
> 1) {
1652 set_dumpable(me
->mm
, arg2
);
1656 case PR_SET_UNALIGN
:
1657 error
= SET_UNALIGN_CTL(me
, arg2
);
1659 case PR_GET_UNALIGN
:
1660 error
= GET_UNALIGN_CTL(me
, arg2
);
1663 error
= SET_FPEMU_CTL(me
, arg2
);
1666 error
= GET_FPEMU_CTL(me
, arg2
);
1669 error
= SET_FPEXC_CTL(me
, arg2
);
1672 error
= GET_FPEXC_CTL(me
, arg2
);
1675 error
= PR_TIMING_STATISTICAL
;
1678 if (arg2
!= PR_TIMING_STATISTICAL
)
1685 comm
[sizeof(me
->comm
)-1] = 0;
1686 if (strncpy_from_user(comm
, (char __user
*)arg2
,
1687 sizeof(me
->comm
) - 1) < 0)
1689 set_task_comm(me
, comm
);
1692 get_task_comm(comm
, me
);
1693 if (copy_to_user((char __user
*)arg2
, comm
,
1698 error
= GET_ENDIAN(me
, arg2
);
1701 error
= SET_ENDIAN(me
, arg2
);
1704 case PR_GET_SECCOMP
:
1705 error
= prctl_get_seccomp();
1707 case PR_SET_SECCOMP
:
1708 error
= prctl_set_seccomp(arg2
);
1711 error
= GET_TSC_CTL(arg2
);
1714 error
= SET_TSC_CTL(arg2
);
1716 case PR_TASK_PERF_EVENTS_DISABLE
:
1717 error
= perf_event_task_disable();
1719 case PR_TASK_PERF_EVENTS_ENABLE
:
1720 error
= perf_event_task_enable();
1722 case PR_GET_TIMERSLACK
:
1723 error
= current
->timer_slack_ns
;
1725 case PR_SET_TIMERSLACK
:
1727 current
->timer_slack_ns
=
1728 current
->default_timer_slack_ns
;
1730 current
->timer_slack_ns
= arg2
;
1737 case PR_MCE_KILL_CLEAR
:
1740 current
->flags
&= ~PF_MCE_PROCESS
;
1742 case PR_MCE_KILL_SET
:
1743 current
->flags
|= PF_MCE_PROCESS
;
1744 if (arg3
== PR_MCE_KILL_EARLY
)
1745 current
->flags
|= PF_MCE_EARLY
;
1746 else if (arg3
== PR_MCE_KILL_LATE
)
1747 current
->flags
&= ~PF_MCE_EARLY
;
1748 else if (arg3
== PR_MCE_KILL_DEFAULT
)
1750 ~(PF_MCE_EARLY
|PF_MCE_PROCESS
);
1759 case PR_MCE_KILL_GET
:
1760 if (arg2
| arg3
| arg4
| arg5
)
1762 if (current
->flags
& PF_MCE_PROCESS
)
1763 error
= (current
->flags
& PF_MCE_EARLY
) ?
1764 PR_MCE_KILL_EARLY
: PR_MCE_KILL_LATE
;
1766 error
= PR_MCE_KILL_DEFAULT
;
1775 SYSCALL_DEFINE3(getcpu
, unsigned __user
*, cpup
, unsigned __user
*, nodep
,
1776 struct getcpu_cache __user
*, unused
)
1779 int cpu
= raw_smp_processor_id();
1781 err
|= put_user(cpu
, cpup
);
1783 err
|= put_user(cpu_to_node(cpu
), nodep
);
1784 return err
? -EFAULT
: 0;
1787 char poweroff_cmd
[POWEROFF_CMD_PATH_LEN
] = "/sbin/poweroff";
1789 static void argv_cleanup(struct subprocess_info
*info
)
1791 argv_free(info
->argv
);
1795 * orderly_poweroff - Trigger an orderly system poweroff
1796 * @force: force poweroff if command execution fails
1798 * This may be called from any context to trigger a system shutdown.
1799 * If the orderly shutdown fails, it will force an immediate shutdown.
1801 int orderly_poweroff(bool force
)
1804 char **argv
= argv_split(GFP_ATOMIC
, poweroff_cmd
, &argc
);
1805 static char *envp
[] = {
1807 "PATH=/sbin:/bin:/usr/sbin:/usr/bin",
1811 struct subprocess_info
*info
;
1814 printk(KERN_WARNING
"%s failed to allocate memory for \"%s\"\n",
1815 __func__
, poweroff_cmd
);
1819 info
= call_usermodehelper_setup(argv
[0], argv
, envp
, GFP_ATOMIC
);
1825 call_usermodehelper_setfns(info
, NULL
, argv_cleanup
, NULL
);
1827 ret
= call_usermodehelper_exec(info
, UMH_NO_WAIT
);
1831 printk(KERN_WARNING
"Failed to start orderly shutdown: "
1832 "forcing the issue\n");
1834 /* I guess this should try to kick off some daemon to
1835 sync and poweroff asap. Or not even bother syncing
1836 if we're doing an emergency shutdown? */
1843 EXPORT_SYMBOL_GPL(orderly_poweroff
);