4 * Copyright (C) 1991, 1992 Linus Torvalds
7 #include <linux/config.h>
8 #include <linux/module.h>
10 #include <linux/utsname.h>
11 #include <linux/mman.h>
12 #include <linux/smp_lock.h>
13 #include <linux/notifier.h>
14 #include <linux/reboot.h>
15 #include <linux/prctl.h>
16 #include <linux/init.h>
17 #include <linux/highuid.h>
19 #include <linux/kernel.h>
20 #include <linux/kexec.h>
21 #include <linux/workqueue.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>
32 #include <linux/compat.h>
33 #include <linux/syscalls.h>
35 #include <asm/uaccess.h>
37 #include <asm/unistd.h>
39 #ifndef SET_UNALIGN_CTL
40 # define SET_UNALIGN_CTL(a,b) (-EINVAL)
42 #ifndef GET_UNALIGN_CTL
43 # define GET_UNALIGN_CTL(a,b) (-EINVAL)
46 # define SET_FPEMU_CTL(a,b) (-EINVAL)
49 # define GET_FPEMU_CTL(a,b) (-EINVAL)
52 # define SET_FPEXC_CTL(a,b) (-EINVAL)
55 # define GET_FPEXC_CTL(a,b) (-EINVAL)
59 * this is where the system-wide overflow UID and GID are defined, for
60 * architectures that now have 32-bit UID/GID but didn't in the past
63 int overflowuid
= DEFAULT_OVERFLOWUID
;
64 int overflowgid
= DEFAULT_OVERFLOWGID
;
67 EXPORT_SYMBOL(overflowuid
);
68 EXPORT_SYMBOL(overflowgid
);
72 * the same as above, but for filesystems which can only store a 16-bit
73 * UID and GID. as such, this is needed on all architectures
76 int fs_overflowuid
= DEFAULT_FS_OVERFLOWUID
;
77 int fs_overflowgid
= DEFAULT_FS_OVERFLOWUID
;
79 EXPORT_SYMBOL(fs_overflowuid
);
80 EXPORT_SYMBOL(fs_overflowgid
);
83 * this indicates whether you can reboot with ctrl-alt-del: the default is yes
90 * Notifier list for kernel code which wants to be called
91 * at shutdown. This is used to stop any idling DMA operations
95 static struct notifier_block
*reboot_notifier_list
;
96 static DEFINE_RWLOCK(notifier_lock
);
99 * notifier_chain_register - Add notifier to a notifier chain
100 * @list: Pointer to root list pointer
101 * @n: New entry in notifier chain
103 * Adds a notifier to a notifier chain.
105 * Currently always returns zero.
108 int notifier_chain_register(struct notifier_block
**list
, struct notifier_block
*n
)
110 write_lock(¬ifier_lock
);
113 if(n
->priority
> (*list
)->priority
)
115 list
= &((*list
)->next
);
119 write_unlock(¬ifier_lock
);
123 EXPORT_SYMBOL(notifier_chain_register
);
126 * notifier_chain_unregister - Remove notifier from a notifier chain
127 * @nl: Pointer to root list pointer
128 * @n: New entry in notifier chain
130 * Removes a notifier from a notifier chain.
132 * Returns zero on success, or %-ENOENT on failure.
135 int notifier_chain_unregister(struct notifier_block
**nl
, struct notifier_block
*n
)
137 write_lock(¬ifier_lock
);
143 write_unlock(¬ifier_lock
);
148 write_unlock(¬ifier_lock
);
152 EXPORT_SYMBOL(notifier_chain_unregister
);
155 * notifier_call_chain - Call functions in a notifier chain
156 * @n: Pointer to root pointer of notifier chain
157 * @val: Value passed unmodified to notifier function
158 * @v: Pointer passed unmodified to notifier function
160 * Calls each function in a notifier chain in turn.
162 * If the return value of the notifier can be and'd
163 * with %NOTIFY_STOP_MASK, then notifier_call_chain
164 * will return immediately, with the return value of
165 * the notifier function which halted execution.
166 * Otherwise, the return value is the return value
167 * of the last notifier function called.
170 int notifier_call_chain(struct notifier_block
**n
, unsigned long val
, void *v
)
173 struct notifier_block
*nb
= *n
;
177 ret
=nb
->notifier_call(nb
,val
,v
);
178 if(ret
&NOTIFY_STOP_MASK
)
187 EXPORT_SYMBOL(notifier_call_chain
);
190 * register_reboot_notifier - Register function to be called at reboot time
191 * @nb: Info about notifier function to be called
193 * Registers a function with the list of functions
194 * to be called at reboot time.
196 * Currently always returns zero, as notifier_chain_register
197 * always returns zero.
200 int register_reboot_notifier(struct notifier_block
* nb
)
202 return notifier_chain_register(&reboot_notifier_list
, nb
);
205 EXPORT_SYMBOL(register_reboot_notifier
);
208 * unregister_reboot_notifier - Unregister previously registered reboot notifier
209 * @nb: Hook to be unregistered
211 * Unregisters a previously registered reboot
214 * Returns zero on success, or %-ENOENT on failure.
217 int unregister_reboot_notifier(struct notifier_block
* nb
)
219 return notifier_chain_unregister(&reboot_notifier_list
, nb
);
222 EXPORT_SYMBOL(unregister_reboot_notifier
);
224 static int set_one_prio(struct task_struct
*p
, int niceval
, int error
)
228 if (p
->uid
!= current
->euid
&&
229 p
->euid
!= current
->euid
&& !capable(CAP_SYS_NICE
)) {
233 if (niceval
< task_nice(p
) && !can_nice(p
, niceval
)) {
237 no_nice
= security_task_setnice(p
, niceval
);
244 set_user_nice(p
, niceval
);
249 asmlinkage
long sys_setpriority(int which
, int who
, int niceval
)
251 struct task_struct
*g
, *p
;
252 struct user_struct
*user
;
255 if (which
> 2 || which
< 0)
258 /* normalize: avoid signed division (rounding problems) */
265 read_lock(&tasklist_lock
);
270 p
= find_task_by_pid(who
);
272 error
= set_one_prio(p
, niceval
, error
);
276 who
= process_group(current
);
277 do_each_task_pid(who
, PIDTYPE_PGID
, p
) {
278 error
= set_one_prio(p
, niceval
, error
);
279 } while_each_task_pid(who
, PIDTYPE_PGID
, p
);
282 user
= current
->user
;
286 if ((who
!= current
->uid
) && !(user
= find_user(who
)))
287 goto out_unlock
; /* No processes for this user */
291 error
= set_one_prio(p
, niceval
, error
);
292 while_each_thread(g
, p
);
293 if (who
!= current
->uid
)
294 free_uid(user
); /* For find_user() */
298 read_unlock(&tasklist_lock
);
304 * Ugh. To avoid negative return values, "getpriority()" will
305 * not return the normal nice-value, but a negated value that
306 * has been offset by 20 (ie it returns 40..1 instead of -20..19)
307 * to stay compatible.
309 asmlinkage
long sys_getpriority(int which
, int who
)
311 struct task_struct
*g
, *p
;
312 struct user_struct
*user
;
313 long niceval
, retval
= -ESRCH
;
315 if (which
> 2 || which
< 0)
318 read_lock(&tasklist_lock
);
323 p
= find_task_by_pid(who
);
325 niceval
= 20 - task_nice(p
);
326 if (niceval
> retval
)
332 who
= process_group(current
);
333 do_each_task_pid(who
, PIDTYPE_PGID
, p
) {
334 niceval
= 20 - task_nice(p
);
335 if (niceval
> retval
)
337 } while_each_task_pid(who
, PIDTYPE_PGID
, p
);
340 user
= current
->user
;
344 if ((who
!= current
->uid
) && !(user
= find_user(who
)))
345 goto out_unlock
; /* No processes for this user */
349 niceval
= 20 - task_nice(p
);
350 if (niceval
> retval
)
353 while_each_thread(g
, p
);
354 if (who
!= current
->uid
)
355 free_uid(user
); /* for find_user() */
359 read_unlock(&tasklist_lock
);
364 void kernel_restart(char *cmd
)
366 notifier_call_chain(&reboot_notifier_list
, SYS_RESTART
, cmd
);
367 system_state
= SYSTEM_RESTART
;
368 device_suspend(PMSG_FREEZE
);
371 printk(KERN_EMERG
"Restarting system.\n");
373 printk(KERN_EMERG
"Restarting system with command '%s'.\n", cmd
);
376 machine_restart(cmd
);
378 EXPORT_SYMBOL_GPL(kernel_restart
);
380 void kernel_kexec(void)
383 struct kimage
*image
;
384 image
= xchg(&kexec_image
, 0);
388 notifier_call_chain(&reboot_notifier_list
, SYS_RESTART
, NULL
);
389 system_state
= SYSTEM_RESTART
;
390 device_suspend(PMSG_FREEZE
);
392 printk(KERN_EMERG
"Starting new kernel\n");
394 machine_kexec(image
);
397 EXPORT_SYMBOL_GPL(kernel_kexec
);
399 void kernel_halt(void)
401 notifier_call_chain(&reboot_notifier_list
, SYS_HALT
, NULL
);
402 system_state
= SYSTEM_HALT
;
403 device_suspend(PMSG_SUSPEND
);
405 printk(KERN_EMERG
"System halted.\n");
408 EXPORT_SYMBOL_GPL(kernel_halt
);
410 void kernel_power_off(void)
412 notifier_call_chain(&reboot_notifier_list
, SYS_POWER_OFF
, NULL
);
413 system_state
= SYSTEM_POWER_OFF
;
414 device_suspend(PMSG_SUSPEND
);
416 printk(KERN_EMERG
"Power down.\n");
419 EXPORT_SYMBOL_GPL(kernel_power_off
);
422 * Reboot system call: for obvious reasons only root may call it,
423 * and even root needs to set up some magic numbers in the registers
424 * so that some mistake won't make this reboot the whole machine.
425 * You can also set the meaning of the ctrl-alt-del-key here.
427 * reboot doesn't sync: do that yourself before calling this.
429 asmlinkage
long sys_reboot(int magic1
, int magic2
, unsigned int cmd
, void __user
* arg
)
433 /* We only trust the superuser with rebooting the system. */
434 if (!capable(CAP_SYS_BOOT
))
437 /* For safety, we require "magic" arguments. */
438 if (magic1
!= LINUX_REBOOT_MAGIC1
||
439 (magic2
!= LINUX_REBOOT_MAGIC2
&&
440 magic2
!= LINUX_REBOOT_MAGIC2A
&&
441 magic2
!= LINUX_REBOOT_MAGIC2B
&&
442 magic2
!= LINUX_REBOOT_MAGIC2C
))
447 case LINUX_REBOOT_CMD_RESTART
:
448 kernel_restart(NULL
);
451 case LINUX_REBOOT_CMD_CAD_ON
:
455 case LINUX_REBOOT_CMD_CAD_OFF
:
459 case LINUX_REBOOT_CMD_HALT
:
465 case LINUX_REBOOT_CMD_POWER_OFF
:
471 case LINUX_REBOOT_CMD_RESTART2
:
472 if (strncpy_from_user(&buffer
[0], arg
, sizeof(buffer
) - 1) < 0) {
476 buffer
[sizeof(buffer
) - 1] = '\0';
478 kernel_restart(buffer
);
481 case LINUX_REBOOT_CMD_KEXEC
:
486 #ifdef CONFIG_SOFTWARE_SUSPEND
487 case LINUX_REBOOT_CMD_SW_SUSPEND
:
489 int ret
= software_suspend();
503 static void deferred_cad(void *dummy
)
505 notifier_call_chain(&reboot_notifier_list
, SYS_RESTART
, NULL
);
506 machine_restart(NULL
);
510 * This function gets called by ctrl-alt-del - ie the keyboard interrupt.
511 * As it's called within an interrupt, it may NOT sync: the only choice
512 * is whether to reboot at once, or just ignore the ctrl-alt-del.
514 void ctrl_alt_del(void)
516 static DECLARE_WORK(cad_work
, deferred_cad
, NULL
);
519 schedule_work(&cad_work
);
521 kill_proc(cad_pid
, SIGINT
, 1);
526 * Unprivileged users may change the real gid to the effective gid
527 * or vice versa. (BSD-style)
529 * If you set the real gid at all, or set the effective gid to a value not
530 * equal to the real gid, then the saved gid is set to the new effective gid.
532 * This makes it possible for a setgid program to completely drop its
533 * privileges, which is often a useful assertion to make when you are doing
534 * a security audit over a program.
536 * The general idea is that a program which uses just setregid() will be
537 * 100% compatible with BSD. A program which uses just setgid() will be
538 * 100% compatible with POSIX with saved IDs.
540 * SMP: There are not races, the GIDs are checked only by filesystem
541 * operations (as far as semantic preservation is concerned).
543 asmlinkage
long sys_setregid(gid_t rgid
, gid_t egid
)
545 int old_rgid
= current
->gid
;
546 int old_egid
= current
->egid
;
547 int new_rgid
= old_rgid
;
548 int new_egid
= old_egid
;
551 retval
= security_task_setgid(rgid
, egid
, (gid_t
)-1, LSM_SETID_RE
);
555 if (rgid
!= (gid_t
) -1) {
556 if ((old_rgid
== rgid
) ||
557 (current
->egid
==rgid
) ||
563 if (egid
!= (gid_t
) -1) {
564 if ((old_rgid
== egid
) ||
565 (current
->egid
== egid
) ||
566 (current
->sgid
== egid
) ||
573 if (new_egid
!= old_egid
)
575 current
->mm
->dumpable
= suid_dumpable
;
578 if (rgid
!= (gid_t
) -1 ||
579 (egid
!= (gid_t
) -1 && egid
!= old_rgid
))
580 current
->sgid
= new_egid
;
581 current
->fsgid
= new_egid
;
582 current
->egid
= new_egid
;
583 current
->gid
= new_rgid
;
584 key_fsgid_changed(current
);
589 * setgid() is implemented like SysV w/ SAVED_IDS
591 * SMP: Same implicit races as above.
593 asmlinkage
long sys_setgid(gid_t gid
)
595 int old_egid
= current
->egid
;
598 retval
= security_task_setgid(gid
, (gid_t
)-1, (gid_t
)-1, LSM_SETID_ID
);
602 if (capable(CAP_SETGID
))
606 current
->mm
->dumpable
= suid_dumpable
;
609 current
->gid
= current
->egid
= current
->sgid
= current
->fsgid
= gid
;
611 else if ((gid
== current
->gid
) || (gid
== current
->sgid
))
615 current
->mm
->dumpable
= suid_dumpable
;
618 current
->egid
= current
->fsgid
= gid
;
623 key_fsgid_changed(current
);
627 static int set_user(uid_t new_ruid
, int dumpclear
)
629 struct user_struct
*new_user
;
631 new_user
= alloc_uid(new_ruid
);
635 if (atomic_read(&new_user
->processes
) >=
636 current
->signal
->rlim
[RLIMIT_NPROC
].rlim_cur
&&
637 new_user
!= &root_user
) {
642 switch_uid(new_user
);
646 current
->mm
->dumpable
= suid_dumpable
;
649 current
->uid
= new_ruid
;
654 * Unprivileged users may change the real uid to the effective uid
655 * or vice versa. (BSD-style)
657 * If you set the real uid at all, or set the effective uid to a value not
658 * equal to the real uid, then the saved uid is set to the new effective uid.
660 * This makes it possible for a setuid program to completely drop its
661 * privileges, which is often a useful assertion to make when you are doing
662 * a security audit over a program.
664 * The general idea is that a program which uses just setreuid() will be
665 * 100% compatible with BSD. A program which uses just setuid() will be
666 * 100% compatible with POSIX with saved IDs.
668 asmlinkage
long sys_setreuid(uid_t ruid
, uid_t euid
)
670 int old_ruid
, old_euid
, old_suid
, new_ruid
, new_euid
;
673 retval
= security_task_setuid(ruid
, euid
, (uid_t
)-1, LSM_SETID_RE
);
677 new_ruid
= old_ruid
= current
->uid
;
678 new_euid
= old_euid
= current
->euid
;
679 old_suid
= current
->suid
;
681 if (ruid
!= (uid_t
) -1) {
683 if ((old_ruid
!= ruid
) &&
684 (current
->euid
!= ruid
) &&
685 !capable(CAP_SETUID
))
689 if (euid
!= (uid_t
) -1) {
691 if ((old_ruid
!= euid
) &&
692 (current
->euid
!= euid
) &&
693 (current
->suid
!= euid
) &&
694 !capable(CAP_SETUID
))
698 if (new_ruid
!= old_ruid
&& set_user(new_ruid
, new_euid
!= old_euid
) < 0)
701 if (new_euid
!= old_euid
)
703 current
->mm
->dumpable
= suid_dumpable
;
706 current
->fsuid
= current
->euid
= new_euid
;
707 if (ruid
!= (uid_t
) -1 ||
708 (euid
!= (uid_t
) -1 && euid
!= old_ruid
))
709 current
->suid
= current
->euid
;
710 current
->fsuid
= current
->euid
;
712 key_fsuid_changed(current
);
714 return security_task_post_setuid(old_ruid
, old_euid
, old_suid
, LSM_SETID_RE
);
720 * setuid() is implemented like SysV with SAVED_IDS
722 * Note that SAVED_ID's is deficient in that a setuid root program
723 * like sendmail, for example, cannot set its uid to be a normal
724 * user and then switch back, because if you're root, setuid() sets
725 * the saved uid too. If you don't like this, blame the bright people
726 * in the POSIX committee and/or USG. Note that the BSD-style setreuid()
727 * will allow a root program to temporarily drop privileges and be able to
728 * regain them by swapping the real and effective uid.
730 asmlinkage
long sys_setuid(uid_t uid
)
732 int old_euid
= current
->euid
;
733 int old_ruid
, old_suid
, new_ruid
, new_suid
;
736 retval
= security_task_setuid(uid
, (uid_t
)-1, (uid_t
)-1, LSM_SETID_ID
);
740 old_ruid
= new_ruid
= current
->uid
;
741 old_suid
= current
->suid
;
744 if (capable(CAP_SETUID
)) {
745 if (uid
!= old_ruid
&& set_user(uid
, old_euid
!= uid
) < 0)
748 } else if ((uid
!= current
->uid
) && (uid
!= new_suid
))
753 current
->mm
->dumpable
= suid_dumpable
;
756 current
->fsuid
= current
->euid
= uid
;
757 current
->suid
= new_suid
;
759 key_fsuid_changed(current
);
761 return security_task_post_setuid(old_ruid
, old_euid
, old_suid
, LSM_SETID_ID
);
766 * This function implements a generic ability to update ruid, euid,
767 * and suid. This allows you to implement the 4.4 compatible seteuid().
769 asmlinkage
long sys_setresuid(uid_t ruid
, uid_t euid
, uid_t suid
)
771 int old_ruid
= current
->uid
;
772 int old_euid
= current
->euid
;
773 int old_suid
= current
->suid
;
776 retval
= security_task_setuid(ruid
, euid
, suid
, LSM_SETID_RES
);
780 if (!capable(CAP_SETUID
)) {
781 if ((ruid
!= (uid_t
) -1) && (ruid
!= current
->uid
) &&
782 (ruid
!= current
->euid
) && (ruid
!= current
->suid
))
784 if ((euid
!= (uid_t
) -1) && (euid
!= current
->uid
) &&
785 (euid
!= current
->euid
) && (euid
!= current
->suid
))
787 if ((suid
!= (uid_t
) -1) && (suid
!= current
->uid
) &&
788 (suid
!= current
->euid
) && (suid
!= current
->suid
))
791 if (ruid
!= (uid_t
) -1) {
792 if (ruid
!= current
->uid
&& set_user(ruid
, euid
!= current
->euid
) < 0)
795 if (euid
!= (uid_t
) -1) {
796 if (euid
!= current
->euid
)
798 current
->mm
->dumpable
= suid_dumpable
;
801 current
->euid
= euid
;
803 current
->fsuid
= current
->euid
;
804 if (suid
!= (uid_t
) -1)
805 current
->suid
= suid
;
807 key_fsuid_changed(current
);
809 return security_task_post_setuid(old_ruid
, old_euid
, old_suid
, LSM_SETID_RES
);
812 asmlinkage
long sys_getresuid(uid_t __user
*ruid
, uid_t __user
*euid
, uid_t __user
*suid
)
816 if (!(retval
= put_user(current
->uid
, ruid
)) &&
817 !(retval
= put_user(current
->euid
, euid
)))
818 retval
= put_user(current
->suid
, suid
);
824 * Same as above, but for rgid, egid, sgid.
826 asmlinkage
long sys_setresgid(gid_t rgid
, gid_t egid
, gid_t sgid
)
830 retval
= security_task_setgid(rgid
, egid
, sgid
, LSM_SETID_RES
);
834 if (!capable(CAP_SETGID
)) {
835 if ((rgid
!= (gid_t
) -1) && (rgid
!= current
->gid
) &&
836 (rgid
!= current
->egid
) && (rgid
!= current
->sgid
))
838 if ((egid
!= (gid_t
) -1) && (egid
!= current
->gid
) &&
839 (egid
!= current
->egid
) && (egid
!= current
->sgid
))
841 if ((sgid
!= (gid_t
) -1) && (sgid
!= current
->gid
) &&
842 (sgid
!= current
->egid
) && (sgid
!= current
->sgid
))
845 if (egid
!= (gid_t
) -1) {
846 if (egid
!= current
->egid
)
848 current
->mm
->dumpable
= suid_dumpable
;
851 current
->egid
= egid
;
853 current
->fsgid
= current
->egid
;
854 if (rgid
!= (gid_t
) -1)
856 if (sgid
!= (gid_t
) -1)
857 current
->sgid
= sgid
;
859 key_fsgid_changed(current
);
863 asmlinkage
long sys_getresgid(gid_t __user
*rgid
, gid_t __user
*egid
, gid_t __user
*sgid
)
867 if (!(retval
= put_user(current
->gid
, rgid
)) &&
868 !(retval
= put_user(current
->egid
, egid
)))
869 retval
= put_user(current
->sgid
, sgid
);
876 * "setfsuid()" sets the fsuid - the uid used for filesystem checks. This
877 * is used for "access()" and for the NFS daemon (letting nfsd stay at
878 * whatever uid it wants to). It normally shadows "euid", except when
879 * explicitly set by setfsuid() or for access..
881 asmlinkage
long sys_setfsuid(uid_t uid
)
885 old_fsuid
= current
->fsuid
;
886 if (security_task_setuid(uid
, (uid_t
)-1, (uid_t
)-1, LSM_SETID_FS
))
889 if (uid
== current
->uid
|| uid
== current
->euid
||
890 uid
== current
->suid
|| uid
== current
->fsuid
||
893 if (uid
!= old_fsuid
)
895 current
->mm
->dumpable
= suid_dumpable
;
898 current
->fsuid
= uid
;
901 key_fsuid_changed(current
);
903 security_task_post_setuid(old_fsuid
, (uid_t
)-1, (uid_t
)-1, LSM_SETID_FS
);
909 * Samma på svenska..
911 asmlinkage
long sys_setfsgid(gid_t gid
)
915 old_fsgid
= current
->fsgid
;
916 if (security_task_setgid(gid
, (gid_t
)-1, (gid_t
)-1, LSM_SETID_FS
))
919 if (gid
== current
->gid
|| gid
== current
->egid
||
920 gid
== current
->sgid
|| gid
== current
->fsgid
||
923 if (gid
!= old_fsgid
)
925 current
->mm
->dumpable
= suid_dumpable
;
928 current
->fsgid
= gid
;
929 key_fsgid_changed(current
);
934 asmlinkage
long sys_times(struct tms __user
* tbuf
)
937 * In the SMP world we might just be unlucky and have one of
938 * the times increment as we use it. Since the value is an
939 * atomically safe type this is just fine. Conceptually its
940 * as if the syscall took an instant longer to occur.
944 cputime_t utime
, stime
, cutime
, cstime
;
947 if (thread_group_empty(current
)) {
949 * Single thread case without the use of any locks.
951 * We may race with release_task if two threads are
952 * executing. However, release task first adds up the
953 * counters (__exit_signal) before removing the task
954 * from the process tasklist (__unhash_process).
955 * __exit_signal also acquires and releases the
956 * siglock which results in the proper memory ordering
957 * so that the list modifications are always visible
958 * after the counters have been updated.
960 * If the counters have been updated by the second thread
961 * but the thread has not yet been removed from the list
962 * then the other branch will be executing which will
963 * block on tasklist_lock until the exit handling of the
964 * other task is finished.
966 * This also implies that the sighand->siglock cannot
967 * be held by another processor. So we can also
968 * skip acquiring that lock.
970 utime
= cputime_add(current
->signal
->utime
, current
->utime
);
971 stime
= cputime_add(current
->signal
->utime
, current
->stime
);
972 cutime
= current
->signal
->cutime
;
973 cstime
= current
->signal
->cstime
;
978 /* Process with multiple threads */
979 struct task_struct
*tsk
= current
;
980 struct task_struct
*t
;
982 read_lock(&tasklist_lock
);
983 utime
= tsk
->signal
->utime
;
984 stime
= tsk
->signal
->stime
;
987 utime
= cputime_add(utime
, t
->utime
);
988 stime
= cputime_add(stime
, t
->stime
);
993 * While we have tasklist_lock read-locked, no dying thread
994 * can be updating current->signal->[us]time. Instead,
995 * we got their counts included in the live thread loop.
996 * However, another thread can come in right now and
997 * do a wait call that updates current->signal->c[us]time.
998 * To make sure we always see that pair updated atomically,
999 * we take the siglock around fetching them.
1001 spin_lock_irq(&tsk
->sighand
->siglock
);
1002 cutime
= tsk
->signal
->cutime
;
1003 cstime
= tsk
->signal
->cstime
;
1004 spin_unlock_irq(&tsk
->sighand
->siglock
);
1005 read_unlock(&tasklist_lock
);
1007 tmp
.tms_utime
= cputime_to_clock_t(utime
);
1008 tmp
.tms_stime
= cputime_to_clock_t(stime
);
1009 tmp
.tms_cutime
= cputime_to_clock_t(cutime
);
1010 tmp
.tms_cstime
= cputime_to_clock_t(cstime
);
1011 if (copy_to_user(tbuf
, &tmp
, sizeof(struct tms
)))
1014 return (long) jiffies_64_to_clock_t(get_jiffies_64());
1018 * This needs some heavy checking ...
1019 * I just haven't the stomach for it. I also don't fully
1020 * understand sessions/pgrp etc. Let somebody who does explain it.
1022 * OK, I think I have the protection semantics right.... this is really
1023 * only important on a multi-user system anyway, to make sure one user
1024 * can't send a signal to a process owned by another. -TYT, 12/12/91
1026 * Auch. Had to add the 'did_exec' flag to conform completely to POSIX.
1030 asmlinkage
long sys_setpgid(pid_t pid
, pid_t pgid
)
1032 struct task_struct
*p
;
1042 /* From this point forward we keep holding onto the tasklist lock
1043 * so that our parent does not change from under us. -DaveM
1045 write_lock_irq(&tasklist_lock
);
1048 p
= find_task_by_pid(pid
);
1053 if (!thread_group_leader(p
))
1056 if (p
->parent
== current
|| p
->real_parent
== current
) {
1058 if (p
->signal
->session
!= current
->signal
->session
)
1070 if (p
->signal
->leader
)
1074 struct task_struct
*p
;
1076 do_each_task_pid(pgid
, PIDTYPE_PGID
, p
) {
1077 if (p
->signal
->session
== current
->signal
->session
)
1079 } while_each_task_pid(pgid
, PIDTYPE_PGID
, p
);
1084 err
= security_task_setpgid(p
, pgid
);
1088 if (process_group(p
) != pgid
) {
1089 detach_pid(p
, PIDTYPE_PGID
);
1090 p
->signal
->pgrp
= pgid
;
1091 attach_pid(p
, PIDTYPE_PGID
, pgid
);
1096 /* All paths lead to here, thus we are safe. -DaveM */
1097 write_unlock_irq(&tasklist_lock
);
1101 asmlinkage
long sys_getpgid(pid_t pid
)
1104 return process_group(current
);
1107 struct task_struct
*p
;
1109 read_lock(&tasklist_lock
);
1110 p
= find_task_by_pid(pid
);
1114 retval
= security_task_getpgid(p
);
1116 retval
= process_group(p
);
1118 read_unlock(&tasklist_lock
);
1123 #ifdef __ARCH_WANT_SYS_GETPGRP
1125 asmlinkage
long sys_getpgrp(void)
1127 /* SMP - assuming writes are word atomic this is fine */
1128 return process_group(current
);
1133 asmlinkage
long sys_getsid(pid_t pid
)
1136 return current
->signal
->session
;
1139 struct task_struct
*p
;
1141 read_lock(&tasklist_lock
);
1142 p
= find_task_by_pid(pid
);
1146 retval
= security_task_getsid(p
);
1148 retval
= p
->signal
->session
;
1150 read_unlock(&tasklist_lock
);
1155 asmlinkage
long sys_setsid(void)
1160 if (!thread_group_leader(current
))
1164 write_lock_irq(&tasklist_lock
);
1166 pid
= find_pid(PIDTYPE_PGID
, current
->pid
);
1170 current
->signal
->leader
= 1;
1171 __set_special_pids(current
->pid
, current
->pid
);
1172 current
->signal
->tty
= NULL
;
1173 current
->signal
->tty_old_pgrp
= 0;
1174 err
= process_group(current
);
1176 write_unlock_irq(&tasklist_lock
);
1182 * Supplementary group IDs
1185 /* init to 2 - one for init_task, one to ensure it is never freed */
1186 struct group_info init_groups
= { .usage
= ATOMIC_INIT(2) };
1188 struct group_info
*groups_alloc(int gidsetsize
)
1190 struct group_info
*group_info
;
1194 nblocks
= (gidsetsize
+ NGROUPS_PER_BLOCK
- 1) / NGROUPS_PER_BLOCK
;
1195 /* Make sure we always allocate at least one indirect block pointer */
1196 nblocks
= nblocks
? : 1;
1197 group_info
= kmalloc(sizeof(*group_info
) + nblocks
*sizeof(gid_t
*), GFP_USER
);
1200 group_info
->ngroups
= gidsetsize
;
1201 group_info
->nblocks
= nblocks
;
1202 atomic_set(&group_info
->usage
, 1);
1204 if (gidsetsize
<= NGROUPS_SMALL
) {
1205 group_info
->blocks
[0] = group_info
->small_block
;
1207 for (i
= 0; i
< nblocks
; i
++) {
1209 b
= (void *)__get_free_page(GFP_USER
);
1211 goto out_undo_partial_alloc
;
1212 group_info
->blocks
[i
] = b
;
1217 out_undo_partial_alloc
:
1219 free_page((unsigned long)group_info
->blocks
[i
]);
1225 EXPORT_SYMBOL(groups_alloc
);
1227 void groups_free(struct group_info
*group_info
)
1229 if (group_info
->blocks
[0] != group_info
->small_block
) {
1231 for (i
= 0; i
< group_info
->nblocks
; i
++)
1232 free_page((unsigned long)group_info
->blocks
[i
]);
1237 EXPORT_SYMBOL(groups_free
);
1239 /* export the group_info to a user-space array */
1240 static int groups_to_user(gid_t __user
*grouplist
,
1241 struct group_info
*group_info
)
1244 int count
= group_info
->ngroups
;
1246 for (i
= 0; i
< group_info
->nblocks
; i
++) {
1247 int cp_count
= min(NGROUPS_PER_BLOCK
, count
);
1248 int off
= i
* NGROUPS_PER_BLOCK
;
1249 int len
= cp_count
* sizeof(*grouplist
);
1251 if (copy_to_user(grouplist
+off
, group_info
->blocks
[i
], len
))
1259 /* fill a group_info from a user-space array - it must be allocated already */
1260 static int groups_from_user(struct group_info
*group_info
,
1261 gid_t __user
*grouplist
)
1264 int count
= group_info
->ngroups
;
1266 for (i
= 0; i
< group_info
->nblocks
; i
++) {
1267 int cp_count
= min(NGROUPS_PER_BLOCK
, count
);
1268 int off
= i
* NGROUPS_PER_BLOCK
;
1269 int len
= cp_count
* sizeof(*grouplist
);
1271 if (copy_from_user(group_info
->blocks
[i
], grouplist
+off
, len
))
1279 /* a simple Shell sort */
1280 static void groups_sort(struct group_info
*group_info
)
1282 int base
, max
, stride
;
1283 int gidsetsize
= group_info
->ngroups
;
1285 for (stride
= 1; stride
< gidsetsize
; stride
= 3 * stride
+ 1)
1290 max
= gidsetsize
- stride
;
1291 for (base
= 0; base
< max
; base
++) {
1293 int right
= left
+ stride
;
1294 gid_t tmp
= GROUP_AT(group_info
, right
);
1296 while (left
>= 0 && GROUP_AT(group_info
, left
) > tmp
) {
1297 GROUP_AT(group_info
, right
) =
1298 GROUP_AT(group_info
, left
);
1302 GROUP_AT(group_info
, right
) = tmp
;
1308 /* a simple bsearch */
1309 int groups_search(struct group_info
*group_info
, gid_t grp
)
1317 right
= group_info
->ngroups
;
1318 while (left
< right
) {
1319 int mid
= (left
+right
)/2;
1320 int cmp
= grp
- GROUP_AT(group_info
, mid
);
1331 /* validate and set current->group_info */
1332 int set_current_groups(struct group_info
*group_info
)
1335 struct group_info
*old_info
;
1337 retval
= security_task_setgroups(group_info
);
1341 groups_sort(group_info
);
1342 get_group_info(group_info
);
1345 old_info
= current
->group_info
;
1346 current
->group_info
= group_info
;
1347 task_unlock(current
);
1349 put_group_info(old_info
);
1354 EXPORT_SYMBOL(set_current_groups
);
1356 asmlinkage
long sys_getgroups(int gidsetsize
, gid_t __user
*grouplist
)
1361 * SMP: Nobody else can change our grouplist. Thus we are
1368 /* no need to grab task_lock here; it cannot change */
1369 get_group_info(current
->group_info
);
1370 i
= current
->group_info
->ngroups
;
1372 if (i
> gidsetsize
) {
1376 if (groups_to_user(grouplist
, current
->group_info
)) {
1382 put_group_info(current
->group_info
);
1387 * SMP: Our groups are copy-on-write. We can set them safely
1388 * without another task interfering.
1391 asmlinkage
long sys_setgroups(int gidsetsize
, gid_t __user
*grouplist
)
1393 struct group_info
*group_info
;
1396 if (!capable(CAP_SETGID
))
1398 if ((unsigned)gidsetsize
> NGROUPS_MAX
)
1401 group_info
= groups_alloc(gidsetsize
);
1404 retval
= groups_from_user(group_info
, grouplist
);
1406 put_group_info(group_info
);
1410 retval
= set_current_groups(group_info
);
1411 put_group_info(group_info
);
1417 * Check whether we're fsgid/egid or in the supplemental group..
1419 int in_group_p(gid_t grp
)
1422 if (grp
!= current
->fsgid
) {
1423 get_group_info(current
->group_info
);
1424 retval
= groups_search(current
->group_info
, grp
);
1425 put_group_info(current
->group_info
);
1430 EXPORT_SYMBOL(in_group_p
);
1432 int in_egroup_p(gid_t grp
)
1435 if (grp
!= current
->egid
) {
1436 get_group_info(current
->group_info
);
1437 retval
= groups_search(current
->group_info
, grp
);
1438 put_group_info(current
->group_info
);
1443 EXPORT_SYMBOL(in_egroup_p
);
1445 DECLARE_RWSEM(uts_sem
);
1447 EXPORT_SYMBOL(uts_sem
);
1449 asmlinkage
long sys_newuname(struct new_utsname __user
* name
)
1453 down_read(&uts_sem
);
1454 if (copy_to_user(name
,&system_utsname
,sizeof *name
))
1460 asmlinkage
long sys_sethostname(char __user
*name
, int len
)
1463 char tmp
[__NEW_UTS_LEN
];
1465 if (!capable(CAP_SYS_ADMIN
))
1467 if (len
< 0 || len
> __NEW_UTS_LEN
)
1469 down_write(&uts_sem
);
1471 if (!copy_from_user(tmp
, name
, len
)) {
1472 memcpy(system_utsname
.nodename
, tmp
, len
);
1473 system_utsname
.nodename
[len
] = 0;
1480 #ifdef __ARCH_WANT_SYS_GETHOSTNAME
1482 asmlinkage
long sys_gethostname(char __user
*name
, int len
)
1488 down_read(&uts_sem
);
1489 i
= 1 + strlen(system_utsname
.nodename
);
1493 if (copy_to_user(name
, system_utsname
.nodename
, i
))
1502 * Only setdomainname; getdomainname can be implemented by calling
1505 asmlinkage
long sys_setdomainname(char __user
*name
, int len
)
1508 char tmp
[__NEW_UTS_LEN
];
1510 if (!capable(CAP_SYS_ADMIN
))
1512 if (len
< 0 || len
> __NEW_UTS_LEN
)
1515 down_write(&uts_sem
);
1517 if (!copy_from_user(tmp
, name
, len
)) {
1518 memcpy(system_utsname
.domainname
, tmp
, len
);
1519 system_utsname
.domainname
[len
] = 0;
1526 asmlinkage
long sys_getrlimit(unsigned int resource
, struct rlimit __user
*rlim
)
1528 if (resource
>= RLIM_NLIMITS
)
1531 struct rlimit value
;
1532 task_lock(current
->group_leader
);
1533 value
= current
->signal
->rlim
[resource
];
1534 task_unlock(current
->group_leader
);
1535 return copy_to_user(rlim
, &value
, sizeof(*rlim
)) ? -EFAULT
: 0;
1539 #ifdef __ARCH_WANT_SYS_OLD_GETRLIMIT
1542 * Back compatibility for getrlimit. Needed for some apps.
1545 asmlinkage
long sys_old_getrlimit(unsigned int resource
, struct rlimit __user
*rlim
)
1548 if (resource
>= RLIM_NLIMITS
)
1551 task_lock(current
->group_leader
);
1552 x
= current
->signal
->rlim
[resource
];
1553 task_unlock(current
->group_leader
);
1554 if(x
.rlim_cur
> 0x7FFFFFFF)
1555 x
.rlim_cur
= 0x7FFFFFFF;
1556 if(x
.rlim_max
> 0x7FFFFFFF)
1557 x
.rlim_max
= 0x7FFFFFFF;
1558 return copy_to_user(rlim
, &x
, sizeof(x
))?-EFAULT
:0;
1563 asmlinkage
long sys_setrlimit(unsigned int resource
, struct rlimit __user
*rlim
)
1565 struct rlimit new_rlim
, *old_rlim
;
1568 if (resource
>= RLIM_NLIMITS
)
1570 if(copy_from_user(&new_rlim
, rlim
, sizeof(*rlim
)))
1572 if (new_rlim
.rlim_cur
> new_rlim
.rlim_max
)
1574 old_rlim
= current
->signal
->rlim
+ resource
;
1575 if ((new_rlim
.rlim_max
> old_rlim
->rlim_max
) &&
1576 !capable(CAP_SYS_RESOURCE
))
1578 if (resource
== RLIMIT_NOFILE
&& new_rlim
.rlim_max
> NR_OPEN
)
1581 retval
= security_task_setrlimit(resource
, &new_rlim
);
1585 task_lock(current
->group_leader
);
1586 *old_rlim
= new_rlim
;
1587 task_unlock(current
->group_leader
);
1589 if (resource
== RLIMIT_CPU
&& new_rlim
.rlim_cur
!= RLIM_INFINITY
&&
1590 (cputime_eq(current
->signal
->it_prof_expires
, cputime_zero
) ||
1591 new_rlim
.rlim_cur
<= cputime_to_secs(
1592 current
->signal
->it_prof_expires
))) {
1593 cputime_t cputime
= secs_to_cputime(new_rlim
.rlim_cur
);
1594 read_lock(&tasklist_lock
);
1595 spin_lock_irq(¤t
->sighand
->siglock
);
1596 set_process_cpu_timer(current
, CPUCLOCK_PROF
,
1598 spin_unlock_irq(¤t
->sighand
->siglock
);
1599 read_unlock(&tasklist_lock
);
1606 * It would make sense to put struct rusage in the task_struct,
1607 * except that would make the task_struct be *really big*. After
1608 * task_struct gets moved into malloc'ed memory, it would
1609 * make sense to do this. It will make moving the rest of the information
1610 * a lot simpler! (Which we're not doing right now because we're not
1611 * measuring them yet).
1613 * This expects to be called with tasklist_lock read-locked or better,
1614 * and the siglock not locked. It may momentarily take the siglock.
1616 * When sampling multiple threads for RUSAGE_SELF, under SMP we might have
1617 * races with threads incrementing their own counters. But since word
1618 * reads are atomic, we either get new values or old values and we don't
1619 * care which for the sums. We always take the siglock to protect reading
1620 * the c* fields from p->signal from races with exit.c updating those
1621 * fields when reaping, so a sample either gets all the additions of a
1622 * given child after it's reaped, or none so this sample is before reaping.
1625 static void k_getrusage(struct task_struct
*p
, int who
, struct rusage
*r
)
1627 struct task_struct
*t
;
1628 unsigned long flags
;
1629 cputime_t utime
, stime
;
1631 memset((char *) r
, 0, sizeof *r
);
1633 if (unlikely(!p
->signal
))
1637 case RUSAGE_CHILDREN
:
1638 spin_lock_irqsave(&p
->sighand
->siglock
, flags
);
1639 utime
= p
->signal
->cutime
;
1640 stime
= p
->signal
->cstime
;
1641 r
->ru_nvcsw
= p
->signal
->cnvcsw
;
1642 r
->ru_nivcsw
= p
->signal
->cnivcsw
;
1643 r
->ru_minflt
= p
->signal
->cmin_flt
;
1644 r
->ru_majflt
= p
->signal
->cmaj_flt
;
1645 spin_unlock_irqrestore(&p
->sighand
->siglock
, flags
);
1646 cputime_to_timeval(utime
, &r
->ru_utime
);
1647 cputime_to_timeval(stime
, &r
->ru_stime
);
1650 spin_lock_irqsave(&p
->sighand
->siglock
, flags
);
1651 utime
= stime
= cputime_zero
;
1654 spin_lock_irqsave(&p
->sighand
->siglock
, flags
);
1655 utime
= p
->signal
->cutime
;
1656 stime
= p
->signal
->cstime
;
1657 r
->ru_nvcsw
= p
->signal
->cnvcsw
;
1658 r
->ru_nivcsw
= p
->signal
->cnivcsw
;
1659 r
->ru_minflt
= p
->signal
->cmin_flt
;
1660 r
->ru_majflt
= p
->signal
->cmaj_flt
;
1662 utime
= cputime_add(utime
, p
->signal
->utime
);
1663 stime
= cputime_add(stime
, p
->signal
->stime
);
1664 r
->ru_nvcsw
+= p
->signal
->nvcsw
;
1665 r
->ru_nivcsw
+= p
->signal
->nivcsw
;
1666 r
->ru_minflt
+= p
->signal
->min_flt
;
1667 r
->ru_majflt
+= p
->signal
->maj_flt
;
1670 utime
= cputime_add(utime
, t
->utime
);
1671 stime
= cputime_add(stime
, t
->stime
);
1672 r
->ru_nvcsw
+= t
->nvcsw
;
1673 r
->ru_nivcsw
+= t
->nivcsw
;
1674 r
->ru_minflt
+= t
->min_flt
;
1675 r
->ru_majflt
+= t
->maj_flt
;
1678 spin_unlock_irqrestore(&p
->sighand
->siglock
, flags
);
1679 cputime_to_timeval(utime
, &r
->ru_utime
);
1680 cputime_to_timeval(stime
, &r
->ru_stime
);
1687 int getrusage(struct task_struct
*p
, int who
, struct rusage __user
*ru
)
1690 read_lock(&tasklist_lock
);
1691 k_getrusage(p
, who
, &r
);
1692 read_unlock(&tasklist_lock
);
1693 return copy_to_user(ru
, &r
, sizeof(r
)) ? -EFAULT
: 0;
1696 asmlinkage
long sys_getrusage(int who
, struct rusage __user
*ru
)
1698 if (who
!= RUSAGE_SELF
&& who
!= RUSAGE_CHILDREN
)
1700 return getrusage(current
, who
, ru
);
1703 asmlinkage
long sys_umask(int mask
)
1705 mask
= xchg(¤t
->fs
->umask
, mask
& S_IRWXUGO
);
1709 asmlinkage
long sys_prctl(int option
, unsigned long arg2
, unsigned long arg3
,
1710 unsigned long arg4
, unsigned long arg5
)
1715 error
= security_task_prctl(option
, arg2
, arg3
, arg4
, arg5
);
1720 case PR_SET_PDEATHSIG
:
1722 if (!valid_signal(sig
)) {
1726 current
->pdeath_signal
= sig
;
1728 case PR_GET_PDEATHSIG
:
1729 error
= put_user(current
->pdeath_signal
, (int __user
*)arg2
);
1731 case PR_GET_DUMPABLE
:
1732 if (current
->mm
->dumpable
)
1735 case PR_SET_DUMPABLE
:
1736 if (arg2
< 0 || arg2
> 2) {
1740 current
->mm
->dumpable
= arg2
;
1743 case PR_SET_UNALIGN
:
1744 error
= SET_UNALIGN_CTL(current
, arg2
);
1746 case PR_GET_UNALIGN
:
1747 error
= GET_UNALIGN_CTL(current
, arg2
);
1750 error
= SET_FPEMU_CTL(current
, arg2
);
1753 error
= GET_FPEMU_CTL(current
, arg2
);
1756 error
= SET_FPEXC_CTL(current
, arg2
);
1759 error
= GET_FPEXC_CTL(current
, arg2
);
1762 error
= PR_TIMING_STATISTICAL
;
1765 if (arg2
== PR_TIMING_STATISTICAL
)
1771 case PR_GET_KEEPCAPS
:
1772 if (current
->keep_capabilities
)
1775 case PR_SET_KEEPCAPS
:
1776 if (arg2
!= 0 && arg2
!= 1) {
1780 current
->keep_capabilities
= arg2
;
1783 struct task_struct
*me
= current
;
1784 unsigned char ncomm
[sizeof(me
->comm
)];
1786 ncomm
[sizeof(me
->comm
)-1] = 0;
1787 if (strncpy_from_user(ncomm
, (char __user
*)arg2
,
1788 sizeof(me
->comm
)-1) < 0)
1790 set_task_comm(me
, ncomm
);
1794 struct task_struct
*me
= current
;
1795 unsigned char tcomm
[sizeof(me
->comm
)];
1797 get_task_comm(tcomm
, me
);
1798 if (copy_to_user((char __user
*)arg2
, tcomm
, sizeof(tcomm
)))