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