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/smp_lock.h>
12 #include <linux/notifier.h>
13 #include <linux/reboot.h>
14 #include <linux/prctl.h>
15 #include <linux/init.h>
16 #include <linux/highuid.h>
18 #include <asm/uaccess.h>
22 * this is where the system-wide overflow UID and GID are defined, for
23 * architectures that now have 32-bit UID/GID but didn't in the past
26 int overflowuid
= DEFAULT_OVERFLOWUID
;
27 int overflowgid
= DEFAULT_OVERFLOWGID
;
30 * the same as above, but for filesystems which can only store a 16-bit
31 * UID and GID. as such, this is needed on all architectures
34 int fs_overflowuid
= DEFAULT_FS_OVERFLOWUID
;
35 int fs_overflowgid
= DEFAULT_FS_OVERFLOWUID
;
38 * this indicates whether you can reboot with ctrl-alt-del: the default is yes
45 * Notifier list for kernel code which wants to be called
46 * at shutdown. This is used to stop any idling DMA operations
50 static struct notifier_block
*reboot_notifier_list
= NULL
;
51 rwlock_t notifier_lock
= RW_LOCK_UNLOCKED
;
54 * notifier_chain_register - Add notifier to a notifier chain
55 * @list: Pointer to root list pointer
56 * @n: New entry in notifier chain
58 * Adds a notifier to a notifier chain.
60 * Currently always returns zero.
63 int notifier_chain_register(struct notifier_block
**list
, struct notifier_block
*n
)
65 write_lock(¬ifier_lock
);
68 if(n
->priority
> (*list
)->priority
)
70 list
= &((*list
)->next
);
74 write_unlock(¬ifier_lock
);
79 * notifier_chain_unregister - Remove notifier from a notifier chain
80 * @nl: Pointer to root list pointer
81 * @n: New entry in notifier chain
83 * Removes a notifier from a notifier chain.
85 * Returns zero on success, or %-ENOENT on failure.
88 int notifier_chain_unregister(struct notifier_block
**nl
, struct notifier_block
*n
)
90 write_lock(¬ifier_lock
);
96 write_unlock(¬ifier_lock
);
101 write_unlock(¬ifier_lock
);
106 * notifier_call_chain - Call functions in a notifier chain
107 * @n: Pointer to root pointer of notifier chain
108 * @val: Value passed unmodified to notifier function
109 * @v: Pointer passed unmodified to notifier function
111 * Calls each function in a notifier chain in turn.
113 * If the return value of the notifier can be and'd
114 * with %NOTIFY_STOP_MASK, then notifier_call_chain
115 * will return immediately, with the return value of
116 * the notifier function which halted execution.
117 * Otherwise, the return value is the return value
118 * of the last notifier function called.
121 int notifier_call_chain(struct notifier_block
**n
, unsigned long val
, void *v
)
124 struct notifier_block
*nb
= *n
;
126 read_lock(¬ifier_lock
);
129 ret
=nb
->notifier_call(nb
,val
,v
);
130 if(ret
&NOTIFY_STOP_MASK
)
132 read_unlock(¬ifier_lock
);
137 read_unlock(¬ifier_lock
);
142 * register_reboot_notifier - Register function to be called at reboot time
143 * @nb: Info about notifier function to be called
145 * Registers a function with the list of functions
146 * to be called at reboot time.
148 * Currently always returns zero, as notifier_chain_register
149 * always returns zero.
152 int register_reboot_notifier(struct notifier_block
* nb
)
154 return notifier_chain_register(&reboot_notifier_list
, nb
);
158 * unregister_reboot_notifier - Unregister previously registered reboot notifier
159 * @nb: Hook to be unregistered
161 * Unregisters a previously registered reboot
164 * Returns zero on success, or %-ENOENT on failure.
167 int unregister_reboot_notifier(struct notifier_block
* nb
)
169 return notifier_chain_unregister(&reboot_notifier_list
, nb
);
172 asmlinkage
long sys_ni_syscall(void)
177 static int proc_sel(struct task_struct
*p
, int which
, int who
)
183 if (!who
&& p
== current
)
185 return(p
->pid
== who
);
189 return(p
->pgrp
== who
);
193 return(p
->uid
== who
);
199 asmlinkage
long sys_setpriority(int which
, int who
, int niceval
)
201 struct task_struct
*p
;
204 if (which
> 2 || which
< 0)
207 /* normalize: avoid signed division (rounding problems) */
214 read_lock(&tasklist_lock
);
216 if (!proc_sel(p
, which
, who
))
218 if (p
->uid
!= current
->euid
&&
219 p
->uid
!= current
->uid
&& !capable(CAP_SYS_NICE
)) {
225 if (niceval
< p
->nice
&& !capable(CAP_SYS_NICE
))
230 read_unlock(&tasklist_lock
);
236 * Ugh. To avoid negative return values, "getpriority()" will
237 * not return the normal nice-value, but a value that has been
238 * offset by 20 (ie it returns 0..39 instead of -20..19)
240 asmlinkage
long sys_getpriority(int which
, int who
)
242 struct task_struct
*p
;
243 long retval
= -ESRCH
;
245 if (which
> 2 || which
< 0)
248 read_lock(&tasklist_lock
);
251 if (!proc_sel(p
, which
, who
))
253 niceval
= p
->nice
+ 20;
254 if (niceval
< (unsigned)retval
)
257 read_unlock(&tasklist_lock
);
264 * Reboot system call: for obvious reasons only root may call it,
265 * and even root needs to set up some magic numbers in the registers
266 * so that some mistake won't make this reboot the whole machine.
267 * You can also set the meaning of the ctrl-alt-del-key here.
269 * reboot doesn't sync: do that yourself before calling this.
271 asmlinkage
long sys_reboot(int magic1
, int magic2
, unsigned int cmd
, void * arg
)
275 /* We only trust the superuser with rebooting the system. */
276 if (!capable(CAP_SYS_BOOT
))
279 /* For safety, we require "magic" arguments. */
280 if (magic1
!= LINUX_REBOOT_MAGIC1
||
281 (magic2
!= LINUX_REBOOT_MAGIC2
&& magic2
!= LINUX_REBOOT_MAGIC2A
&&
282 magic2
!= LINUX_REBOOT_MAGIC2B
))
287 case LINUX_REBOOT_CMD_RESTART
:
288 notifier_call_chain(&reboot_notifier_list
, SYS_RESTART
, NULL
);
289 printk(KERN_EMERG
"Restarting system.\n");
290 machine_restart(NULL
);
293 case LINUX_REBOOT_CMD_CAD_ON
:
297 case LINUX_REBOOT_CMD_CAD_OFF
:
301 case LINUX_REBOOT_CMD_HALT
:
302 notifier_call_chain(&reboot_notifier_list
, SYS_HALT
, NULL
);
303 printk(KERN_EMERG
"System halted.\n");
308 case LINUX_REBOOT_CMD_POWER_OFF
:
309 notifier_call_chain(&reboot_notifier_list
, SYS_POWER_OFF
, NULL
);
310 printk(KERN_EMERG
"Power down.\n");
315 case LINUX_REBOOT_CMD_RESTART2
:
316 if (strncpy_from_user(&buffer
[0], (char *)arg
, sizeof(buffer
) - 1) < 0) {
320 buffer
[sizeof(buffer
) - 1] = '\0';
322 notifier_call_chain(&reboot_notifier_list
, SYS_RESTART
, buffer
);
323 printk(KERN_EMERG
"Restarting system with command '%s'.\n", buffer
);
324 machine_restart(buffer
);
336 * This function gets called by ctrl-alt-del - ie the keyboard interrupt.
337 * As it's called within an interrupt, it may NOT sync: the only choice
338 * is whether to reboot at once, or just ignore the ctrl-alt-del.
340 void ctrl_alt_del(void)
343 notifier_call_chain(&reboot_notifier_list
, SYS_RESTART
, NULL
);
344 machine_restart(NULL
);
346 kill_proc(1, SIGINT
, 1);
351 * Unprivileged users may change the real gid to the effective gid
352 * or vice versa. (BSD-style)
354 * If you set the real gid at all, or set the effective gid to a value not
355 * equal to the real gid, then the saved gid is set to the new effective gid.
357 * This makes it possible for a setgid program to completely drop its
358 * privileges, which is often a useful assertion to make when you are doing
359 * a security audit over a program.
361 * The general idea is that a program which uses just setregid() will be
362 * 100% compatible with BSD. A program which uses just setgid() will be
363 * 100% compatible with POSIX with saved IDs.
365 * SMP: There are not races, the GIDs are checked only by filesystem
366 * operations (as far as semantic preservation is concerned).
368 asmlinkage
long sys_setregid(gid_t rgid
, gid_t egid
)
370 int old_rgid
= current
->gid
;
371 int old_egid
= current
->egid
;
373 if (rgid
!= (gid_t
) -1) {
374 if ((old_rgid
== rgid
) ||
375 (current
->egid
==rgid
) ||
381 if (egid
!= (gid_t
) -1) {
382 if ((old_rgid
== egid
) ||
383 (current
->egid
== egid
) ||
384 (current
->sgid
== egid
) ||
386 current
->fsgid
= current
->egid
= egid
;
388 current
->gid
= old_rgid
;
392 if (rgid
!= (gid_t
) -1 ||
393 (egid
!= (gid_t
) -1 && egid
!= old_rgid
))
394 current
->sgid
= current
->egid
;
395 current
->fsgid
= current
->egid
;
396 if (current
->egid
!= old_egid
)
397 current
->dumpable
= 0;
402 * setgid() is implemented like SysV w/ SAVED_IDS
404 * SMP: Same implicit races as above.
406 asmlinkage
long sys_setgid(gid_t gid
)
408 int old_egid
= current
->egid
;
410 if (capable(CAP_SETGID
))
411 current
->gid
= current
->egid
= current
->sgid
= current
->fsgid
= gid
;
412 else if ((gid
== current
->gid
) || (gid
== current
->sgid
))
413 current
->egid
= current
->fsgid
= gid
;
417 if (current
->egid
!= old_egid
)
418 current
->dumpable
= 0;
423 * cap_emulate_setxuid() fixes the effective / permitted capabilities of
424 * a process after a call to setuid, setreuid, or setresuid.
426 * 1) When set*uiding _from_ one of {r,e,s}uid == 0 _to_ all of
427 * {r,e,s}uid != 0, the permitted and effective capabilities are
430 * 2) When set*uiding _from_ euid == 0 _to_ euid != 0, the effective
431 * capabilities of the process are cleared.
433 * 3) When set*uiding _from_ euid != 0 _to_ euid == 0, the effective
434 * capabilities are set to the permitted capabilities.
436 * fsuid is handled elsewhere. fsuid == 0 and {r,e,s}uid!= 0 should
441 * cevans - New behaviour, Oct '99
442 * A process may, via prctl(), elect to keep its capabilities when it
443 * calls setuid() and switches away from uid==0. Both permitted and
444 * effective sets will be retained.
445 * Without this change, it was impossible for a daemon to drop only some
446 * of its privilege. The call to setuid(!=0) would drop all privileges!
447 * Keeping uid 0 is not an option because uid 0 owns too many vital
449 * Thanks to Olaf Kirch and Peter Benie for spotting this.
451 extern inline void cap_emulate_setxuid(int old_ruid
, int old_euid
,
454 if ((old_ruid
== 0 || old_euid
== 0 || old_suid
== 0) &&
455 (current
->uid
!= 0 && current
->euid
!= 0 && current
->suid
!= 0) &&
456 !current
->keep_capabilities
) {
457 cap_clear(current
->cap_permitted
);
458 cap_clear(current
->cap_effective
);
460 if (old_euid
== 0 && current
->euid
!= 0) {
461 cap_clear(current
->cap_effective
);
463 if (old_euid
!= 0 && current
->euid
== 0) {
464 current
->cap_effective
= current
->cap_permitted
;
469 * Unprivileged users may change the real uid to the effective uid
470 * or vice versa. (BSD-style)
472 * If you set the real uid at all, or set the effective uid to a value not
473 * equal to the real uid, then the saved uid is set to the new effective uid.
475 * This makes it possible for a setuid program to completely drop its
476 * privileges, which is often a useful assertion to make when you are doing
477 * a security audit over a program.
479 * The general idea is that a program which uses just setreuid() will be
480 * 100% compatible with BSD. A program which uses just setuid() will be
481 * 100% compatible with POSIX with saved IDs.
483 asmlinkage
long sys_setreuid(uid_t ruid
, uid_t euid
)
485 int old_ruid
, old_euid
, old_suid
, new_ruid
;
487 new_ruid
= old_ruid
= current
->uid
;
488 old_euid
= current
->euid
;
489 old_suid
= current
->suid
;
490 if (ruid
!= (uid_t
) -1) {
491 if ((old_ruid
== ruid
) ||
492 (current
->euid
==ruid
) ||
498 if (euid
!= (uid_t
) -1) {
499 if ((old_ruid
== euid
) ||
500 (current
->euid
== euid
) ||
501 (current
->suid
== euid
) ||
503 current
->fsuid
= current
->euid
= euid
;
507 if (ruid
!= (uid_t
) -1 ||
508 (euid
!= (uid_t
) -1 && euid
!= old_ruid
))
509 current
->suid
= current
->euid
;
510 current
->fsuid
= current
->euid
;
511 if (current
->euid
!= old_euid
)
512 current
->dumpable
= 0;
514 if(new_ruid
!= old_ruid
) {
515 /* What if a process setreuid()'s and this brings the
516 * new uid over his NPROC rlimit? We can check this now
517 * cheaply with the new uid cache, so if it matters
518 * we should be checking for it. -DaveM
521 current
->uid
= new_ruid
;
525 if (!issecure(SECURE_NO_SETUID_FIXUP
)) {
526 cap_emulate_setxuid(old_ruid
, old_euid
, old_suid
);
535 * setuid() is implemented like SysV with SAVED_IDS
537 * Note that SAVED_ID's is deficient in that a setuid root program
538 * like sendmail, for example, cannot set its uid to be a normal
539 * user and then switch back, because if you're root, setuid() sets
540 * the saved uid too. If you don't like this, blame the bright people
541 * in the POSIX committee and/or USG. Note that the BSD-style setreuid()
542 * will allow a root program to temporarily drop privileges and be able to
543 * regain them by swapping the real and effective uid.
545 asmlinkage
long sys_setuid(uid_t uid
)
547 int old_euid
= current
->euid
;
548 int old_ruid
, old_suid
, new_ruid
;
550 old_ruid
= new_ruid
= current
->uid
;
551 old_suid
= current
->suid
;
552 if (capable(CAP_SETUID
))
553 new_ruid
= current
->euid
= current
->suid
= current
->fsuid
= uid
;
554 else if ((uid
== current
->uid
) || (uid
== current
->suid
))
555 current
->fsuid
= current
->euid
= uid
;
559 if (current
->euid
!= old_euid
)
560 current
->dumpable
= 0;
562 if (new_ruid
!= old_ruid
) {
563 /* See comment above about NPROC rlimit issues... */
565 current
->uid
= new_ruid
;
569 if (!issecure(SECURE_NO_SETUID_FIXUP
)) {
570 cap_emulate_setxuid(old_ruid
, old_euid
, old_suid
);
578 * This function implements a generic ability to update ruid, euid,
579 * and suid. This allows you to implement the 4.4 compatible seteuid().
581 asmlinkage
long sys_setresuid(uid_t ruid
, uid_t euid
, uid_t suid
)
583 int old_ruid
= current
->uid
;
584 int old_euid
= current
->euid
;
585 int old_suid
= current
->suid
;
587 if (!capable(CAP_SETUID
)) {
588 if ((ruid
!= (uid_t
) -1) && (ruid
!= current
->uid
) &&
589 (ruid
!= current
->euid
) && (ruid
!= current
->suid
))
591 if ((euid
!= (uid_t
) -1) && (euid
!= current
->uid
) &&
592 (euid
!= current
->euid
) && (euid
!= current
->suid
))
594 if ((suid
!= (uid_t
) -1) && (suid
!= current
->uid
) &&
595 (suid
!= current
->euid
) && (suid
!= current
->suid
))
598 if (ruid
!= (uid_t
) -1) {
599 /* See above commentary about NPROC rlimit issues here. */
604 if (euid
!= (uid_t
) -1) {
605 if (euid
!= current
->euid
)
606 current
->dumpable
= 0;
607 current
->euid
= euid
;
608 current
->fsuid
= euid
;
610 if (suid
!= (uid_t
) -1)
611 current
->suid
= suid
;
613 if (!issecure(SECURE_NO_SETUID_FIXUP
)) {
614 cap_emulate_setxuid(old_ruid
, old_euid
, old_suid
);
620 asmlinkage
long sys_getresuid(uid_t
*ruid
, uid_t
*euid
, uid_t
*suid
)
624 if (!(retval
= put_user(current
->uid
, ruid
)) &&
625 !(retval
= put_user(current
->euid
, euid
)))
626 retval
= put_user(current
->suid
, suid
);
632 * Same as above, but for rgid, egid, sgid.
634 asmlinkage
long sys_setresgid(gid_t rgid
, gid_t egid
, gid_t sgid
)
636 if (!capable(CAP_SETGID
)) {
637 if ((rgid
!= (gid_t
) -1) && (rgid
!= current
->gid
) &&
638 (rgid
!= current
->egid
) && (rgid
!= current
->sgid
))
640 if ((egid
!= (gid_t
) -1) && (egid
!= current
->gid
) &&
641 (egid
!= current
->egid
) && (egid
!= current
->sgid
))
643 if ((sgid
!= (gid_t
) -1) && (sgid
!= current
->gid
) &&
644 (sgid
!= current
->egid
) && (sgid
!= current
->sgid
))
647 if (rgid
!= (gid_t
) -1)
649 if (egid
!= (gid_t
) -1) {
650 if (egid
!= current
->egid
)
651 current
->dumpable
= 0;
652 current
->egid
= egid
;
653 current
->fsgid
= egid
;
655 if (sgid
!= (gid_t
) -1)
656 current
->sgid
= sgid
;
660 asmlinkage
long sys_getresgid(gid_t
*rgid
, gid_t
*egid
, gid_t
*sgid
)
664 if (!(retval
= put_user(current
->gid
, rgid
)) &&
665 !(retval
= put_user(current
->egid
, egid
)))
666 retval
= put_user(current
->sgid
, sgid
);
673 * "setfsuid()" sets the fsuid - the uid used for filesystem checks. This
674 * is used for "access()" and for the NFS daemon (letting nfsd stay at
675 * whatever uid it wants to). It normally shadows "euid", except when
676 * explicitly set by setfsuid() or for access..
678 asmlinkage
long sys_setfsuid(uid_t uid
)
682 old_fsuid
= current
->fsuid
;
683 if (uid
== current
->uid
|| uid
== current
->euid
||
684 uid
== current
->suid
|| uid
== current
->fsuid
||
686 current
->fsuid
= uid
;
687 if (current
->fsuid
!= old_fsuid
)
688 current
->dumpable
= 0;
690 /* We emulate fsuid by essentially doing a scaled-down version
691 * of what we did in setresuid and friends. However, we only
692 * operate on the fs-specific bits of the process' effective
695 * FIXME - is fsuser used for all CAP_FS_MASK capabilities?
696 * if not, we might be a bit too harsh here.
699 if (!issecure(SECURE_NO_SETUID_FIXUP
)) {
700 if (old_fsuid
== 0 && current
->fsuid
!= 0) {
701 cap_t(current
->cap_effective
) &= ~CAP_FS_MASK
;
703 if (old_fsuid
!= 0 && current
->fsuid
== 0) {
704 cap_t(current
->cap_effective
) |=
705 (cap_t(current
->cap_permitted
) & CAP_FS_MASK
);
713 * Samma på svenska..
715 asmlinkage
long sys_setfsgid(gid_t gid
)
719 old_fsgid
= current
->fsgid
;
720 if (gid
== current
->gid
|| gid
== current
->egid
||
721 gid
== current
->sgid
|| gid
== current
->fsgid
||
723 current
->fsgid
= gid
;
724 if (current
->fsgid
!= old_fsgid
)
725 current
->dumpable
= 0;
730 asmlinkage
long sys_times(struct tms
* tbuf
)
733 * In the SMP world we might just be unlucky and have one of
734 * the times increment as we use it. Since the value is an
735 * atomically safe type this is just fine. Conceptually its
736 * as if the syscall took an instant longer to occur.
739 if (copy_to_user(tbuf
, ¤t
->times
, sizeof(struct tms
)))
745 * This needs some heavy checking ...
746 * I just haven't the stomach for it. I also don't fully
747 * understand sessions/pgrp etc. Let somebody who does explain it.
749 * OK, I think I have the protection semantics right.... this is really
750 * only important on a multi-user system anyway, to make sure one user
751 * can't send a signal to a process owned by another. -TYT, 12/12/91
753 * Auch. Had to add the 'did_exec' flag to conform completely to POSIX.
757 asmlinkage
long sys_setpgid(pid_t pid
, pid_t pgid
)
759 struct task_struct
* p
;
769 /* From this point forward we keep holding onto the tasklist lock
770 * so that our parent does not change from under us. -DaveM
772 read_lock(&tasklist_lock
);
775 p
= find_task_by_pid(pid
);
779 if (p
->p_pptr
== current
|| p
->p_opptr
== current
) {
781 if (p
->session
!= current
->session
)
786 } else if (p
!= current
)
792 struct task_struct
* tmp
;
793 for_each_task (tmp
) {
794 if (tmp
->pgrp
== pgid
&&
795 tmp
->session
== current
->session
)
805 /* All paths lead to here, thus we are safe. -DaveM */
806 read_unlock(&tasklist_lock
);
810 asmlinkage
long sys_getpgid(pid_t pid
)
813 return current
->pgrp
;
816 struct task_struct
*p
;
818 read_lock(&tasklist_lock
);
819 p
= find_task_by_pid(pid
);
824 read_unlock(&tasklist_lock
);
829 asmlinkage
long sys_getpgrp(void)
831 /* SMP - assuming writes are word atomic this is fine */
832 return current
->pgrp
;
835 asmlinkage
long sys_getsid(pid_t pid
)
838 return current
->session
;
841 struct task_struct
*p
;
843 read_lock(&tasklist_lock
);
844 p
= find_task_by_pid(pid
);
849 read_unlock(&tasklist_lock
);
854 asmlinkage
long sys_setsid(void)
856 struct task_struct
* p
;
859 read_lock(&tasklist_lock
);
861 if (p
->pgrp
== current
->pid
)
866 current
->session
= current
->pgrp
= current
->pid
;
868 current
->tty_old_pgrp
= 0;
871 read_unlock(&tasklist_lock
);
876 * Supplementary group IDs
878 asmlinkage
long sys_getgroups(int gidsetsize
, gid_t
*grouplist
)
883 * SMP: Nobody else can change our grouplist. Thus we are
889 i
= current
->ngroups
;
893 if (copy_to_user(grouplist
, current
->groups
, sizeof(gid_t
)*i
))
900 * SMP: Our groups are not shared. We can copy to/from them safely
901 * without another task interfering.
904 asmlinkage
long sys_setgroups(int gidsetsize
, gid_t
*grouplist
)
906 if (!capable(CAP_SETGID
))
908 if ((unsigned) gidsetsize
> NGROUPS
)
910 if(copy_from_user(current
->groups
, grouplist
, gidsetsize
* sizeof(gid_t
)))
912 current
->ngroups
= gidsetsize
;
916 static int supplemental_group_member(gid_t grp
)
918 int i
= current
->ngroups
;
921 gid_t
*groups
= current
->groups
;
933 * Check whether we're fsgid/egid or in the supplemental group..
935 int in_group_p(gid_t grp
)
938 if (grp
!= current
->fsgid
)
939 retval
= supplemental_group_member(grp
);
943 int in_egroup_p(gid_t grp
)
946 if (grp
!= current
->egid
)
947 retval
= supplemental_group_member(grp
);
951 DECLARE_RWSEM(uts_sem
);
953 asmlinkage
long sys_newuname(struct new_utsname
* name
)
958 if (copy_to_user(name
,&system_utsname
,sizeof *name
))
964 asmlinkage
long sys_sethostname(char *name
, int len
)
968 if (!capable(CAP_SYS_ADMIN
))
970 if (len
< 0 || len
> __NEW_UTS_LEN
)
972 down_write(&uts_sem
);
974 if (!copy_from_user(system_utsname
.nodename
, name
, len
)) {
975 system_utsname
.nodename
[len
] = 0;
982 asmlinkage
long sys_gethostname(char *name
, int len
)
989 i
= 1 + strlen(system_utsname
.nodename
);
993 if (copy_to_user(name
, system_utsname
.nodename
, i
))
1000 * Only setdomainname; getdomainname can be implemented by calling
1003 asmlinkage
long sys_setdomainname(char *name
, int len
)
1007 if (!capable(CAP_SYS_ADMIN
))
1009 if (len
< 0 || len
> __NEW_UTS_LEN
)
1012 down_write(&uts_sem
);
1014 if (!copy_from_user(system_utsname
.domainname
, name
, len
)) {
1016 system_utsname
.domainname
[len
] = 0;
1022 asmlinkage
long sys_getrlimit(unsigned int resource
, struct rlimit
*rlim
)
1024 if (resource
>= RLIM_NLIMITS
)
1027 return copy_to_user(rlim
, current
->rlim
+ resource
, sizeof(*rlim
))
1031 #if !defined(__ia64__) && !defined(__s390__)
1034 * Back compatibility for getrlimit. Needed for some apps.
1037 asmlinkage
long sys_old_getrlimit(unsigned int resource
, struct rlimit
*rlim
)
1040 if (resource
>= RLIM_NLIMITS
)
1043 memcpy(&x
, current
->rlim
+ resource
, sizeof(*rlim
));
1044 if(x
.rlim_cur
> 0x7FFFFFFF)
1045 x
.rlim_cur
= 0x7FFFFFFF;
1046 if(x
.rlim_max
> 0x7FFFFFFF)
1047 x
.rlim_max
= 0x7FFFFFFF;
1048 return copy_to_user(rlim
, &x
, sizeof(x
))?-EFAULT
:0;
1053 asmlinkage
long sys_setrlimit(unsigned int resource
, struct rlimit
*rlim
)
1055 struct rlimit new_rlim
, *old_rlim
;
1057 if (resource
>= RLIM_NLIMITS
)
1059 if(copy_from_user(&new_rlim
, rlim
, sizeof(*rlim
)))
1061 if (new_rlim
.rlim_cur
< 0 || new_rlim
.rlim_max
< 0)
1063 old_rlim
= current
->rlim
+ resource
;
1064 if (((new_rlim
.rlim_cur
> old_rlim
->rlim_max
) ||
1065 (new_rlim
.rlim_max
> old_rlim
->rlim_max
)) &&
1066 !capable(CAP_SYS_RESOURCE
))
1068 if (resource
== RLIMIT_NOFILE
) {
1069 if (new_rlim
.rlim_cur
> NR_OPEN
|| new_rlim
.rlim_max
> NR_OPEN
)
1072 *old_rlim
= new_rlim
;
1077 * It would make sense to put struct rusage in the task_struct,
1078 * except that would make the task_struct be *really big*. After
1079 * task_struct gets moved into malloc'ed memory, it would
1080 * make sense to do this. It will make moving the rest of the information
1081 * a lot simpler! (Which we're not doing right now because we're not
1082 * measuring them yet).
1084 * This is SMP safe. Either we are called from sys_getrusage on ourselves
1085 * below (we know we aren't going to exit/disappear and only we change our
1086 * rusage counters), or we are called from wait4() on a process which is
1087 * either stopped or zombied. In the zombied case the task won't get
1088 * reaped till shortly after the call to getrusage(), in both cases the
1089 * task being examined is in a frozen state so the counters won't change.
1091 * FIXME! Get the fault counts properly!
1093 int getrusage(struct task_struct
*p
, int who
, struct rusage
*ru
)
1097 memset((char *) &r
, 0, sizeof(r
));
1100 r
.ru_utime
.tv_sec
= CT_TO_SECS(p
->times
.tms_utime
);
1101 r
.ru_utime
.tv_usec
= CT_TO_USECS(p
->times
.tms_utime
);
1102 r
.ru_stime
.tv_sec
= CT_TO_SECS(p
->times
.tms_stime
);
1103 r
.ru_stime
.tv_usec
= CT_TO_USECS(p
->times
.tms_stime
);
1104 r
.ru_minflt
= p
->min_flt
;
1105 r
.ru_majflt
= p
->maj_flt
;
1106 r
.ru_nswap
= p
->nswap
;
1108 case RUSAGE_CHILDREN
:
1109 r
.ru_utime
.tv_sec
= CT_TO_SECS(p
->times
.tms_cutime
);
1110 r
.ru_utime
.tv_usec
= CT_TO_USECS(p
->times
.tms_cutime
);
1111 r
.ru_stime
.tv_sec
= CT_TO_SECS(p
->times
.tms_cstime
);
1112 r
.ru_stime
.tv_usec
= CT_TO_USECS(p
->times
.tms_cstime
);
1113 r
.ru_minflt
= p
->cmin_flt
;
1114 r
.ru_majflt
= p
->cmaj_flt
;
1115 r
.ru_nswap
= p
->cnswap
;
1118 r
.ru_utime
.tv_sec
= CT_TO_SECS(p
->times
.tms_utime
+ p
->times
.tms_cutime
);
1119 r
.ru_utime
.tv_usec
= CT_TO_USECS(p
->times
.tms_utime
+ p
->times
.tms_cutime
);
1120 r
.ru_stime
.tv_sec
= CT_TO_SECS(p
->times
.tms_stime
+ p
->times
.tms_cstime
);
1121 r
.ru_stime
.tv_usec
= CT_TO_USECS(p
->times
.tms_stime
+ p
->times
.tms_cstime
);
1122 r
.ru_minflt
= p
->min_flt
+ p
->cmin_flt
;
1123 r
.ru_majflt
= p
->maj_flt
+ p
->cmaj_flt
;
1124 r
.ru_nswap
= p
->nswap
+ p
->cnswap
;
1127 return copy_to_user(ru
, &r
, sizeof(r
)) ? -EFAULT
: 0;
1130 asmlinkage
long sys_getrusage(int who
, struct rusage
*ru
)
1132 if (who
!= RUSAGE_SELF
&& who
!= RUSAGE_CHILDREN
)
1134 return getrusage(current
, who
, ru
);
1137 asmlinkage
long sys_umask(int mask
)
1139 mask
= xchg(¤t
->fs
->umask
, mask
& S_IRWXUGO
);
1143 asmlinkage
long sys_prctl(int option
, unsigned long arg2
, unsigned long arg3
,
1144 unsigned long arg4
, unsigned long arg5
)
1150 case PR_SET_PDEATHSIG
:
1156 current
->pdeath_signal
= sig
;
1158 case PR_GET_PDEATHSIG
:
1159 error
= put_user(current
->pdeath_signal
, (int *)arg2
);
1161 case PR_GET_DUMPABLE
:
1162 if (current
->dumpable
)
1165 case PR_SET_DUMPABLE
:
1166 if (arg2
!= 0 && arg2
!= 1) {
1170 current
->dumpable
= arg2
;
1172 case PR_SET_UNALIGN
:
1173 #ifdef SET_UNALIGN_CTL
1174 error
= SET_UNALIGN_CTL(current
, arg2
);
1180 case PR_GET_UNALIGN
:
1181 #ifdef GET_UNALIGN_CTL
1182 error
= GET_UNALIGN_CTL(current
, arg2
);
1188 case PR_GET_KEEPCAPS
:
1189 if (current
->keep_capabilities
)
1192 case PR_SET_KEEPCAPS
:
1193 if (arg2
!= 0 && arg2
!= 1) {
1197 current
->keep_capabilities
= arg2
;
1206 EXPORT_SYMBOL(notifier_chain_register
);
1207 EXPORT_SYMBOL(notifier_chain_unregister
);
1208 EXPORT_SYMBOL(notifier_call_chain
);
1209 EXPORT_SYMBOL(register_reboot_notifier
);
1210 EXPORT_SYMBOL(unregister_reboot_notifier
);
1211 EXPORT_SYMBOL(in_group_p
);
1212 EXPORT_SYMBOL(in_egroup_p
);