?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] sched: multilevel sbe sbf
[wandboard.git] / kernel / sys.c
blobdac10161ca2384c59340d4fab96eae4237f2f8af
1 /*
2 * linux/kernel/sys.c
3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 */
6
7 #include <linux/config.h>
8 #include <linux/module.h>
9 #include <linux/mm.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>
18 #include <linux/fs.h>
19 #include <linux/workqueue.h>
20 #include <linux/device.h>
21 #include <linux/key.h>
22 #include <linux/times.h>
23 #include <linux/posix-timers.h>
24 #include <linux/security.h>
25 #include <linux/dcookies.h>
26 #include <linux/suspend.h>
27 #include <linux/tty.h>
28 #include <linux/signal.h>
29
30 #include <linux/compat.h>
31 #include <linux/syscalls.h>
32
33 #include <asm/uaccess.h>
34 #include <asm/io.h>
35 #include <asm/unistd.h>
36
37 #ifndef SET_UNALIGN_CTL
38 # define SET_UNALIGN_CTL(a,b) (-EINVAL)
39 #endif
40 #ifndef GET_UNALIGN_CTL
41 # define GET_UNALIGN_CTL(a,b) (-EINVAL)
42 #endif
43 #ifndef SET_FPEMU_CTL
44 # define SET_FPEMU_CTL(a,b) (-EINVAL)
45 #endif
46 #ifndef GET_FPEMU_CTL
47 # define GET_FPEMU_CTL(a,b) (-EINVAL)
48 #endif
49 #ifndef SET_FPEXC_CTL
50 # define SET_FPEXC_CTL(a,b) (-EINVAL)
51 #endif
52 #ifndef GET_FPEXC_CTL
53 # define GET_FPEXC_CTL(a,b) (-EINVAL)
54 #endif
55
56 /*
57 * this is where the system-wide overflow UID and GID are defined, for
58 * architectures that now have 32-bit UID/GID but didn't in the past
59 */
60
61 int overflowuid = DEFAULT_OVERFLOWUID;
62 int overflowgid = DEFAULT_OVERFLOWGID;
63
64 #ifdef CONFIG_UID16
65 EXPORT_SYMBOL(overflowuid);
66 EXPORT_SYMBOL(overflowgid);
67 #endif
68
69 /*
70 * the same as above, but for filesystems which can only store a 16-bit
71 * UID and GID. as such, this is needed on all architectures
72 */
73
74 int fs_overflowuid = DEFAULT_FS_OVERFLOWUID;
75 int fs_overflowgid = DEFAULT_FS_OVERFLOWUID;
76
77 EXPORT_SYMBOL(fs_overflowuid);
78 EXPORT_SYMBOL(fs_overflowgid);
79
80 /*
81 * this indicates whether you can reboot with ctrl-alt-del: the default is yes
82 */
83
84 int C_A_D = 1;
85 int cad_pid = 1;
86
87 /*
88 * Notifier list for kernel code which wants to be called
89 * at shutdown. This is used to stop any idling DMA operations
90 * and the like.
91 */
92
93 static struct notifier_block *reboot_notifier_list;
94 static DEFINE_RWLOCK(notifier_lock);
95
96 /**
97 * notifier_chain_register - Add notifier to a notifier chain
98 * @list: Pointer to root list pointer
99 * @n: New entry in notifier chain
100 *
101 * Adds a notifier to a notifier chain.
102 *
103 * Currently always returns zero.
104 */
105
106 int notifier_chain_register(struct notifier_block **list, struct notifier_block *n)
107 {
108 write_lock(&notifier_lock);
109 while(*list)
110 {
111 if(n->priority > (*list)->priority)
112 break;
113 list= &((*list)->next);
114 }
115 n->next = *list;
116 *list=n;
117 write_unlock(&notifier_lock);
118 return 0;
119 }
120
121 EXPORT_SYMBOL(notifier_chain_register);
122
123 /**
124 * notifier_chain_unregister - Remove notifier from a notifier chain
125 * @nl: Pointer to root list pointer
126 * @n: New entry in notifier chain
127 *
128 * Removes a notifier from a notifier chain.
129 *
130 * Returns zero on success, or %-ENOENT on failure.
131 */
132
133 int notifier_chain_unregister(struct notifier_block **nl, struct notifier_block *n)
134 {
135 write_lock(&notifier_lock);
136 while((*nl)!=NULL)
137 {
138 if((*nl)==n)
139 {
140 *nl=n->next;
141 write_unlock(&notifier_lock);
142 return 0;
143 }
144 nl=&((*nl)->next);
145 }
146 write_unlock(&notifier_lock);
147 return -ENOENT;
148 }
149
150 EXPORT_SYMBOL(notifier_chain_unregister);
151
152 /**
153 * notifier_call_chain - Call functions in a notifier chain
154 * @n: Pointer to root pointer of notifier chain
155 * @val: Value passed unmodified to notifier function
156 * @v: Pointer passed unmodified to notifier function
157 *
158 * Calls each function in a notifier chain in turn.
159 *
160 * If the return value of the notifier can be and'd
161 * with %NOTIFY_STOP_MASK, then notifier_call_chain
162 * will return immediately, with the return value of
163 * the notifier function which halted execution.
164 * Otherwise, the return value is the return value
165 * of the last notifier function called.
166 */
167
168 int notifier_call_chain(struct notifier_block **n, unsigned long val, void *v)
169 {
170 int ret=NOTIFY_DONE;
171 struct notifier_block *nb = *n;
172
173 while(nb)
174 {
175 ret=nb->notifier_call(nb,val,v);
176 if(ret&NOTIFY_STOP_MASK)
177 {
178 return ret;
179 }
180 nb=nb->next;
181 }
182 return ret;
183 }
184
185 EXPORT_SYMBOL(notifier_call_chain);
186
187 /**
188 * register_reboot_notifier - Register function to be called at reboot time
189 * @nb: Info about notifier function to be called
190 *
191 * Registers a function with the list of functions
192 * to be called at reboot time.
193 *
194 * Currently always returns zero, as notifier_chain_register
195 * always returns zero.
196 */
197
198 int register_reboot_notifier(struct notifier_block * nb)
199 {
200 return notifier_chain_register(&reboot_notifier_list, nb);
201 }
202
203 EXPORT_SYMBOL(register_reboot_notifier);
204
205 /**
206 * unregister_reboot_notifier - Unregister previously registered reboot notifier
207 * @nb: Hook to be unregistered
208 *
209 * Unregisters a previously registered reboot
210 * notifier function.
211 *
212 * Returns zero on success, or %-ENOENT on failure.
213 */
214
215 int unregister_reboot_notifier(struct notifier_block * nb)
216 {
217 return notifier_chain_unregister(&reboot_notifier_list, nb);
218 }
219
220 EXPORT_SYMBOL(unregister_reboot_notifier);
221
222 static int set_one_prio(struct task_struct *p, int niceval, int error)
223 {
224 int no_nice;
225
226 if (p->uid != current->euid &&
227 p->euid != current->euid && !capable(CAP_SYS_NICE)) {
228 error = -EPERM;
229 goto out;
230 }
231 if (niceval < task_nice(p) && !can_nice(p, niceval)) {
232 error = -EACCES;
233 goto out;
234 }
235 no_nice = security_task_setnice(p, niceval);
236 if (no_nice) {
237 error = no_nice;
238 goto out;
239 }
240 if (error == -ESRCH)
241 error = 0;
242 set_user_nice(p, niceval);
243 out:
244 return error;
245 }
246
247 asmlinkage long sys_setpriority(int which, int who, int niceval)
248 {
249 struct task_struct *g, *p;
250 struct user_struct *user;
251 int error = -EINVAL;
252
253 if (which > 2 || which < 0)
254 goto out;
255
256 /* normalize: avoid signed division (rounding problems) */
257 error = -ESRCH;
258 if (niceval < -20)
259 niceval = -20;
260 if (niceval > 19)
261 niceval = 19;
262
263 read_lock(&tasklist_lock);
264 switch (which) {
265 case PRIO_PROCESS:
266 if (!who)
267 who = current->pid;
268 p = find_task_by_pid(who);
269 if (p)
270 error = set_one_prio(p, niceval, error);
271 break;
272 case PRIO_PGRP:
273 if (!who)
274 who = process_group(current);
275 do_each_task_pid(who, PIDTYPE_PGID, p) {
276 error = set_one_prio(p, niceval, error);
277 } while_each_task_pid(who, PIDTYPE_PGID, p);
278 break;
279 case PRIO_USER:
280 user = current->user;
281 if (!who)
282 who = current->uid;
283 else
284 if ((who != current->uid) && !(user = find_user(who)))
285 goto out_unlock; /* No processes for this user */
286
287 do_each_thread(g, p)
288 if (p->uid == who)
289 error = set_one_prio(p, niceval, error);
290 while_each_thread(g, p);
291 if (who != current->uid)
292 free_uid(user); /* For find_user() */
293 break;
294 }
295 out_unlock:
296 read_unlock(&tasklist_lock);
297 out:
298 return error;
299 }
300
301 /*
302 * Ugh. To avoid negative return values, "getpriority()" will
303 * not return the normal nice-value, but a negated value that
304 * has been offset by 20 (ie it returns 40..1 instead of -20..19)
305 * to stay compatible.
306 */
307 asmlinkage long sys_getpriority(int which, int who)
308 {
309 struct task_struct *g, *p;
310 struct user_struct *user;
311 long niceval, retval = -ESRCH;
312
313 if (which > 2 || which < 0)
314 return -EINVAL;
315
316 read_lock(&tasklist_lock);
317 switch (which) {
318 case PRIO_PROCESS:
319 if (!who)
320 who = current->pid;
321 p = find_task_by_pid(who);
322 if (p) {
323 niceval = 20 - task_nice(p);
324 if (niceval > retval)
325 retval = niceval;
326 }
327 break;
328 case PRIO_PGRP:
329 if (!who)
330 who = process_group(current);
331 do_each_task_pid(who, PIDTYPE_PGID, p) {
332 niceval = 20 - task_nice(p);
333 if (niceval > retval)
334 retval = niceval;
335 } while_each_task_pid(who, PIDTYPE_PGID, p);
336 break;
337 case PRIO_USER:
338 user = current->user;
339 if (!who)
340 who = current->uid;
341 else
342 if ((who != current->uid) && !(user = find_user(who)))
343 goto out_unlock; /* No processes for this user */
344
345 do_each_thread(g, p)
346 if (p->uid == who) {
347 niceval = 20 - task_nice(p);
348 if (niceval > retval)
349 retval = niceval;
350 }
351 while_each_thread(g, p);
352 if (who != current->uid)
353 free_uid(user); /* for find_user() */
354 break;
355 }
356 out_unlock:
357 read_unlock(&tasklist_lock);
358
359 return retval;
360 }
361
362
363 /*
364 * Reboot system call: for obvious reasons only root may call it,
365 * and even root needs to set up some magic numbers in the registers
366 * so that some mistake won't make this reboot the whole machine.
367 * You can also set the meaning of the ctrl-alt-del-key here.
368 *
369 * reboot doesn't sync: do that yourself before calling this.
370 */
371 asmlinkage long sys_reboot(int magic1, int magic2, unsigned int cmd, void __user * arg)
372 {
373 char buffer[256];
374
375 /* We only trust the superuser with rebooting the system. */
376 if (!capable(CAP_SYS_BOOT))
377 return -EPERM;
378
379 /* For safety, we require "magic" arguments. */
380 if (magic1 != LINUX_REBOOT_MAGIC1 ||
381 (magic2 != LINUX_REBOOT_MAGIC2 &&
382 magic2 != LINUX_REBOOT_MAGIC2A &&
383 magic2 != LINUX_REBOOT_MAGIC2B &&
384 magic2 != LINUX_REBOOT_MAGIC2C))
385 return -EINVAL;
386
387 lock_kernel();
388 switch (cmd) {
389 case LINUX_REBOOT_CMD_RESTART:
390 notifier_call_chain(&reboot_notifier_list, SYS_RESTART, NULL);
391 system_state = SYSTEM_RESTART;
392 device_shutdown();
393 printk(KERN_EMERG "Restarting system.\n");
394 machine_restart(NULL);
395 break;
396
397 case LINUX_REBOOT_CMD_CAD_ON:
398 C_A_D = 1;
399 break;
400
401 case LINUX_REBOOT_CMD_CAD_OFF:
402 C_A_D = 0;
403 break;
404
405 case LINUX_REBOOT_CMD_HALT:
406 notifier_call_chain(&reboot_notifier_list, SYS_HALT, NULL);
407 system_state = SYSTEM_HALT;
408 device_suspend(PMSG_SUSPEND);
409 device_shutdown();
410 printk(KERN_EMERG "System halted.\n");
411 machine_halt();
412 unlock_kernel();
413 do_exit(0);
414 break;
415
416 case LINUX_REBOOT_CMD_POWER_OFF:
417 notifier_call_chain(&reboot_notifier_list, SYS_POWER_OFF, NULL);
418 system_state = SYSTEM_POWER_OFF;
419 device_suspend(PMSG_SUSPEND);
420 device_shutdown();
421 printk(KERN_EMERG "Power down.\n");
422 machine_power_off();
423 unlock_kernel();
424 do_exit(0);
425 break;
426
427 case LINUX_REBOOT_CMD_RESTART2:
428 if (strncpy_from_user(&buffer[0], arg, sizeof(buffer) - 1) < 0) {
429 unlock_kernel();
430 return -EFAULT;
431 }
432 buffer[sizeof(buffer) - 1] = '\0';
433
434 notifier_call_chain(&reboot_notifier_list, SYS_RESTART, buffer);
435 system_state = SYSTEM_RESTART;
436 device_suspend(PMSG_FREEZE);
437 device_shutdown();
438 printk(KERN_EMERG "Restarting system with command '%s'.\n", buffer);
439 machine_restart(buffer);
440 break;
441
442 #ifdef CONFIG_SOFTWARE_SUSPEND
443 case LINUX_REBOOT_CMD_SW_SUSPEND:
444 {
445 int ret = software_suspend();
446 unlock_kernel();
447 return ret;
448 }
449 #endif
450
451 default:
452 unlock_kernel();
453 return -EINVAL;
454 }
455 unlock_kernel();
456 return 0;
457 }
458
459 static void deferred_cad(void *dummy)
460 {
461 notifier_call_chain(&reboot_notifier_list, SYS_RESTART, NULL);
462 machine_restart(NULL);
463 }
464
465 /*
466 * This function gets called by ctrl-alt-del - ie the keyboard interrupt.
467 * As it's called within an interrupt, it may NOT sync: the only choice
468 * is whether to reboot at once, or just ignore the ctrl-alt-del.
469 */
470 void ctrl_alt_del(void)
471 {
472 static DECLARE_WORK(cad_work, deferred_cad, NULL);
473
474 if (C_A_D)
475 schedule_work(&cad_work);
476 else
477 kill_proc(cad_pid, SIGINT, 1);
478 }
479
480
481 /*
482 * Unprivileged users may change the real gid to the effective gid
483 * or vice versa. (BSD-style)
484 *
485 * If you set the real gid at all, or set the effective gid to a value not
486 * equal to the real gid, then the saved gid is set to the new effective gid.
487 *
488 * This makes it possible for a setgid program to completely drop its
489 * privileges, which is often a useful assertion to make when you are doing
490 * a security audit over a program.
491 *
492 * The general idea is that a program which uses just setregid() will be
493 * 100% compatible with BSD. A program which uses just setgid() will be
494 * 100% compatible with POSIX with saved IDs.
495 *
496 * SMP: There are not races, the GIDs are checked only by filesystem
497 * operations (as far as semantic preservation is concerned).
498 */
499 asmlinkage long sys_setregid(gid_t rgid, gid_t egid)
500 {
501 int old_rgid = current->gid;
502 int old_egid = current->egid;
503 int new_rgid = old_rgid;
504 int new_egid = old_egid;
505 int retval;
506
507 retval = security_task_setgid(rgid, egid, (gid_t)-1, LSM_SETID_RE);
508 if (retval)
509 return retval;
510
511 if (rgid != (gid_t) -1) {
512 if ((old_rgid == rgid) ||
513 (current->egid==rgid) ||
514 capable(CAP_SETGID))
515 new_rgid = rgid;
516 else
517 return -EPERM;
518 }
519 if (egid != (gid_t) -1) {
520 if ((old_rgid == egid) ||
521 (current->egid == egid) ||
522 (current->sgid == egid) ||
523 capable(CAP_SETGID))
524 new_egid = egid;
525 else {
526 return -EPERM;
527 }
528 }
529 if (new_egid != old_egid)
530 {
531 current->mm->dumpable = suid_dumpable;
532 smp_wmb();
533 }
534 if (rgid != (gid_t) -1 ||
535 (egid != (gid_t) -1 && egid != old_rgid))
536 current->sgid = new_egid;
537 current->fsgid = new_egid;
538 current->egid = new_egid;
539 current->gid = new_rgid;
540 key_fsgid_changed(current);
541 return 0;
542 }
543
544 /*
545 * setgid() is implemented like SysV w/ SAVED_IDS
546 *
547 * SMP: Same implicit races as above.
548 */
549 asmlinkage long sys_setgid(gid_t gid)
550 {
551 int old_egid = current->egid;
552 int retval;
553
554 retval = security_task_setgid(gid, (gid_t)-1, (gid_t)-1, LSM_SETID_ID);
555 if (retval)
556 return retval;
557
558 if (capable(CAP_SETGID))
559 {
560 if(old_egid != gid)
561 {
562 current->mm->dumpable = suid_dumpable;
563 smp_wmb();
564 }
565 current->gid = current->egid = current->sgid = current->fsgid = gid;
566 }
567 else if ((gid == current->gid) || (gid == current->sgid))
568 {
569 if(old_egid != gid)
570 {
571 current->mm->dumpable = suid_dumpable;
572 smp_wmb();
573 }
574 current->egid = current->fsgid = gid;
575 }
576 else
577 return -EPERM;
578
579 key_fsgid_changed(current);
580 return 0;
581 }
582
583 static int set_user(uid_t new_ruid, int dumpclear)
584 {
585 struct user_struct *new_user;
586
587 new_user = alloc_uid(new_ruid);
588 if (!new_user)
589 return -EAGAIN;
590
591 if (atomic_read(&new_user->processes) >=
592 current->signal->rlim[RLIMIT_NPROC].rlim_cur &&
593 new_user != &root_user) {
594 free_uid(new_user);
595 return -EAGAIN;
596 }
597
598 switch_uid(new_user);
599
600 if(dumpclear)
601 {
602 current->mm->dumpable = suid_dumpable;
603 smp_wmb();
604 }
605 current->uid = new_ruid;
606 return 0;
607 }
608
609 /*
610 * Unprivileged users may change the real uid to the effective uid
611 * or vice versa. (BSD-style)
612 *
613 * If you set the real uid at all, or set the effective uid to a value not
614 * equal to the real uid, then the saved uid is set to the new effective uid.
615 *
616 * This makes it possible for a setuid program to completely drop its
617 * privileges, which is often a useful assertion to make when you are doing
618 * a security audit over a program.
619 *
620 * The general idea is that a program which uses just setreuid() will be
621 * 100% compatible with BSD. A program which uses just setuid() will be
622 * 100% compatible with POSIX with saved IDs.
623 */
624 asmlinkage long sys_setreuid(uid_t ruid, uid_t euid)
625 {
626 int old_ruid, old_euid, old_suid, new_ruid, new_euid;
627 int retval;
628
629 retval = security_task_setuid(ruid, euid, (uid_t)-1, LSM_SETID_RE);
630 if (retval)
631 return retval;
632
633 new_ruid = old_ruid = current->uid;
634 new_euid = old_euid = current->euid;
635 old_suid = current->suid;
636
637 if (ruid != (uid_t) -1) {
638 new_ruid = ruid;
639 if ((old_ruid != ruid) &&
640 (current->euid != ruid) &&
641 !capable(CAP_SETUID))
642 return -EPERM;
643 }
644
645 if (euid != (uid_t) -1) {
646 new_euid = euid;
647 if ((old_ruid != euid) &&
648 (current->euid != euid) &&
649 (current->suid != euid) &&
650 !capable(CAP_SETUID))
651 return -EPERM;
652 }
653
654 if (new_ruid != old_ruid && set_user(new_ruid, new_euid != old_euid) < 0)
655 return -EAGAIN;
656
657 if (new_euid != old_euid)
658 {
659 current->mm->dumpable = suid_dumpable;
660 smp_wmb();
661 }
662 current->fsuid = current->euid = new_euid;
663 if (ruid != (uid_t) -1 ||
664 (euid != (uid_t) -1 && euid != old_ruid))
665 current->suid = current->euid;
666 current->fsuid = current->euid;
667
668 key_fsuid_changed(current);
669
670 return security_task_post_setuid(old_ruid, old_euid, old_suid, LSM_SETID_RE);
671 }
672
673
674
675 /*
676 * setuid() is implemented like SysV with SAVED_IDS
677 *
678 * Note that SAVED_ID's is deficient in that a setuid root program
679 * like sendmail, for example, cannot set its uid to be a normal
680 * user and then switch back, because if you're root, setuid() sets
681 * the saved uid too. If you don't like this, blame the bright people
682 * in the POSIX committee and/or USG. Note that the BSD-style setreuid()
683 * will allow a root program to temporarily drop privileges and be able to
684 * regain them by swapping the real and effective uid.
685 */
686 asmlinkage long sys_setuid(uid_t uid)
687 {
688 int old_euid = current->euid;
689 int old_ruid, old_suid, new_ruid, new_suid;
690 int retval;
691
692 retval = security_task_setuid(uid, (uid_t)-1, (uid_t)-1, LSM_SETID_ID);
693 if (retval)
694 return retval;
695
696 old_ruid = new_ruid = current->uid;
697 old_suid = current->suid;
698 new_suid = old_suid;
699
700 if (capable(CAP_SETUID)) {
701 if (uid != old_ruid && set_user(uid, old_euid != uid) < 0)
702 return -EAGAIN;
703 new_suid = uid;
704 } else if ((uid != current->uid) && (uid != new_suid))
705 return -EPERM;
706
707 if (old_euid != uid)
708 {
709 current->mm->dumpable = suid_dumpable;
710 smp_wmb();
711 }
712 current->fsuid = current->euid = uid;
713 current->suid = new_suid;
714
715 key_fsuid_changed(current);
716
717 return security_task_post_setuid(old_ruid, old_euid, old_suid, LSM_SETID_ID);
718 }
719
720
721 /*
722 * This function implements a generic ability to update ruid, euid,
723 * and suid. This allows you to implement the 4.4 compatible seteuid().
724 */
725 asmlinkage long sys_setresuid(uid_t ruid, uid_t euid, uid_t suid)
726 {
727 int old_ruid = current->uid;
728 int old_euid = current->euid;
729 int old_suid = current->suid;
730 int retval;
731
732 retval = security_task_setuid(ruid, euid, suid, LSM_SETID_RES);
733 if (retval)
734 return retval;
735
736 if (!capable(CAP_SETUID)) {
737 if ((ruid != (uid_t) -1) && (ruid != current->uid) &&
738 (ruid != current->euid) && (ruid != current->suid))
739 return -EPERM;
740 if ((euid != (uid_t) -1) && (euid != current->uid) &&
741 (euid != current->euid) && (euid != current->suid))
742 return -EPERM;
743 if ((suid != (uid_t) -1) && (suid != current->uid) &&
744 (suid != current->euid) && (suid != current->suid))
745 return -EPERM;
746 }
747 if (ruid != (uid_t) -1) {
748 if (ruid != current->uid && set_user(ruid, euid != current->euid) < 0)
749 return -EAGAIN;
750 }
751 if (euid != (uid_t) -1) {
752 if (euid != current->euid)
753 {
754 current->mm->dumpable = suid_dumpable;
755 smp_wmb();
756 }
757 current->euid = euid;
758 }
759 current->fsuid = current->euid;
760 if (suid != (uid_t) -1)
761 current->suid = suid;
762
763 key_fsuid_changed(current);
764
765 return security_task_post_setuid(old_ruid, old_euid, old_suid, LSM_SETID_RES);
766 }
767
768 asmlinkage long sys_getresuid(uid_t __user *ruid, uid_t __user *euid, uid_t __user *suid)
769 {
770 int retval;
771
772 if (!(retval = put_user(current->uid, ruid)) &&
773 !(retval = put_user(current->euid, euid)))
774 retval = put_user(current->suid, suid);
775
776 return retval;
777 }
778
779 /*
780 * Same as above, but for rgid, egid, sgid.
781 */
782 asmlinkage long sys_setresgid(gid_t rgid, gid_t egid, gid_t sgid)
783 {
784 int retval;
785
786 retval = security_task_setgid(rgid, egid, sgid, LSM_SETID_RES);
787 if (retval)
788 return retval;
789
790 if (!capable(CAP_SETGID)) {
791 if ((rgid != (gid_t) -1) && (rgid != current->gid) &&
792 (rgid != current->egid) && (rgid != current->sgid))
793 return -EPERM;
794 if ((egid != (gid_t) -1) && (egid != current->gid) &&
795 (egid != current->egid) && (egid != current->sgid))
796 return -EPERM;
797 if ((sgid != (gid_t) -1) && (sgid != current->gid) &&
798 (sgid != current->egid) && (sgid != current->sgid))
799 return -EPERM;
800 }
801 if (egid != (gid_t) -1) {
802 if (egid != current->egid)
803 {
804 current->mm->dumpable = suid_dumpable;
805 smp_wmb();
806 }
807 current->egid = egid;
808 }
809 current->fsgid = current->egid;
810 if (rgid != (gid_t) -1)
811 current->gid = rgid;
812 if (sgid != (gid_t) -1)
813 current->sgid = sgid;
814
815 key_fsgid_changed(current);
816 return 0;
817 }
818
819 asmlinkage long sys_getresgid(gid_t __user *rgid, gid_t __user *egid, gid_t __user *sgid)
820 {
821 int retval;
822
823 if (!(retval = put_user(current->gid, rgid)) &&
824 !(retval = put_user(current->egid, egid)))
825 retval = put_user(current->sgid, sgid);
826
827 return retval;
828 }
829
830
831 /*
832 * "setfsuid()" sets the fsuid - the uid used for filesystem checks. This
833 * is used for "access()" and for the NFS daemon (letting nfsd stay at
834 * whatever uid it wants to). It normally shadows "euid", except when
835 * explicitly set by setfsuid() or for access..
836 */
837 asmlinkage long sys_setfsuid(uid_t uid)
838 {
839 int old_fsuid;
840
841 old_fsuid = current->fsuid;
842 if (security_task_setuid(uid, (uid_t)-1, (uid_t)-1, LSM_SETID_FS))
843 return old_fsuid;
844
845 if (uid == current->uid || uid == current->euid ||
846 uid == current->suid || uid == current->fsuid ||
847 capable(CAP_SETUID))
848 {
849 if (uid != old_fsuid)
850 {
851 current->mm->dumpable = suid_dumpable;
852 smp_wmb();
853 }
854 current->fsuid = uid;
855 }
856
857 key_fsuid_changed(current);
858
859 security_task_post_setuid(old_fsuid, (uid_t)-1, (uid_t)-1, LSM_SETID_FS);
860
861 return old_fsuid;
862 }
863
864 /*
865 * Samma på svenska..
866 */
867 asmlinkage long sys_setfsgid(gid_t gid)
868 {
869 int old_fsgid;
870
871 old_fsgid = current->fsgid;
872 if (security_task_setgid(gid, (gid_t)-1, (gid_t)-1, LSM_SETID_FS))
873 return old_fsgid;
874
875 if (gid == current->gid || gid == current->egid ||
876 gid == current->sgid || gid == current->fsgid ||
877 capable(CAP_SETGID))
878 {
879 if (gid != old_fsgid)
880 {
881 current->mm->dumpable = suid_dumpable;
882 smp_wmb();
883 }
884 current->fsgid = gid;
885 key_fsgid_changed(current);
886 }
887 return old_fsgid;
888 }
889
890 asmlinkage long sys_times(struct tms __user * tbuf)
891 {
892 /*
893 * In the SMP world we might just be unlucky and have one of
894 * the times increment as we use it. Since the value is an
895 * atomically safe type this is just fine. Conceptually its
896 * as if the syscall took an instant longer to occur.
897 */
898 if (tbuf) {
899 struct tms tmp;
900 cputime_t utime, stime, cutime, cstime;
901
902 #ifdef CONFIG_SMP
903 if (thread_group_empty(current)) {
904 /*
905 * Single thread case without the use of any locks.
906 *
907 * We may race with release_task if two threads are
908 * executing. However, release task first adds up the
909 * counters (__exit_signal) before removing the task
910 * from the process tasklist (__unhash_process).
911 * __exit_signal also acquires and releases the
912 * siglock which results in the proper memory ordering
913 * so that the list modifications are always visible
914 * after the counters have been updated.
915 *
916 * If the counters have been updated by the second thread
917 * but the thread has not yet been removed from the list
918 * then the other branch will be executing which will
919 * block on tasklist_lock until the exit handling of the
920 * other task is finished.
921 *
922 * This also implies that the sighand->siglock cannot
923 * be held by another processor. So we can also
924 * skip acquiring that lock.
925 */
926 utime = cputime_add(current->signal->utime, current->utime);
927 stime = cputime_add(current->signal->utime, current->stime);
928 cutime = current->signal->cutime;
929 cstime = current->signal->cstime;
930 } else
931 #endif
932 {
933
934 /* Process with multiple threads */
935 struct task_struct *tsk = current;
936 struct task_struct *t;
937
938 read_lock(&tasklist_lock);
939 utime = tsk->signal->utime;
940 stime = tsk->signal->stime;
941 t = tsk;
942 do {
943 utime = cputime_add(utime, t->utime);
944 stime = cputime_add(stime, t->stime);
945 t = next_thread(t);
946 } while (t != tsk);
947
948 /*
949 * While we have tasklist_lock read-locked, no dying thread
950 * can be updating current->signal->[us]time. Instead,
951 * we got their counts included in the live thread loop.
952 * However, another thread can come in right now and
953 * do a wait call that updates current->signal->c[us]time.
954 * To make sure we always see that pair updated atomically,
955 * we take the siglock around fetching them.
956 */
957 spin_lock_irq(&tsk->sighand->siglock);
958 cutime = tsk->signal->cutime;
959 cstime = tsk->signal->cstime;
960 spin_unlock_irq(&tsk->sighand->siglock);
961 read_unlock(&tasklist_lock);
962 }
963 tmp.tms_utime = cputime_to_clock_t(utime);
964 tmp.tms_stime = cputime_to_clock_t(stime);
965 tmp.tms_cutime = cputime_to_clock_t(cutime);
966 tmp.tms_cstime = cputime_to_clock_t(cstime);
967 if (copy_to_user(tbuf, &tmp, sizeof(struct tms)))
968 return -EFAULT;
969 }
970 return (long) jiffies_64_to_clock_t(get_jiffies_64());
971 }
972
973 /*
974 * This needs some heavy checking ...
975 * I just haven't the stomach for it. I also don't fully
976 * understand sessions/pgrp etc. Let somebody who does explain it.
977 *
978 * OK, I think I have the protection semantics right.... this is really
979 * only important on a multi-user system anyway, to make sure one user
980 * can't send a signal to a process owned by another. -TYT, 12/12/91
981 *
982 * Auch. Had to add the 'did_exec' flag to conform completely to POSIX.
983 * LBT 04.03.94
984 */
985
986 asmlinkage long sys_setpgid(pid_t pid, pid_t pgid)
987 {
988 struct task_struct *p;
989 int err = -EINVAL;
990
991 if (!pid)
992 pid = current->pid;
993 if (!pgid)
994 pgid = pid;
995 if (pgid < 0)
996 return -EINVAL;
997
998 /* From this point forward we keep holding onto the tasklist lock
999 * so that our parent does not change from under us. -DaveM
1000 */
1001 write_lock_irq(&tasklist_lock);
1002
1003 err = -ESRCH;
1004 p = find_task_by_pid(pid);
1005 if (!p)
1006 goto out;
1007
1008 err = -EINVAL;
1009 if (!thread_group_leader(p))
1010 goto out;
1011
1012 if (p->parent == current || p->real_parent == current) {
1013 err = -EPERM;
1014 if (p->signal->session != current->signal->session)
1015 goto out;
1016 err = -EACCES;
1017 if (p->did_exec)
1018 goto out;
1019 } else {
1020 err = -ESRCH;
1021 if (p != current)
1022 goto out;
1023 }
1024
1025 err = -EPERM;
1026 if (p->signal->leader)
1027 goto out;
1028
1029 if (pgid != pid) {
1030 struct task_struct *p;
1031
1032 do_each_task_pid(pgid, PIDTYPE_PGID, p) {
1033 if (p->signal->session == current->signal->session)
1034 goto ok_pgid;
1035 } while_each_task_pid(pgid, PIDTYPE_PGID, p);
1036 goto out;
1037 }
1038
1039 ok_pgid:
1040 err = security_task_setpgid(p, pgid);
1041 if (err)
1042 goto out;
1043
1044 if (process_group(p) != pgid) {
1045 detach_pid(p, PIDTYPE_PGID);
1046 p->signal->pgrp = pgid;
1047 attach_pid(p, PIDTYPE_PGID, pgid);
1048 }
1049
1050 err = 0;
1051 out:
1052 /* All paths lead to here, thus we are safe. -DaveM */
1053 write_unlock_irq(&tasklist_lock);
1054 return err;
1055 }
1056
1057 asmlinkage long sys_getpgid(pid_t pid)
1058 {
1059 if (!pid) {
1060 return process_group(current);
1061 } else {
1062 int retval;
1063 struct task_struct *p;
1064
1065 read_lock(&tasklist_lock);
1066 p = find_task_by_pid(pid);
1067
1068 retval = -ESRCH;
1069 if (p) {
1070 retval = security_task_getpgid(p);
1071 if (!retval)
1072 retval = process_group(p);
1073 }
1074 read_unlock(&tasklist_lock);
1075 return retval;
1076 }
1077 }
1078
1079 #ifdef __ARCH_WANT_SYS_GETPGRP
1080
1081 asmlinkage long sys_getpgrp(void)
1082 {
1083 /* SMP - assuming writes are word atomic this is fine */
1084 return process_group(current);
1085 }
1086
1087 #endif
1088
1089 asmlinkage long sys_getsid(pid_t pid)
1090 {
1091 if (!pid) {
1092 return current->signal->session;
1093 } else {
1094 int retval;
1095 struct task_struct *p;
1096
1097 read_lock(&tasklist_lock);
1098 p = find_task_by_pid(pid);
1099
1100 retval = -ESRCH;
1101 if(p) {
1102 retval = security_task_getsid(p);
1103 if (!retval)
1104 retval = p->signal->session;
1105 }
1106 read_unlock(&tasklist_lock);
1107 return retval;
1108 }
1109 }
1110
1111 asmlinkage long sys_setsid(void)
1112 {
1113 struct pid *pid;
1114 int err = -EPERM;
1115
1116 if (!thread_group_leader(current))
1117 return -EINVAL;
1118
1119 down(&tty_sem);
1120 write_lock_irq(&tasklist_lock);
1121
1122 pid = find_pid(PIDTYPE_PGID, current->pid);
1123 if (pid)
1124 goto out;
1125
1126 current->signal->leader = 1;
1127 __set_special_pids(current->pid, current->pid);
1128 current->signal->tty = NULL;
1129 current->signal->tty_old_pgrp = 0;
1130 err = process_group(current);
1131 out:
1132 write_unlock_irq(&tasklist_lock);
1133 up(&tty_sem);
1134 return err;
1135 }
1136
1137 /*
1138 * Supplementary group IDs
1139 */
1140
1141 /* init to 2 - one for init_task, one to ensure it is never freed */
1142 struct group_info init_groups = { .usage = ATOMIC_INIT(2) };
1143
1144 struct group_info *groups_alloc(int gidsetsize)
1145 {
1146 struct group_info *group_info;
1147 int nblocks;
1148 int i;
1149
1150 nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;
1151 /* Make sure we always allocate at least one indirect block pointer */
1152 nblocks = nblocks ? : 1;
1153 group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);
1154 if (!group_info)
1155 return NULL;
1156 group_info->ngroups = gidsetsize;
1157 group_info->nblocks = nblocks;
1158 atomic_set(&group_info->usage, 1);
1159
1160 if (gidsetsize <= NGROUPS_SMALL) {
1161 group_info->blocks[0] = group_info->small_block;
1162 } else {
1163 for (i = 0; i < nblocks; i++) {
1164 gid_t *b;
1165 b = (void *)__get_free_page(GFP_USER);
1166 if (!b)
1167 goto out_undo_partial_alloc;
1168 group_info->blocks[i] = b;
1169 }
1170 }
1171 return group_info;
1172
1173 out_undo_partial_alloc:
1174 while (--i >= 0) {
1175 free_page((unsigned long)group_info->blocks[i]);
1176 }
1177 kfree(group_info);
1178 return NULL;
1179 }
1180
1181 EXPORT_SYMBOL(groups_alloc);
1182
1183 void groups_free(struct group_info *group_info)
1184 {
1185 if (group_info->blocks[0] != group_info->small_block) {
1186 int i;
1187 for (i = 0; i < group_info->nblocks; i++)
1188 free_page((unsigned long)group_info->blocks[i]);
1189 }
1190 kfree(group_info);
1191 }
1192
1193 EXPORT_SYMBOL(groups_free);
1194
1195 /* export the group_info to a user-space array */
1196 static int groups_to_user(gid_t __user *grouplist,
1197 struct group_info *group_info)
1198 {
1199 int i;
1200 int count = group_info->ngroups;
1201
1202 for (i = 0; i < group_info->nblocks; i++) {
1203 int cp_count = min(NGROUPS_PER_BLOCK, count);
1204 int off = i * NGROUPS_PER_BLOCK;
1205 int len = cp_count * sizeof(*grouplist);
1206
1207 if (copy_to_user(grouplist+off, group_info->blocks[i], len))
1208 return -EFAULT;
1209
1210 count -= cp_count;
1211 }
1212 return 0;
1213 }
1214
1215 /* fill a group_info from a user-space array - it must be allocated already */
1216 static int groups_from_user(struct group_info *group_info,
1217 gid_t __user *grouplist)
1218 {
1219 int i;
1220 int count = group_info->ngroups;
1221
1222 for (i = 0; i < group_info->nblocks; i++) {
1223 int cp_count = min(NGROUPS_PER_BLOCK, count);
1224 int off = i * NGROUPS_PER_BLOCK;
1225 int len = cp_count * sizeof(*grouplist);
1226
1227 if (copy_from_user(group_info->blocks[i], grouplist+off, len))
1228 return -EFAULT;
1229
1230 count -= cp_count;
1231 }
1232 return 0;
1233 }
1234
1235 /* a simple Shell sort */
1236 static void groups_sort(struct group_info *group_info)
1237 {
1238 int base, max, stride;
1239 int gidsetsize = group_info->ngroups;
1240
1241 for (stride = 1; stride < gidsetsize; stride = 3 * stride + 1)
1242 ; /* nothing */
1243 stride /= 3;
1244
1245 while (stride) {
1246 max = gidsetsize - stride;
1247 for (base = 0; base < max; base++) {
1248 int left = base;
1249 int right = left + stride;
1250 gid_t tmp = GROUP_AT(group_info, right);
1251
1252 while (left >= 0 && GROUP_AT(group_info, left) > tmp) {
1253 GROUP_AT(group_info, right) =
1254 GROUP_AT(group_info, left);
1255 right = left;
1256 left -= stride;
1257 }
1258 GROUP_AT(group_info, right) = tmp;
1259 }
1260 stride /= 3;
1261 }
1262 }
1263
1264 /* a simple bsearch */
1265 int groups_search(struct group_info *group_info, gid_t grp)
1266 {
1267 int left, right;
1268
1269 if (!group_info)
1270 return 0;
1271
1272 left = 0;
1273 right = group_info->ngroups;
1274 while (left < right) {
1275 int mid = (left+right)/2;
1276 int cmp = grp - GROUP_AT(group_info, mid);
1277 if (cmp > 0)
1278 left = mid + 1;
1279 else if (cmp < 0)
1280 right = mid;
1281 else
1282 return 1;
1283 }
1284 return 0;
1285 }
1286
1287 /* validate and set current->group_info */
1288 int set_current_groups(struct group_info *group_info)
1289 {
1290 int retval;
1291 struct group_info *old_info;
1292
1293 retval = security_task_setgroups(group_info);
1294 if (retval)
1295 return retval;
1296
1297 groups_sort(group_info);
1298 get_group_info(group_info);
1299
1300 task_lock(current);
1301 old_info = current->group_info;
1302 current->group_info = group_info;
1303 task_unlock(current);
1304
1305 put_group_info(old_info);
1306
1307 return 0;
1308 }
1309
1310 EXPORT_SYMBOL(set_current_groups);
1311
1312 asmlinkage long sys_getgroups(int gidsetsize, gid_t __user *grouplist)
1313 {
1314 int i = 0;
1315
1316 /*
1317 * SMP: Nobody else can change our grouplist. Thus we are
1318 * safe.
1319 */
1320
1321 if (gidsetsize < 0)
1322 return -EINVAL;
1323
1324 /* no need to grab task_lock here; it cannot change */
1325 get_group_info(current->group_info);
1326 i = current->group_info->ngroups;
1327 if (gidsetsize) {
1328 if (i > gidsetsize) {
1329 i = -EINVAL;
1330 goto out;
1331 }
1332 if (groups_to_user(grouplist, current->group_info)) {
1333 i = -EFAULT;
1334 goto out;
1335 }
1336 }
1337 out:
1338 put_group_info(current->group_info);
1339 return i;
1340 }
1341
1342 /*
1343 * SMP: Our groups are copy-on-write. We can set them safely
1344 * without another task interfering.
1345 */
1346
1347 asmlinkage long sys_setgroups(int gidsetsize, gid_t __user *grouplist)
1348 {
1349 struct group_info *group_info;
1350 int retval;
1351
1352 if (!capable(CAP_SETGID))
1353 return -EPERM;
1354 if ((unsigned)gidsetsize > NGROUPS_MAX)
1355 return -EINVAL;
1356
1357 group_info = groups_alloc(gidsetsize);
1358 if (!group_info)
1359 return -ENOMEM;
1360 retval = groups_from_user(group_info, grouplist);
1361 if (retval) {
1362 put_group_info(group_info);
1363 return retval;
1364 }
1365
1366 retval = set_current_groups(group_info);
1367 put_group_info(group_info);
1368
1369 return retval;
1370 }
1371
1372 /*
1373 * Check whether we're fsgid/egid or in the supplemental group..
1374 */
1375 int in_group_p(gid_t grp)
1376 {
1377 int retval = 1;
1378 if (grp != current->fsgid) {
1379 get_group_info(current->group_info);
1380 retval = groups_search(current->group_info, grp);
1381 put_group_info(current->group_info);
1382 }
1383 return retval;
1384 }
1385
1386 EXPORT_SYMBOL(in_group_p);
1387
1388 int in_egroup_p(gid_t grp)
1389 {
1390 int retval = 1;
1391 if (grp != current->egid) {
1392 get_group_info(current->group_info);
1393 retval = groups_search(current->group_info, grp);
1394 put_group_info(current->group_info);
1395 }
1396 return retval;
1397 }
1398
1399 EXPORT_SYMBOL(in_egroup_p);
1400
1401 DECLARE_RWSEM(uts_sem);
1402
1403 EXPORT_SYMBOL(uts_sem);
1404
1405 asmlinkage long sys_newuname(struct new_utsname __user * name)
1406 {
1407 int errno = 0;
1408
1409 down_read(&uts_sem);
1410 if (copy_to_user(name,&system_utsname,sizeof *name))
1411 errno = -EFAULT;
1412 up_read(&uts_sem);
1413 return errno;
1414 }
1415
1416 asmlinkage long sys_sethostname(char __user *name, int len)
1417 {
1418 int errno;
1419 char tmp[__NEW_UTS_LEN];
1420
1421 if (!capable(CAP_SYS_ADMIN))
1422 return -EPERM;
1423 if (len < 0 || len > __NEW_UTS_LEN)
1424 return -EINVAL;
1425 down_write(&uts_sem);
1426 errno = -EFAULT;
1427 if (!copy_from_user(tmp, name, len)) {
1428 memcpy(system_utsname.nodename, tmp, len);
1429 system_utsname.nodename[len] = 0;
1430 errno = 0;
1431 }
1432 up_write(&uts_sem);
1433 return errno;
1434 }
1435
1436 #ifdef __ARCH_WANT_SYS_GETHOSTNAME
1437
1438 asmlinkage long sys_gethostname(char __user *name, int len)
1439 {
1440 int i, errno;
1441
1442 if (len < 0)
1443 return -EINVAL;
1444 down_read(&uts_sem);
1445 i = 1 + strlen(system_utsname.nodename);
1446 if (i > len)
1447 i = len;
1448 errno = 0;
1449 if (copy_to_user(name, system_utsname.nodename, i))
1450 errno = -EFAULT;
1451 up_read(&uts_sem);
1452 return errno;
1453 }
1454
1455 #endif
1456
1457 /*
1458 * Only setdomainname; getdomainname can be implemented by calling
1459 * uname()
1460 */
1461 asmlinkage long sys_setdomainname(char __user *name, int len)
1462 {
1463 int errno;
1464 char tmp[__NEW_UTS_LEN];
1465
1466 if (!capable(CAP_SYS_ADMIN))
1467 return -EPERM;
1468 if (len < 0 || len > __NEW_UTS_LEN)
1469 return -EINVAL;
1470
1471 down_write(&uts_sem);
1472 errno = -EFAULT;
1473 if (!copy_from_user(tmp, name, len)) {
1474 memcpy(system_utsname.domainname, tmp, len);
1475 system_utsname.domainname[len] = 0;
1476 errno = 0;
1477 }
1478 up_write(&uts_sem);
1479 return errno;
1480 }
1481
1482 asmlinkage long sys_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 asmlinkage long sys_old_getrlimit(unsigned int resource, struct rlimit __user *rlim)
1502 {
1503 struct rlimit x;
1504 if (resource >= RLIM_NLIMITS)
1505 return -EINVAL;
1506
1507 task_lock(current->group_leader);
1508 x = current->signal->rlim[resource];
1509 task_unlock(current->group_leader);
1510 if(x.rlim_cur > 0x7FFFFFFF)
1511 x.rlim_cur = 0x7FFFFFFF;
1512 if(x.rlim_max > 0x7FFFFFFF)
1513 x.rlim_max = 0x7FFFFFFF;
1514 return copy_to_user(rlim, &x, sizeof(x))?-EFAULT:0;
1515 }
1516
1517 #endif
1518
1519 asmlinkage long sys_setrlimit(unsigned int resource, struct rlimit __user *rlim)
1520 {
1521 struct rlimit new_rlim, *old_rlim;
1522 int retval;
1523
1524 if (resource >= RLIM_NLIMITS)
1525 return -EINVAL;
1526 if(copy_from_user(&new_rlim, rlim, sizeof(*rlim)))
1527 return -EFAULT;
1528 if (new_rlim.rlim_cur > new_rlim.rlim_max)
1529 return -EINVAL;
1530 old_rlim = current->signal->rlim + resource;
1531 if ((new_rlim.rlim_max > old_rlim->rlim_max) &&
1532 !capable(CAP_SYS_RESOURCE))
1533 return -EPERM;
1534 if (resource == RLIMIT_NOFILE && new_rlim.rlim_max > NR_OPEN)
1535 return -EPERM;
1536
1537 retval = security_task_setrlimit(resource, &new_rlim);
1538 if (retval)
1539 return retval;
1540
1541 task_lock(current->group_leader);
1542 *old_rlim = new_rlim;
1543 task_unlock(current->group_leader);
1544
1545 if (resource == RLIMIT_CPU && new_rlim.rlim_cur != RLIM_INFINITY &&
1546 (cputime_eq(current->signal->it_prof_expires, cputime_zero) ||
1547 new_rlim.rlim_cur <= cputime_to_secs(
1548 current->signal->it_prof_expires))) {
1549 cputime_t cputime = secs_to_cputime(new_rlim.rlim_cur);
1550 read_lock(&tasklist_lock);
1551 spin_lock_irq(&current->sighand->siglock);
1552 set_process_cpu_timer(current, CPUCLOCK_PROF,
1553 &cputime, NULL);
1554 spin_unlock_irq(&current->sighand->siglock);
1555 read_unlock(&tasklist_lock);
1556 }
1557
1558 return 0;
1559 }
1560
1561 /*
1562 * It would make sense to put struct rusage in the task_struct,
1563 * except that would make the task_struct be *really big*. After
1564 * task_struct gets moved into malloc'ed memory, it would
1565 * make sense to do this. It will make moving the rest of the information
1566 * a lot simpler! (Which we're not doing right now because we're not
1567 * measuring them yet).
1568 *
1569 * This expects to be called with tasklist_lock read-locked or better,
1570 * and the siglock not locked. It may momentarily take the siglock.
1571 *
1572 * When sampling multiple threads for RUSAGE_SELF, under SMP we might have
1573 * races with threads incrementing their own counters. But since word
1574 * reads are atomic, we either get new values or old values and we don't
1575 * care which for the sums. We always take the siglock to protect reading
1576 * the c* fields from p->signal from races with exit.c updating those
1577 * fields when reaping, so a sample either gets all the additions of a
1578 * given child after it's reaped, or none so this sample is before reaping.
1579 */
1580
1581 static void k_getrusage(struct task_struct *p, int who, struct rusage *r)
1582 {
1583 struct task_struct *t;
1584 unsigned long flags;
1585 cputime_t utime, stime;
1586
1587 memset((char *) r, 0, sizeof *r);
1588
1589 if (unlikely(!p->signal))
1590 return;
1591
1592 switch (who) {
1593 case RUSAGE_CHILDREN:
1594 spin_lock_irqsave(&p->sighand->siglock, flags);
1595 utime = p->signal->cutime;
1596 stime = p->signal->cstime;
1597 r->ru_nvcsw = p->signal->cnvcsw;
1598 r->ru_nivcsw = p->signal->cnivcsw;
1599 r->ru_minflt = p->signal->cmin_flt;
1600 r->ru_majflt = p->signal->cmaj_flt;
1601 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1602 cputime_to_timeval(utime, &r->ru_utime);
1603 cputime_to_timeval(stime, &r->ru_stime);
1604 break;
1605 case RUSAGE_SELF:
1606 spin_lock_irqsave(&p->sighand->siglock, flags);
1607 utime = stime = cputime_zero;
1608 goto sum_group;
1609 case RUSAGE_BOTH:
1610 spin_lock_irqsave(&p->sighand->siglock, flags);
1611 utime = p->signal->cutime;
1612 stime = p->signal->cstime;
1613 r->ru_nvcsw = p->signal->cnvcsw;
1614 r->ru_nivcsw = p->signal->cnivcsw;
1615 r->ru_minflt = p->signal->cmin_flt;
1616 r->ru_majflt = p->signal->cmaj_flt;
1617 sum_group:
1618 utime = cputime_add(utime, p->signal->utime);
1619 stime = cputime_add(stime, p->signal->stime);
1620 r->ru_nvcsw += p->signal->nvcsw;
1621 r->ru_nivcsw += p->signal->nivcsw;
1622 r->ru_minflt += p->signal->min_flt;
1623 r->ru_majflt += p->signal->maj_flt;
1624 t = p;
1625 do {
1626 utime = cputime_add(utime, t->utime);
1627 stime = cputime_add(stime, t->stime);
1628 r->ru_nvcsw += t->nvcsw;
1629 r->ru_nivcsw += t->nivcsw;
1630 r->ru_minflt += t->min_flt;
1631 r->ru_majflt += t->maj_flt;
1632 t = next_thread(t);
1633 } while (t != p);
1634 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1635 cputime_to_timeval(utime, &r->ru_utime);
1636 cputime_to_timeval(stime, &r->ru_stime);
1637 break;
1638 default:
1639 BUG();
1640 }
1641 }
1642
1643 int getrusage(struct task_struct *p, int who, struct rusage __user *ru)
1644 {
1645 struct rusage r;
1646 read_lock(&tasklist_lock);
1647 k_getrusage(p, who, &r);
1648 read_unlock(&tasklist_lock);
1649 return copy_to_user(ru, &r, sizeof(r)) ? -EFAULT : 0;
1650 }
1651
1652 asmlinkage long sys_getrusage(int who, struct rusage __user *ru)
1653 {
1654 if (who != RUSAGE_SELF && who != RUSAGE_CHILDREN)
1655 return -EINVAL;
1656 return getrusage(current, who, ru);
1657 }
1658
1659 asmlinkage long sys_umask(int mask)
1660 {
1661 mask = xchg(&current->fs->umask, mask & S_IRWXUGO);
1662 return mask;
1663 }
1664
1665 asmlinkage long sys_prctl(int option, unsigned long arg2, unsigned long arg3,
1666 unsigned long arg4, unsigned long arg5)
1667 {
1668 long error;
1669 int sig;
1670
1671 error = security_task_prctl(option, arg2, arg3, arg4, arg5);
1672 if (error)
1673 return error;
1674
1675 switch (option) {
1676 case PR_SET_PDEATHSIG:
1677 sig = arg2;
1678 if (!valid_signal(sig)) {
1679 error = -EINVAL;
1680 break;
1681 }
1682 current->pdeath_signal = sig;
1683 break;
1684 case PR_GET_PDEATHSIG:
1685 error = put_user(current->pdeath_signal, (int __user *)arg2);
1686 break;
1687 case PR_GET_DUMPABLE:
1688 if (current->mm->dumpable)
1689 error = 1;
1690 break;
1691 case PR_SET_DUMPABLE:
1692 if (arg2 < 0 || arg2 > 2) {
1693 error = -EINVAL;
1694 break;
1695 }
1696 current->mm->dumpable = arg2;
1697 break;
1698
1699 case PR_SET_UNALIGN:
1700 error = SET_UNALIGN_CTL(current, arg2);
1701 break;
1702 case PR_GET_UNALIGN:
1703 error = GET_UNALIGN_CTL(current, arg2);
1704 break;
1705 case PR_SET_FPEMU:
1706 error = SET_FPEMU_CTL(current, arg2);
1707 break;
1708 case PR_GET_FPEMU:
1709 error = GET_FPEMU_CTL(current, arg2);
1710 break;
1711 case PR_SET_FPEXC:
1712 error = SET_FPEXC_CTL(current, arg2);
1713 break;
1714 case PR_GET_FPEXC:
1715 error = GET_FPEXC_CTL(current, arg2);
1716 break;
1717 case PR_GET_TIMING:
1718 error = PR_TIMING_STATISTICAL;
1719 break;
1720 case PR_SET_TIMING:
1721 if (arg2 == PR_TIMING_STATISTICAL)
1722 error = 0;
1723 else
1724 error = -EINVAL;
1725 break;
1726
1727 case PR_GET_KEEPCAPS:
1728 if (current->keep_capabilities)
1729 error = 1;
1730 break;
1731 case PR_SET_KEEPCAPS:
1732 if (arg2 != 0 && arg2 != 1) {
1733 error = -EINVAL;
1734 break;
1735 }
1736 current->keep_capabilities = arg2;
1737 break;
1738 case PR_SET_NAME: {
1739 struct task_struct *me = current;
1740 unsigned char ncomm[sizeof(me->comm)];
1741
1742 ncomm[sizeof(me->comm)-1] = 0;
1743 if (strncpy_from_user(ncomm, (char __user *)arg2,
1744 sizeof(me->comm)-1) < 0)
1745 return -EFAULT;
1746 set_task_comm(me, ncomm);
1747 return 0;
1748 }
1749 case PR_GET_NAME: {
1750 struct task_struct *me = current;
1751 unsigned char tcomm[sizeof(me->comm)];
1752
1753 get_task_comm(tcomm, me);
1754 if (copy_to_user((char __user *)arg2, tcomm, sizeof(tcomm)))
1755 return -EFAULT;
1756 return 0;
1757 }
1758 default:
1759 error = -EINVAL;
1760 break;
1761 }
1762 return error;
1763 }
WandBoard kernel