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/ptrace.h>
37 #include <linux/fs_struct.h>
39 #include <linux/compat.h>
40 #include <linux/syscalls.h>
41 #include <linux/kprobes.h>
42 #include <linux/user_namespace.h>
44 #include <asm/uaccess.h>
46 #include <asm/unistd.h>
48 #ifndef SET_UNALIGN_CTL
49 # define SET_UNALIGN_CTL(a,b) (-EINVAL)
51 #ifndef GET_UNALIGN_CTL
52 # define GET_UNALIGN_CTL(a,b) (-EINVAL)
55 # define SET_FPEMU_CTL(a,b) (-EINVAL)
58 # define GET_FPEMU_CTL(a,b) (-EINVAL)
61 # define SET_FPEXC_CTL(a,b) (-EINVAL)
64 # define GET_FPEXC_CTL(a,b) (-EINVAL)
67 # define GET_ENDIAN(a,b) (-EINVAL)
70 # define SET_ENDIAN(a,b) (-EINVAL)
73 # define GET_TSC_CTL(a) (-EINVAL)
76 # define SET_TSC_CTL(a) (-EINVAL)
80 * this is where the system-wide overflow UID and GID are defined, for
81 * architectures that now have 32-bit UID/GID but didn't in the past
84 int overflowuid
= DEFAULT_OVERFLOWUID
;
85 int overflowgid
= DEFAULT_OVERFLOWGID
;
88 EXPORT_SYMBOL(overflowuid
);
89 EXPORT_SYMBOL(overflowgid
);
93 * the same as above, but for filesystems which can only store a 16-bit
94 * UID and GID. as such, this is needed on all architectures
97 int fs_overflowuid
= DEFAULT_FS_OVERFLOWUID
;
98 int fs_overflowgid
= DEFAULT_FS_OVERFLOWUID
;
100 EXPORT_SYMBOL(fs_overflowuid
);
101 EXPORT_SYMBOL(fs_overflowgid
);
104 * this indicates whether you can reboot with ctrl-alt-del: the default is yes
109 EXPORT_SYMBOL(cad_pid
);
112 * If set, this is used for preparing the system to power off.
115 void (*pm_power_off_prepare
)(void);
118 * set the priority of a task
119 * - the caller must hold the RCU read lock
121 static int set_one_prio(struct task_struct
*p
, int niceval
, int error
)
123 const struct cred
*cred
= current_cred(), *pcred
= __task_cred(p
);
126 if (pcred
->uid
!= cred
->euid
&&
127 pcred
->euid
!= cred
->euid
&& !capable(CAP_SYS_NICE
)) {
131 if (niceval
< task_nice(p
) && !can_nice(p
, niceval
)) {
135 no_nice
= security_task_setnice(p
, niceval
);
142 set_user_nice(p
, niceval
);
147 SYSCALL_DEFINE3(setpriority
, int, which
, int, who
, int, niceval
)
149 struct task_struct
*g
, *p
;
150 struct user_struct
*user
;
151 const struct cred
*cred
= current_cred();
155 if (which
> PRIO_USER
|| which
< PRIO_PROCESS
)
158 /* normalize: avoid signed division (rounding problems) */
166 read_lock(&tasklist_lock
);
170 p
= find_task_by_vpid(who
);
174 error
= set_one_prio(p
, niceval
, error
);
178 pgrp
= find_vpid(who
);
180 pgrp
= task_pgrp(current
);
181 do_each_pid_thread(pgrp
, PIDTYPE_PGID
, p
) {
182 error
= set_one_prio(p
, niceval
, error
);
183 } while_each_pid_thread(pgrp
, PIDTYPE_PGID
, p
);
186 user
= (struct user_struct
*) cred
->user
;
189 else if ((who
!= cred
->uid
) &&
190 !(user
= find_user(who
)))
191 goto out_unlock
; /* No processes for this user */
193 do_each_thread(g
, p
) {
194 if (__task_cred(p
)->uid
== who
)
195 error
= set_one_prio(p
, niceval
, error
);
196 } while_each_thread(g
, p
);
197 if (who
!= cred
->uid
)
198 free_uid(user
); /* For find_user() */
202 read_unlock(&tasklist_lock
);
209 * Ugh. To avoid negative return values, "getpriority()" will
210 * not return the normal nice-value, but a negated value that
211 * has been offset by 20 (ie it returns 40..1 instead of -20..19)
212 * to stay compatible.
214 SYSCALL_DEFINE2(getpriority
, int, which
, int, who
)
216 struct task_struct
*g
, *p
;
217 struct user_struct
*user
;
218 const struct cred
*cred
= current_cred();
219 long niceval
, retval
= -ESRCH
;
222 if (which
> PRIO_USER
|| which
< PRIO_PROCESS
)
226 read_lock(&tasklist_lock
);
230 p
= find_task_by_vpid(who
);
234 niceval
= 20 - task_nice(p
);
235 if (niceval
> retval
)
241 pgrp
= find_vpid(who
);
243 pgrp
= task_pgrp(current
);
244 do_each_pid_thread(pgrp
, PIDTYPE_PGID
, p
) {
245 niceval
= 20 - task_nice(p
);
246 if (niceval
> retval
)
248 } while_each_pid_thread(pgrp
, PIDTYPE_PGID
, p
);
251 user
= (struct user_struct
*) cred
->user
;
254 else if ((who
!= cred
->uid
) &&
255 !(user
= find_user(who
)))
256 goto out_unlock
; /* No processes for this user */
258 do_each_thread(g
, p
) {
259 if (__task_cred(p
)->uid
== who
) {
260 niceval
= 20 - task_nice(p
);
261 if (niceval
> retval
)
264 } while_each_thread(g
, p
);
265 if (who
!= cred
->uid
)
266 free_uid(user
); /* for find_user() */
270 read_unlock(&tasklist_lock
);
277 * emergency_restart - reboot the system
279 * Without shutting down any hardware or taking any locks
280 * reboot the system. This is called when we know we are in
281 * trouble so this is our best effort to reboot. This is
282 * safe to call in interrupt context.
284 void emergency_restart(void)
286 machine_emergency_restart();
288 EXPORT_SYMBOL_GPL(emergency_restart
);
290 void kernel_restart_prepare(char *cmd
)
292 blocking_notifier_call_chain(&reboot_notifier_list
, SYS_RESTART
, cmd
);
293 system_state
= SYSTEM_RESTART
;
299 * kernel_restart - reboot the system
300 * @cmd: pointer to buffer containing command to execute for restart
303 * Shutdown everything and perform a clean reboot.
304 * This is not safe to call in interrupt context.
306 void kernel_restart(char *cmd
)
308 kernel_restart_prepare(cmd
);
310 printk(KERN_EMERG
"Restarting system.\n");
312 printk(KERN_EMERG
"Restarting system with command '%s'.\n", cmd
);
313 machine_restart(cmd
);
315 EXPORT_SYMBOL_GPL(kernel_restart
);
317 static void kernel_shutdown_prepare(enum system_states state
)
319 blocking_notifier_call_chain(&reboot_notifier_list
,
320 (state
== SYSTEM_HALT
)?SYS_HALT
:SYS_POWER_OFF
, NULL
);
321 system_state
= state
;
325 * kernel_halt - halt the system
327 * Shutdown everything and perform a clean system halt.
329 void kernel_halt(void)
331 kernel_shutdown_prepare(SYSTEM_HALT
);
333 printk(KERN_EMERG
"System halted.\n");
337 EXPORT_SYMBOL_GPL(kernel_halt
);
340 * kernel_power_off - power_off the system
342 * Shutdown everything and perform a clean system power_off.
344 void kernel_power_off(void)
346 kernel_shutdown_prepare(SYSTEM_POWER_OFF
);
347 if (pm_power_off_prepare
)
348 pm_power_off_prepare();
349 disable_nonboot_cpus();
351 printk(KERN_EMERG
"Power down.\n");
354 EXPORT_SYMBOL_GPL(kernel_power_off
);
356 static DEFINE_MUTEX(reboot_mutex
);
359 * Reboot system call: for obvious reasons only root may call it,
360 * and even root needs to set up some magic numbers in the registers
361 * so that some mistake won't make this reboot the whole machine.
362 * You can also set the meaning of the ctrl-alt-del-key here.
364 * reboot doesn't sync: do that yourself before calling this.
366 SYSCALL_DEFINE4(reboot
, int, magic1
, int, magic2
, unsigned int, cmd
,
372 /* We only trust the superuser with rebooting the system. */
373 if (!capable(CAP_SYS_BOOT
))
376 /* For safety, we require "magic" arguments. */
377 if (magic1
!= LINUX_REBOOT_MAGIC1
||
378 (magic2
!= LINUX_REBOOT_MAGIC2
&&
379 magic2
!= LINUX_REBOOT_MAGIC2A
&&
380 magic2
!= LINUX_REBOOT_MAGIC2B
&&
381 magic2
!= LINUX_REBOOT_MAGIC2C
))
384 /* Instead of trying to make the power_off code look like
385 * halt when pm_power_off is not set do it the easy way.
387 if ((cmd
== LINUX_REBOOT_CMD_POWER_OFF
) && !pm_power_off
)
388 cmd
= LINUX_REBOOT_CMD_HALT
;
390 mutex_lock(&reboot_mutex
);
392 case LINUX_REBOOT_CMD_RESTART
:
393 kernel_restart(NULL
);
396 case LINUX_REBOOT_CMD_CAD_ON
:
400 case LINUX_REBOOT_CMD_CAD_OFF
:
404 case LINUX_REBOOT_CMD_HALT
:
407 panic("cannot halt");
409 case LINUX_REBOOT_CMD_POWER_OFF
:
414 case LINUX_REBOOT_CMD_RESTART2
:
415 if (strncpy_from_user(&buffer
[0], arg
, sizeof(buffer
) - 1) < 0) {
419 buffer
[sizeof(buffer
) - 1] = '\0';
421 kernel_restart(buffer
);
425 case LINUX_REBOOT_CMD_KEXEC
:
426 ret
= kernel_kexec();
430 #ifdef CONFIG_HIBERNATION
431 case LINUX_REBOOT_CMD_SW_SUSPEND
:
440 mutex_unlock(&reboot_mutex
);
444 static void deferred_cad(struct work_struct
*dummy
)
446 kernel_restart(NULL
);
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.
454 void ctrl_alt_del(void)
456 static DECLARE_WORK(cad_work
, deferred_cad
);
459 schedule_work(&cad_work
);
461 kill_cad_pid(SIGINT
, 1);
465 * Unprivileged users may change the real gid to the effective gid
466 * or vice versa. (BSD-style)
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.
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.
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.
479 * SMP: There are not races, the GIDs are checked only by filesystem
480 * operations (as far as semantic preservation is concerned).
482 SYSCALL_DEFINE2(setregid
, gid_t
, rgid
, gid_t
, egid
)
484 const struct cred
*old
;
488 new = prepare_creds();
491 old
= current_cred();
493 retval
= security_task_setgid(rgid
, egid
, (gid_t
)-1, LSM_SETID_RE
);
498 if (rgid
!= (gid_t
) -1) {
499 if (old
->gid
== rgid
||
506 if (egid
!= (gid_t
) -1) {
507 if (old
->gid
== egid
||
516 if (rgid
!= (gid_t
) -1 ||
517 (egid
!= (gid_t
) -1 && egid
!= old
->gid
))
518 new->sgid
= new->egid
;
519 new->fsgid
= new->egid
;
521 return commit_creds(new);
529 * setgid() is implemented like SysV w/ SAVED_IDS
531 * SMP: Same implicit races as above.
533 SYSCALL_DEFINE1(setgid
, gid_t
, gid
)
535 const struct cred
*old
;
539 new = prepare_creds();
542 old
= current_cred();
544 retval
= security_task_setgid(gid
, (gid_t
)-1, (gid_t
)-1, LSM_SETID_ID
);
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
;
556 return commit_creds(new);
564 * change the user struct in a credentials set to match the new UID
566 static int set_user(struct cred
*new)
568 struct user_struct
*new_user
;
570 new_user
= alloc_uid(current_user_ns(), new->uid
);
574 if (atomic_read(&new_user
->processes
) >= rlimit(RLIMIT_NPROC
) &&
575 new_user
!= INIT_USER
) {
581 new->user
= new_user
;
586 * Unprivileged users may change the real uid to the effective uid
587 * or vice versa. (BSD-style)
589 * If you set the real uid at all, or set the effective uid to a value not
590 * equal to the real uid, then the saved uid is set to the new effective uid.
592 * This makes it possible for a setuid program to completely drop its
593 * privileges, which is often a useful assertion to make when you are doing
594 * a security audit over a program.
596 * The general idea is that a program which uses just setreuid() will be
597 * 100% compatible with BSD. A program which uses just setuid() will be
598 * 100% compatible with POSIX with saved IDs.
600 SYSCALL_DEFINE2(setreuid
, uid_t
, ruid
, uid_t
, euid
)
602 const struct cred
*old
;
606 new = prepare_creds();
609 old
= current_cred();
611 retval
= security_task_setuid(ruid
, euid
, (uid_t
)-1, LSM_SETID_RE
);
616 if (ruid
!= (uid_t
) -1) {
618 if (old
->uid
!= ruid
&&
620 !capable(CAP_SETUID
))
624 if (euid
!= (uid_t
) -1) {
626 if (old
->uid
!= euid
&&
629 !capable(CAP_SETUID
))
633 if (new->uid
!= old
->uid
) {
634 retval
= set_user(new);
638 if (ruid
!= (uid_t
) -1 ||
639 (euid
!= (uid_t
) -1 && euid
!= old
->uid
))
640 new->suid
= new->euid
;
641 new->fsuid
= new->euid
;
643 retval
= security_task_fix_setuid(new, old
, LSM_SETID_RE
);
647 return commit_creds(new);
655 * setuid() is implemented like SysV with SAVED_IDS
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.
665 SYSCALL_DEFINE1(setuid
, uid_t
, uid
)
667 const struct cred
*old
;
671 new = prepare_creds();
674 old
= current_cred();
676 retval
= security_task_setuid(uid
, (uid_t
)-1, (uid_t
)-1, LSM_SETID_ID
);
681 if (capable(CAP_SETUID
)) {
682 new->suid
= new->uid
= uid
;
683 if (uid
!= old
->uid
) {
684 retval
= set_user(new);
688 } else if (uid
!= old
->uid
&& uid
!= new->suid
) {
692 new->fsuid
= new->euid
= uid
;
694 retval
= security_task_fix_setuid(new, old
, LSM_SETID_ID
);
698 return commit_creds(new);
707 * This function implements a generic ability to update ruid, euid,
708 * and suid. This allows you to implement the 4.4 compatible seteuid().
710 SYSCALL_DEFINE3(setresuid
, uid_t
, ruid
, uid_t
, euid
, uid_t
, suid
)
712 const struct cred
*old
;
716 new = prepare_creds();
720 retval
= security_task_setuid(ruid
, euid
, suid
, LSM_SETID_RES
);
723 old
= current_cred();
726 if (!capable(CAP_SETUID
)) {
727 if (ruid
!= (uid_t
) -1 && ruid
!= old
->uid
&&
728 ruid
!= old
->euid
&& ruid
!= old
->suid
)
730 if (euid
!= (uid_t
) -1 && euid
!= old
->uid
&&
731 euid
!= old
->euid
&& euid
!= old
->suid
)
733 if (suid
!= (uid_t
) -1 && suid
!= old
->uid
&&
734 suid
!= old
->euid
&& suid
!= old
->suid
)
738 if (ruid
!= (uid_t
) -1) {
740 if (ruid
!= old
->uid
) {
741 retval
= set_user(new);
746 if (euid
!= (uid_t
) -1)
748 if (suid
!= (uid_t
) -1)
750 new->fsuid
= new->euid
;
752 retval
= security_task_fix_setuid(new, old
, LSM_SETID_RES
);
756 return commit_creds(new);
763 SYSCALL_DEFINE3(getresuid
, uid_t __user
*, ruid
, uid_t __user
*, euid
, uid_t __user
*, suid
)
765 const struct cred
*cred
= current_cred();
768 if (!(retval
= put_user(cred
->uid
, ruid
)) &&
769 !(retval
= put_user(cred
->euid
, euid
)))
770 retval
= put_user(cred
->suid
, suid
);
776 * Same as above, but for rgid, egid, sgid.
778 SYSCALL_DEFINE3(setresgid
, gid_t
, rgid
, gid_t
, egid
, gid_t
, sgid
)
780 const struct cred
*old
;
784 new = prepare_creds();
787 old
= current_cred();
789 retval
= security_task_setgid(rgid
, egid
, sgid
, LSM_SETID_RES
);
794 if (!capable(CAP_SETGID
)) {
795 if (rgid
!= (gid_t
) -1 && rgid
!= old
->gid
&&
796 rgid
!= old
->egid
&& rgid
!= old
->sgid
)
798 if (egid
!= (gid_t
) -1 && egid
!= old
->gid
&&
799 egid
!= old
->egid
&& egid
!= old
->sgid
)
801 if (sgid
!= (gid_t
) -1 && sgid
!= old
->gid
&&
802 sgid
!= old
->egid
&& sgid
!= old
->sgid
)
806 if (rgid
!= (gid_t
) -1)
808 if (egid
!= (gid_t
) -1)
810 if (sgid
!= (gid_t
) -1)
812 new->fsgid
= new->egid
;
814 return commit_creds(new);
821 SYSCALL_DEFINE3(getresgid
, gid_t __user
*, rgid
, gid_t __user
*, egid
, gid_t __user
*, sgid
)
823 const struct cred
*cred
= current_cred();
826 if (!(retval
= put_user(cred
->gid
, rgid
)) &&
827 !(retval
= put_user(cred
->egid
, egid
)))
828 retval
= put_user(cred
->sgid
, sgid
);
835 * "setfsuid()" sets the fsuid - the uid used for filesystem checks. This
836 * is used for "access()" and for the NFS daemon (letting nfsd stay at
837 * whatever uid it wants to). It normally shadows "euid", except when
838 * explicitly set by setfsuid() or for access..
840 SYSCALL_DEFINE1(setfsuid
, uid_t
, uid
)
842 const struct cred
*old
;
846 new = prepare_creds();
848 return current_fsuid();
849 old
= current_cred();
850 old_fsuid
= old
->fsuid
;
852 if (security_task_setuid(uid
, (uid_t
)-1, (uid_t
)-1, LSM_SETID_FS
) < 0)
855 if (uid
== old
->uid
|| uid
== old
->euid
||
856 uid
== old
->suid
|| uid
== old
->fsuid
||
857 capable(CAP_SETUID
)) {
858 if (uid
!= old_fsuid
) {
860 if (security_task_fix_setuid(new, old
, LSM_SETID_FS
) == 0)
875 * Samma på svenska..
877 SYSCALL_DEFINE1(setfsgid
, gid_t
, gid
)
879 const struct cred
*old
;
883 new = prepare_creds();
885 return current_fsgid();
886 old
= current_cred();
887 old_fsgid
= old
->fsgid
;
889 if (security_task_setgid(gid
, (gid_t
)-1, (gid_t
)-1, LSM_SETID_FS
))
892 if (gid
== old
->gid
|| gid
== old
->egid
||
893 gid
== old
->sgid
|| gid
== old
->fsgid
||
894 capable(CAP_SETGID
)) {
895 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
);
964 /* From this point forward we keep holding onto the tasklist lock
965 * so that our parent does not change from under us. -DaveM
967 write_lock_irq(&tasklist_lock
);
970 p
= find_task_by_vpid(pid
);
975 if (!thread_group_leader(p
))
978 if (same_thread_group(p
->real_parent
, group_leader
)) {
980 if (task_session(p
) != task_session(group_leader
))
987 if (p
!= group_leader
)
992 if (p
->signal
->leader
)
997 struct task_struct
*g
;
999 pgrp
= find_vpid(pgid
);
1000 g
= pid_task(pgrp
, PIDTYPE_PGID
);
1001 if (!g
|| task_session(g
) != task_session(group_leader
))
1005 err
= security_task_setpgid(p
, pgid
);
1009 if (task_pgrp(p
) != pgrp
)
1010 change_pid(p
, PIDTYPE_PGID
, pgrp
);
1014 /* All paths lead to here, thus we are safe. -DaveM */
1015 write_unlock_irq(&tasklist_lock
);
1019 SYSCALL_DEFINE1(getpgid
, pid_t
, pid
)
1021 struct task_struct
*p
;
1027 grp
= task_pgrp(current
);
1030 p
= find_task_by_vpid(pid
);
1037 retval
= security_task_getpgid(p
);
1041 retval
= pid_vnr(grp
);
1047 #ifdef __ARCH_WANT_SYS_GETPGRP
1049 SYSCALL_DEFINE0(getpgrp
)
1051 return sys_getpgid(0);
1056 SYSCALL_DEFINE1(getsid
, pid_t
, pid
)
1058 struct task_struct
*p
;
1064 sid
= task_session(current
);
1067 p
= find_task_by_vpid(pid
);
1070 sid
= task_session(p
);
1074 retval
= security_task_getsid(p
);
1078 retval
= pid_vnr(sid
);
1084 SYSCALL_DEFINE0(setsid
)
1086 struct task_struct
*group_leader
= current
->group_leader
;
1087 struct pid
*sid
= task_pid(group_leader
);
1088 pid_t session
= pid_vnr(sid
);
1091 write_lock_irq(&tasklist_lock
);
1092 /* Fail if I am already a session leader */
1093 if (group_leader
->signal
->leader
)
1096 /* Fail if a process group id already exists that equals the
1097 * proposed session id.
1099 if (pid_task(sid
, PIDTYPE_PGID
))
1102 group_leader
->signal
->leader
= 1;
1103 __set_special_pids(sid
);
1105 proc_clear_tty(group_leader
);
1109 write_unlock_irq(&tasklist_lock
);
1111 proc_sid_connector(group_leader
);
1115 DECLARE_RWSEM(uts_sem
);
1117 SYSCALL_DEFINE1(newuname
, struct new_utsname __user
*, name
)
1121 down_read(&uts_sem
);
1122 if (copy_to_user(name
, utsname(), sizeof *name
))
1128 SYSCALL_DEFINE2(sethostname
, char __user
*, name
, int, len
)
1131 char tmp
[__NEW_UTS_LEN
];
1133 if (!capable(CAP_SYS_ADMIN
))
1135 if (len
< 0 || len
> __NEW_UTS_LEN
)
1137 down_write(&uts_sem
);
1139 if (!copy_from_user(tmp
, name
, len
)) {
1140 struct new_utsname
*u
= utsname();
1142 memcpy(u
->nodename
, tmp
, len
);
1143 memset(u
->nodename
+ len
, 0, sizeof(u
->nodename
) - len
);
1150 #ifdef __ARCH_WANT_SYS_GETHOSTNAME
1152 SYSCALL_DEFINE2(gethostname
, char __user
*, name
, int, len
)
1155 struct new_utsname
*u
;
1159 down_read(&uts_sem
);
1161 i
= 1 + strlen(u
->nodename
);
1165 if (copy_to_user(name
, u
->nodename
, i
))
1174 * Only setdomainname; getdomainname can be implemented by calling
1177 SYSCALL_DEFINE2(setdomainname
, char __user
*, name
, int, len
)
1180 char tmp
[__NEW_UTS_LEN
];
1182 if (!capable(CAP_SYS_ADMIN
))
1184 if (len
< 0 || len
> __NEW_UTS_LEN
)
1187 down_write(&uts_sem
);
1189 if (!copy_from_user(tmp
, name
, len
)) {
1190 struct new_utsname
*u
= utsname();
1192 memcpy(u
->domainname
, tmp
, len
);
1193 memset(u
->domainname
+ len
, 0, sizeof(u
->domainname
) - len
);
1200 SYSCALL_DEFINE2(getrlimit
, unsigned int, resource
, struct rlimit __user
*, rlim
)
1202 if (resource
>= RLIM_NLIMITS
)
1205 struct rlimit value
;
1206 task_lock(current
->group_leader
);
1207 value
= current
->signal
->rlim
[resource
];
1208 task_unlock(current
->group_leader
);
1209 return copy_to_user(rlim
, &value
, sizeof(*rlim
)) ? -EFAULT
: 0;
1213 #ifdef __ARCH_WANT_SYS_OLD_GETRLIMIT
1216 * Back compatibility for getrlimit. Needed for some apps.
1219 SYSCALL_DEFINE2(old_getrlimit
, unsigned int, resource
,
1220 struct rlimit __user
*, rlim
)
1223 if (resource
>= RLIM_NLIMITS
)
1226 task_lock(current
->group_leader
);
1227 x
= current
->signal
->rlim
[resource
];
1228 task_unlock(current
->group_leader
);
1229 if (x
.rlim_cur
> 0x7FFFFFFF)
1230 x
.rlim_cur
= 0x7FFFFFFF;
1231 if (x
.rlim_max
> 0x7FFFFFFF)
1232 x
.rlim_max
= 0x7FFFFFFF;
1233 return copy_to_user(rlim
, &x
, sizeof(x
))?-EFAULT
:0;
1238 SYSCALL_DEFINE2(setrlimit
, unsigned int, resource
, struct rlimit __user
*, rlim
)
1240 struct rlimit new_rlim
, *old_rlim
;
1243 if (resource
>= RLIM_NLIMITS
)
1245 if (copy_from_user(&new_rlim
, rlim
, sizeof(*rlim
)))
1247 if (new_rlim
.rlim_cur
> new_rlim
.rlim_max
)
1249 old_rlim
= current
->signal
->rlim
+ resource
;
1250 if ((new_rlim
.rlim_max
> old_rlim
->rlim_max
) &&
1251 !capable(CAP_SYS_RESOURCE
))
1253 if (resource
== RLIMIT_NOFILE
&& new_rlim
.rlim_max
> sysctl_nr_open
)
1256 retval
= security_task_setrlimit(resource
, &new_rlim
);
1260 if (resource
== RLIMIT_CPU
&& new_rlim
.rlim_cur
== 0) {
1262 * The caller is asking for an immediate RLIMIT_CPU
1263 * expiry. But we use the zero value to mean "it was
1264 * never set". So let's cheat and make it one second
1267 new_rlim
.rlim_cur
= 1;
1270 task_lock(current
->group_leader
);
1271 *old_rlim
= new_rlim
;
1272 task_unlock(current
->group_leader
);
1274 if (resource
!= RLIMIT_CPU
)
1278 * RLIMIT_CPU handling. Note that the kernel fails to return an error
1279 * code if it rejected the user's attempt to set RLIMIT_CPU. This is a
1280 * very long-standing error, and fixing it now risks breakage of
1281 * applications, so we live with it
1283 if (new_rlim
.rlim_cur
== RLIM_INFINITY
)
1286 update_rlimit_cpu(new_rlim
.rlim_cur
);
1292 * It would make sense to put struct rusage in the task_struct,
1293 * except that would make the task_struct be *really big*. After
1294 * task_struct gets moved into malloc'ed memory, it would
1295 * make sense to do this. It will make moving the rest of the information
1296 * a lot simpler! (Which we're not doing right now because we're not
1297 * measuring them yet).
1299 * When sampling multiple threads for RUSAGE_SELF, under SMP we might have
1300 * races with threads incrementing their own counters. But since word
1301 * reads are atomic, we either get new values or old values and we don't
1302 * care which for the sums. We always take the siglock to protect reading
1303 * the c* fields from p->signal from races with exit.c updating those
1304 * fields when reaping, so a sample either gets all the additions of a
1305 * given child after it's reaped, or none so this sample is before reaping.
1308 * We need to take the siglock for CHILDEREN, SELF and BOTH
1309 * for the cases current multithreaded, non-current single threaded
1310 * non-current multithreaded. Thread traversal is now safe with
1312 * Strictly speaking, we donot need to take the siglock if we are current and
1313 * single threaded, as no one else can take our signal_struct away, no one
1314 * else can reap the children to update signal->c* counters, and no one else
1315 * can race with the signal-> fields. If we do not take any lock, the
1316 * signal-> fields could be read out of order while another thread was just
1317 * exiting. So we should place a read memory barrier when we avoid the lock.
1318 * On the writer side, write memory barrier is implied in __exit_signal
1319 * as __exit_signal releases the siglock spinlock after updating the signal->
1320 * fields. But we don't do this yet to keep things simple.
1324 static void accumulate_thread_rusage(struct task_struct
*t
, struct rusage
*r
)
1326 r
->ru_nvcsw
+= t
->nvcsw
;
1327 r
->ru_nivcsw
+= t
->nivcsw
;
1328 r
->ru_minflt
+= t
->min_flt
;
1329 r
->ru_majflt
+= t
->maj_flt
;
1330 r
->ru_inblock
+= task_io_get_inblock(t
);
1331 r
->ru_oublock
+= task_io_get_oublock(t
);
1334 static void k_getrusage(struct task_struct
*p
, int who
, struct rusage
*r
)
1336 struct task_struct
*t
;
1337 unsigned long flags
;
1338 cputime_t tgutime
, tgstime
, utime
, stime
;
1339 unsigned long maxrss
= 0;
1341 memset((char *) r
, 0, sizeof *r
);
1342 utime
= stime
= cputime_zero
;
1344 if (who
== RUSAGE_THREAD
) {
1345 task_times(current
, &utime
, &stime
);
1346 accumulate_thread_rusage(p
, r
);
1347 maxrss
= p
->signal
->maxrss
;
1351 if (!lock_task_sighand(p
, &flags
))
1356 case RUSAGE_CHILDREN
:
1357 utime
= p
->signal
->cutime
;
1358 stime
= p
->signal
->cstime
;
1359 r
->ru_nvcsw
= p
->signal
->cnvcsw
;
1360 r
->ru_nivcsw
= p
->signal
->cnivcsw
;
1361 r
->ru_minflt
= p
->signal
->cmin_flt
;
1362 r
->ru_majflt
= p
->signal
->cmaj_flt
;
1363 r
->ru_inblock
= p
->signal
->cinblock
;
1364 r
->ru_oublock
= p
->signal
->coublock
;
1365 maxrss
= p
->signal
->cmaxrss
;
1367 if (who
== RUSAGE_CHILDREN
)
1371 thread_group_times(p
, &tgutime
, &tgstime
);
1372 utime
= cputime_add(utime
, tgutime
);
1373 stime
= cputime_add(stime
, tgstime
);
1374 r
->ru_nvcsw
+= p
->signal
->nvcsw
;
1375 r
->ru_nivcsw
+= p
->signal
->nivcsw
;
1376 r
->ru_minflt
+= p
->signal
->min_flt
;
1377 r
->ru_majflt
+= p
->signal
->maj_flt
;
1378 r
->ru_inblock
+= p
->signal
->inblock
;
1379 r
->ru_oublock
+= p
->signal
->oublock
;
1380 if (maxrss
< p
->signal
->maxrss
)
1381 maxrss
= p
->signal
->maxrss
;
1384 accumulate_thread_rusage(t
, r
);
1392 unlock_task_sighand(p
, &flags
);
1395 cputime_to_timeval(utime
, &r
->ru_utime
);
1396 cputime_to_timeval(stime
, &r
->ru_stime
);
1398 if (who
!= RUSAGE_CHILDREN
) {
1399 struct mm_struct
*mm
= get_task_mm(p
);
1401 setmax_mm_hiwater_rss(&maxrss
, mm
);
1405 r
->ru_maxrss
= maxrss
* (PAGE_SIZE
/ 1024); /* convert pages to KBs */
1408 int getrusage(struct task_struct
*p
, int who
, struct rusage __user
*ru
)
1411 k_getrusage(p
, who
, &r
);
1412 return copy_to_user(ru
, &r
, sizeof(r
)) ? -EFAULT
: 0;
1415 SYSCALL_DEFINE2(getrusage
, int, who
, struct rusage __user
*, ru
)
1417 if (who
!= RUSAGE_SELF
&& who
!= RUSAGE_CHILDREN
&&
1418 who
!= RUSAGE_THREAD
)
1420 return getrusage(current
, who
, ru
);
1423 SYSCALL_DEFINE1(umask
, int, mask
)
1425 mask
= xchg(¤t
->fs
->umask
, mask
& S_IRWXUGO
);
1429 SYSCALL_DEFINE5(prctl
, int, option
, unsigned long, arg2
, unsigned long, arg3
,
1430 unsigned long, arg4
, unsigned long, arg5
)
1432 struct task_struct
*me
= current
;
1433 unsigned char comm
[sizeof(me
->comm
)];
1436 error
= security_task_prctl(option
, arg2
, arg3
, arg4
, arg5
);
1437 if (error
!= -ENOSYS
)
1442 case PR_SET_PDEATHSIG
:
1443 if (!valid_signal(arg2
)) {
1447 me
->pdeath_signal
= arg2
;
1450 case PR_GET_PDEATHSIG
:
1451 error
= put_user(me
->pdeath_signal
, (int __user
*)arg2
);
1453 case PR_GET_DUMPABLE
:
1454 error
= get_dumpable(me
->mm
);
1456 case PR_SET_DUMPABLE
:
1457 if (arg2
< 0 || arg2
> 1) {
1461 set_dumpable(me
->mm
, arg2
);
1465 case PR_SET_UNALIGN
:
1466 error
= SET_UNALIGN_CTL(me
, arg2
);
1468 case PR_GET_UNALIGN
:
1469 error
= GET_UNALIGN_CTL(me
, arg2
);
1472 error
= SET_FPEMU_CTL(me
, arg2
);
1475 error
= GET_FPEMU_CTL(me
, arg2
);
1478 error
= SET_FPEXC_CTL(me
, arg2
);
1481 error
= GET_FPEXC_CTL(me
, arg2
);
1484 error
= PR_TIMING_STATISTICAL
;
1487 if (arg2
!= PR_TIMING_STATISTICAL
)
1494 comm
[sizeof(me
->comm
)-1] = 0;
1495 if (strncpy_from_user(comm
, (char __user
*)arg2
,
1496 sizeof(me
->comm
) - 1) < 0)
1498 set_task_comm(me
, comm
);
1501 get_task_comm(comm
, me
);
1502 if (copy_to_user((char __user
*)arg2
, comm
,
1507 error
= GET_ENDIAN(me
, arg2
);
1510 error
= SET_ENDIAN(me
, arg2
);
1513 case PR_GET_SECCOMP
:
1514 error
= prctl_get_seccomp();
1516 case PR_SET_SECCOMP
:
1517 error
= prctl_set_seccomp(arg2
);
1520 error
= GET_TSC_CTL(arg2
);
1523 error
= SET_TSC_CTL(arg2
);
1525 case PR_TASK_PERF_EVENTS_DISABLE
:
1526 error
= perf_event_task_disable();
1528 case PR_TASK_PERF_EVENTS_ENABLE
:
1529 error
= perf_event_task_enable();
1531 case PR_GET_TIMERSLACK
:
1532 error
= current
->timer_slack_ns
;
1534 case PR_SET_TIMERSLACK
:
1536 current
->timer_slack_ns
=
1537 current
->default_timer_slack_ns
;
1539 current
->timer_slack_ns
= arg2
;
1546 case PR_MCE_KILL_CLEAR
:
1549 current
->flags
&= ~PF_MCE_PROCESS
;
1551 case PR_MCE_KILL_SET
:
1552 current
->flags
|= PF_MCE_PROCESS
;
1553 if (arg3
== PR_MCE_KILL_EARLY
)
1554 current
->flags
|= PF_MCE_EARLY
;
1555 else if (arg3
== PR_MCE_KILL_LATE
)
1556 current
->flags
&= ~PF_MCE_EARLY
;
1557 else if (arg3
== PR_MCE_KILL_DEFAULT
)
1559 ~(PF_MCE_EARLY
|PF_MCE_PROCESS
);
1568 case PR_MCE_KILL_GET
:
1569 if (arg2
| arg3
| arg4
| arg5
)
1571 if (current
->flags
& PF_MCE_PROCESS
)
1572 error
= (current
->flags
& PF_MCE_EARLY
) ?
1573 PR_MCE_KILL_EARLY
: PR_MCE_KILL_LATE
;
1575 error
= PR_MCE_KILL_DEFAULT
;
1584 SYSCALL_DEFINE3(getcpu
, unsigned __user
*, cpup
, unsigned __user
*, nodep
,
1585 struct getcpu_cache __user
*, unused
)
1588 int cpu
= raw_smp_processor_id();
1590 err
|= put_user(cpu
, cpup
);
1592 err
|= put_user(cpu_to_node(cpu
), nodep
);
1593 return err
? -EFAULT
: 0;
1596 char poweroff_cmd
[POWEROFF_CMD_PATH_LEN
] = "/sbin/poweroff";
1598 static void argv_cleanup(char **argv
, char **envp
)
1604 * orderly_poweroff - Trigger an orderly system poweroff
1605 * @force: force poweroff if command execution fails
1607 * This may be called from any context to trigger a system shutdown.
1608 * If the orderly shutdown fails, it will force an immediate shutdown.
1610 int orderly_poweroff(bool force
)
1613 char **argv
= argv_split(GFP_ATOMIC
, poweroff_cmd
, &argc
);
1614 static char *envp
[] = {
1616 "PATH=/sbin:/bin:/usr/sbin:/usr/bin",
1620 struct subprocess_info
*info
;
1623 printk(KERN_WARNING
"%s failed to allocate memory for \"%s\"\n",
1624 __func__
, poweroff_cmd
);
1628 info
= call_usermodehelper_setup(argv
[0], argv
, envp
, GFP_ATOMIC
);
1634 call_usermodehelper_setcleanup(info
, argv_cleanup
);
1636 ret
= call_usermodehelper_exec(info
, UMH_NO_WAIT
);
1640 printk(KERN_WARNING
"Failed to start orderly shutdown: "
1641 "forcing the issue\n");
1643 /* I guess this should try to kick off some daemon to
1644 sync and poweroff asap. Or not even bother syncing
1645 if we're doing an emergency shutdown? */
1652 EXPORT_SYMBOL_GPL(orderly_poweroff
);