1
2
3
4
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/notifier.h>
12#include <linux/reboot.h>
13#include <linux/prctl.h>
14#include <linux/highuid.h>
15#include <linux/fs.h>
16#include <linux/perf_event.h>
17#include <linux/resource.h>
18#include <linux/kernel.h>
19#include <linux/kexec.h>
20#include <linux/workqueue.h>
21#include <linux/capability.h>
22#include <linux/device.h>
23#include <linux/key.h>
24#include <linux/times.h>
25#include <linux/posix-timers.h>
26#include <linux/security.h>
27#include <linux/dcookies.h>
28#include <linux/suspend.h>
29#include <linux/tty.h>
30#include <linux/signal.h>
31#include <linux/cn_proc.h>
32#include <linux/getcpu.h>
33#include <linux/task_io_accounting_ops.h>
34#include <linux/seccomp.h>
35#include <linux/cpu.h>
36#include <linux/personality.h>
37#include <linux/ptrace.h>
38#include <linux/fs_struct.h>
39#include <linux/gfp.h>
40
41#include <linux/compat.h>
42#include <linux/syscalls.h>
43#include <linux/kprobes.h>
44#include <linux/user_namespace.h>
45
46#include <linux/kmsg_dump.h>
47
48#include <asm/uaccess.h>
49#include <asm/io.h>
50#include <asm/unistd.h>
51
52#ifndef SET_UNALIGN_CTL
53# define SET_UNALIGN_CTL(a,b) (-EINVAL)
54#endif
55#ifndef GET_UNALIGN_CTL
56# define GET_UNALIGN_CTL(a,b) (-EINVAL)
57#endif
58#ifndef SET_FPEMU_CTL
59# define SET_FPEMU_CTL(a,b) (-EINVAL)
60#endif
61#ifndef GET_FPEMU_CTL
62# define GET_FPEMU_CTL(a,b) (-EINVAL)
63#endif
64#ifndef SET_FPEXC_CTL
65# define SET_FPEXC_CTL(a,b) (-EINVAL)
66#endif
67#ifndef GET_FPEXC_CTL
68# define GET_FPEXC_CTL(a,b) (-EINVAL)
69#endif
70#ifndef GET_ENDIAN
71# define GET_ENDIAN(a,b) (-EINVAL)
72#endif
73#ifndef SET_ENDIAN
74# define SET_ENDIAN(a,b) (-EINVAL)
75#endif
76#ifndef GET_TSC_CTL
77# define GET_TSC_CTL(a) (-EINVAL)
78#endif
79#ifndef SET_TSC_CTL
80# define SET_TSC_CTL(a) (-EINVAL)
81#endif
82
83
84
85
86
87
88int overflowuid = DEFAULT_OVERFLOWUID;
89int overflowgid = DEFAULT_OVERFLOWGID;
90
91#ifdef CONFIG_UID16
92EXPORT_SYMBOL(overflowuid);
93EXPORT_SYMBOL(overflowgid);
94#endif
95
96
97
98
99
100
101int fs_overflowuid = DEFAULT_FS_OVERFLOWUID;
102int fs_overflowgid = DEFAULT_FS_OVERFLOWUID;
103
104EXPORT_SYMBOL(fs_overflowuid);
105EXPORT_SYMBOL(fs_overflowgid);
106
107
108
109
110
111int C_A_D = 1;
112struct pid *cad_pid;
113EXPORT_SYMBOL(cad_pid);
114
115
116
117
118
119void (*pm_power_off_prepare)(void);
120
121
122
123
124
125static int set_one_prio(struct task_struct *p, int niceval, int error)
126{
127 const struct cred *cred = current_cred(), *pcred = __task_cred(p);
128 int no_nice;
129
130 if (pcred->uid != cred->euid &&
131 pcred->euid != cred->euid && !capable(CAP_SYS_NICE)) {
132 error = -EPERM;
133 goto out;
134 }
135 if (niceval < task_nice(p) && !can_nice(p, niceval)) {
136 error = -EACCES;
137 goto out;
138 }
139 no_nice = security_task_setnice(p, niceval);
140 if (no_nice) {
141 error = no_nice;
142 goto out;
143 }
144 if (error == -ESRCH)
145 error = 0;
146 set_user_nice(p, niceval);
147out:
148 return error;
149}
150
151SYSCALL_DEFINE3(setpriority, int, which, int, who, int, niceval)
152{
153 struct task_struct *g, *p;
154 struct user_struct *user;
155 const struct cred *cred = current_cred();
156 int error = -EINVAL;
157 struct pid *pgrp;
158
159 if (which > PRIO_USER || which < PRIO_PROCESS)
160 goto out;
161
162
163 error = -ESRCH;
164 if (niceval < -20)
165 niceval = -20;
166 if (niceval > 19)
167 niceval = 19;
168
169 rcu_read_lock();
170 read_lock(&tasklist_lock);
171 switch (which) {
172 case PRIO_PROCESS:
173 if (who)
174 p = find_task_by_vpid(who);
175 else
176 p = current;
177 if (p)
178 error = set_one_prio(p, niceval, error);
179 break;
180 case PRIO_PGRP:
181 if (who)
182 pgrp = find_vpid(who);
183 else
184 pgrp = task_pgrp(current);
185 do_each_pid_thread(pgrp, PIDTYPE_PGID, p) {
186 error = set_one_prio(p, niceval, error);
187 } while_each_pid_thread(pgrp, PIDTYPE_PGID, p);
188 break;
189 case PRIO_USER:
190 user = (struct user_struct *) cred->user;
191 if (!who)
192 who = cred->uid;
193 else if ((who != cred->uid) &&
194 !(user = find_user(who)))
195 goto out_unlock;
196
197 do_each_thread(g, p) {
198 if (__task_cred(p)->uid == who)
199 error = set_one_prio(p, niceval, error);
200 } while_each_thread(g, p);
201 if (who != cred->uid)
202 free_uid(user);
203 break;
204 }
205out_unlock:
206 read_unlock(&tasklist_lock);
207 rcu_read_unlock();
208out:
209 return error;
210}
211
212
213
214
215
216
217
218SYSCALL_DEFINE2(getpriority, int, which, int, who)
219{
220 struct task_struct *g, *p;
221 struct user_struct *user;
222 const struct cred *cred = current_cred();
223 long niceval, retval = -ESRCH;
224 struct pid *pgrp;
225
226 if (which > PRIO_USER || which < PRIO_PROCESS)
227 return -EINVAL;
228
229 rcu_read_lock();
230 read_lock(&tasklist_lock);
231 switch (which) {
232 case PRIO_PROCESS:
233 if (who)
234 p = find_task_by_vpid(who);
235 else
236 p = current;
237 if (p) {
238 niceval = 20 - task_nice(p);
239 if (niceval > retval)
240 retval = niceval;
241 }
242 break;
243 case PRIO_PGRP:
244 if (who)
245 pgrp = find_vpid(who);
246 else
247 pgrp = task_pgrp(current);
248 do_each_pid_thread(pgrp, PIDTYPE_PGID, p) {
249 niceval = 20 - task_nice(p);
250 if (niceval > retval)
251 retval = niceval;
252 } while_each_pid_thread(pgrp, PIDTYPE_PGID, p);
253 break;
254 case PRIO_USER:
255 user = (struct user_struct *) cred->user;
256 if (!who)
257 who = cred->uid;
258 else if ((who != cred->uid) &&
259 !(user = find_user(who)))
260 goto out_unlock;
261
262 do_each_thread(g, p) {
263 if (__task_cred(p)->uid == who) {
264 niceval = 20 - task_nice(p);
265 if (niceval > retval)
266 retval = niceval;
267 }
268 } while_each_thread(g, p);
269 if (who != cred->uid)
270 free_uid(user);
271 break;
272 }
273out_unlock:
274 read_unlock(&tasklist_lock);
275 rcu_read_unlock();
276
277 return retval;
278}
279
280
281
282
283
284
285
286
287
288void emergency_restart(void)
289{
290 kmsg_dump(KMSG_DUMP_EMERG);
291 machine_emergency_restart();
292}
293EXPORT_SYMBOL_GPL(emergency_restart);
294
295void kernel_restart_prepare(char *cmd)
296{
297 blocking_notifier_call_chain(&reboot_notifier_list, SYS_RESTART, cmd);
298 system_state = SYSTEM_RESTART;
299 device_shutdown();
300 sysdev_shutdown();
301}
302
303
304
305
306
307
308
309
310
311void kernel_restart(char *cmd)
312{
313 kernel_restart_prepare(cmd);
314 if (!cmd)
315 printk(KERN_EMERG "Restarting system.\n");
316 else
317 printk(KERN_EMERG "Restarting system with command '%s'.\n", cmd);
318 kmsg_dump(KMSG_DUMP_RESTART);
319 machine_restart(cmd);
320}
321EXPORT_SYMBOL_GPL(kernel_restart);
322
323static void kernel_shutdown_prepare(enum system_states state)
324{
325 blocking_notifier_call_chain(&reboot_notifier_list,
326 (state == SYSTEM_HALT)?SYS_HALT:SYS_POWER_OFF, NULL);
327 system_state = state;
328 device_shutdown();
329}
330
331
332
333
334
335void kernel_halt(void)
336{
337 kernel_shutdown_prepare(SYSTEM_HALT);
338 sysdev_shutdown();
339 printk(KERN_EMERG "System halted.\n");
340 kmsg_dump(KMSG_DUMP_HALT);
341 machine_halt();
342}
343
344EXPORT_SYMBOL_GPL(kernel_halt);
345
346
347
348
349
350
351void kernel_power_off(void)
352{
353 kernel_shutdown_prepare(SYSTEM_POWER_OFF);
354 if (pm_power_off_prepare)
355 pm_power_off_prepare();
356 disable_nonboot_cpus();
357 sysdev_shutdown();
358 printk(KERN_EMERG "Power down.\n");
359 kmsg_dump(KMSG_DUMP_POWEROFF);
360 machine_power_off();
361}
362EXPORT_SYMBOL_GPL(kernel_power_off);
363
364static DEFINE_MUTEX(reboot_mutex);
365
366
367
368
369
370
371
372
373
374SYSCALL_DEFINE4(reboot, int, magic1, int, magic2, unsigned int, cmd,
375 void __user *, arg)
376{
377 char buffer[256];
378 int ret = 0;
379
380
381 if (!capable(CAP_SYS_BOOT))
382 return -EPERM;
383
384
385 if (magic1 != LINUX_REBOOT_MAGIC1 ||
386 (magic2 != LINUX_REBOOT_MAGIC2 &&
387 magic2 != LINUX_REBOOT_MAGIC2A &&
388 magic2 != LINUX_REBOOT_MAGIC2B &&
389 magic2 != LINUX_REBOOT_MAGIC2C))
390 return -EINVAL;
391
392
393
394
395 if ((cmd == LINUX_REBOOT_CMD_POWER_OFF) && !pm_power_off)
396 cmd = LINUX_REBOOT_CMD_HALT;
397
398 mutex_lock(&reboot_mutex);
399 switch (cmd) {
400 case LINUX_REBOOT_CMD_RESTART:
401 kernel_restart(NULL);
402 break;
403
404 case LINUX_REBOOT_CMD_CAD_ON:
405 C_A_D = 1;
406 break;
407
408 case LINUX_REBOOT_CMD_CAD_OFF:
409 C_A_D = 0;
410 break;
411
412 case LINUX_REBOOT_CMD_HALT:
413 kernel_halt();
414 do_exit(0);
415 panic("cannot halt");
416
417 case LINUX_REBOOT_CMD_POWER_OFF:
418 kernel_power_off();
419 do_exit(0);
420 break;
421
422 case LINUX_REBOOT_CMD_RESTART2:
423 if (strncpy_from_user(&buffer[0], arg, sizeof(buffer) - 1) < 0) {
424 ret = -EFAULT;
425 break;
426 }
427 buffer[sizeof(buffer) - 1] = '\0';
428
429 kernel_restart(buffer);
430 break;
431
432#ifdef CONFIG_KEXEC
433 case LINUX_REBOOT_CMD_KEXEC:
434 ret = kernel_kexec();
435 break;
436#endif
437
438#ifdef CONFIG_HIBERNATION
439 case LINUX_REBOOT_CMD_SW_SUSPEND:
440 ret = hibernate();
441 break;
442#endif
443
444 default:
445 ret = -EINVAL;
446 break;
447 }
448 mutex_unlock(&reboot_mutex);
449 return ret;
450}
451
452static void deferred_cad(struct work_struct *dummy)
453{
454 kernel_restart(NULL);
455}
456
457
458
459
460
461
462void ctrl_alt_del(void)
463{
464 static DECLARE_WORK(cad_work, deferred_cad);
465
466 if (C_A_D)
467 schedule_work(&cad_work);
468 else
469 kill_cad_pid(SIGINT, 1);
470}
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490SYSCALL_DEFINE2(setregid, gid_t, rgid, gid_t, egid)
491{
492 const struct cred *old;
493 struct cred *new;
494 int retval;
495
496 new = prepare_creds();
497 if (!new)
498 return -ENOMEM;
499 old = current_cred();
500
501 retval = -EPERM;
502 if (rgid != (gid_t) -1) {
503 if (old->gid == rgid ||
504 old->egid == rgid ||
505 capable(CAP_SETGID))
506 new->gid = rgid;
507 else
508 goto error;
509 }
510 if (egid != (gid_t) -1) {
511 if (old->gid == egid ||
512 old->egid == egid ||
513 old->sgid == egid ||
514 capable(CAP_SETGID))
515 new->egid = egid;
516 else
517 goto error;
518 }
519
520 if (rgid != (gid_t) -1 ||
521 (egid != (gid_t) -1 && egid != old->gid))
522 new->sgid = new->egid;
523 new->fsgid = new->egid;
524
525 return commit_creds(new);
526
527error:
528 abort_creds(new);
529 return retval;
530}
531
532
533
534
535
536
537SYSCALL_DEFINE1(setgid, gid_t, gid)
538{
539 const struct cred *old;
540 struct cred *new;
541 int retval;
542
543 new = prepare_creds();
544 if (!new)
545 return -ENOMEM;
546 old = current_cred();
547
548 retval = -EPERM;
549 if (capable(CAP_SETGID))
550 new->gid = new->egid = new->sgid = new->fsgid = gid;
551 else if (gid == old->gid || gid == old->sgid)
552 new->egid = new->fsgid = gid;
553 else
554 goto error;
555
556 return commit_creds(new);
557
558error:
559 abort_creds(new);
560 return retval;
561}
562
563
564
565
566static int set_user(struct cred *new)
567{
568 struct user_struct *new_user;
569
570 new_user = alloc_uid(current_user_ns(), new->uid);
571 if (!new_user)
572 return -EAGAIN;
573
574 if (atomic_read(&new_user->processes) >= rlimit(RLIMIT_NPROC) &&
575 new_user != INIT_USER) {
576 free_uid(new_user);
577 return -EAGAIN;
578 }
579
580 free_uid(new->user);
581 new->user = new_user;
582 return 0;
583}
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600SYSCALL_DEFINE2(setreuid, uid_t, ruid, uid_t, euid)
601{
602 const struct cred *old;
603 struct cred *new;
604 int retval;
605
606 new = prepare_creds();
607 if (!new)
608 return -ENOMEM;
609 old = current_cred();
610
611 retval = -EPERM;
612 if (ruid != (uid_t) -1) {
613 new->uid = ruid;
614 if (old->uid != ruid &&
615 old->euid != ruid &&
616 !capable(CAP_SETUID))
617 goto error;
618 }
619
620 if (euid != (uid_t) -1) {
621 new->euid = euid;
622 if (old->uid != euid &&
623 old->euid != euid &&
624 old->suid != euid &&
625 !capable(CAP_SETUID))
626 goto error;
627 }
628
629 if (new->uid != old->uid) {
630 retval = set_user(new);
631 if (retval < 0)
632 goto error;
633 }
634 if (ruid != (uid_t) -1 ||
635 (euid != (uid_t) -1 && euid != old->uid))
636 new->suid = new->euid;
637 new->fsuid = new->euid;
638
639 retval = security_task_fix_setuid(new, old, LSM_SETID_RE);
640 if (retval < 0)
641 goto error;
642
643 return commit_creds(new);
644
645error:
646 abort_creds(new);
647 return retval;
648}
649
650
651
652
653
654
655
656
657
658
659
660
661SYSCALL_DEFINE1(setuid, uid_t, uid)
662{
663 const struct cred *old;
664 struct cred *new;
665 int retval;
666
667 new = prepare_creds();
668 if (!new)
669 return -ENOMEM;
670 old = current_cred();
671
672 retval = -EPERM;
673 if (capable(CAP_SETUID)) {
674 new->suid = new->uid = uid;
675 if (uid != old->uid) {
676 retval = set_user(new);
677 if (retval < 0)
678 goto error;
679 }
680 } else if (uid != old->uid && uid != new->suid) {
681 goto error;
682 }
683
684 new->fsuid = new->euid = uid;
685
686 retval = security_task_fix_setuid(new, old, LSM_SETID_ID);
687 if (retval < 0)
688 goto error;
689
690 return commit_creds(new);
691
692error:
693 abort_creds(new);
694 return retval;
695}
696
697
698
699
700
701
702SYSCALL_DEFINE3(setresuid, uid_t, ruid, uid_t, euid, uid_t, suid)
703{
704 const struct cred *old;
705 struct cred *new;
706 int retval;
707
708 new = prepare_creds();
709 if (!new)
710 return -ENOMEM;
711
712 old = current_cred();
713
714 retval = -EPERM;
715 if (!capable(CAP_SETUID)) {
716 if (ruid != (uid_t) -1 && ruid != old->uid &&
717 ruid != old->euid && ruid != old->suid)
718 goto error;
719 if (euid != (uid_t) -1 && euid != old->uid &&
720 euid != old->euid && euid != old->suid)
721 goto error;
722 if (suid != (uid_t) -1 && suid != old->uid &&
723 suid != old->euid && suid != old->suid)
724 goto error;
725 }
726
727 if (ruid != (uid_t) -1) {
728 new->uid = ruid;
729 if (ruid != old->uid) {
730 retval = set_user(new);
731 if (retval < 0)
732 goto error;
733 }
734 }
735 if (euid != (uid_t) -1)
736 new->euid = euid;
737 if (suid != (uid_t) -1)
738 new->suid = suid;
739 new->fsuid = new->euid;
740
741 retval = security_task_fix_setuid(new, old, LSM_SETID_RES);
742 if (retval < 0)
743 goto error;
744
745 return commit_creds(new);
746
747error:
748 abort_creds(new);
749 return retval;
750}
751
752SYSCALL_DEFINE3(getresuid, uid_t __user *, ruid, uid_t __user *, euid, uid_t __user *, suid)
753{
754 const struct cred *cred = current_cred();
755 int retval;
756
757 if (!(retval = put_user(cred->uid, ruid)) &&
758 !(retval = put_user(cred->euid, euid)))
759 retval = put_user(cred->suid, suid);
760
761 return retval;
762}
763
764
765
766
767SYSCALL_DEFINE3(setresgid, gid_t, rgid, gid_t, egid, gid_t, sgid)
768{
769 const struct cred *old;
770 struct cred *new;
771 int retval;
772
773 new = prepare_creds();
774 if (!new)
775 return -ENOMEM;
776 old = current_cred();
777
778 retval = -EPERM;
779 if (!capable(CAP_SETGID)) {
780 if (rgid != (gid_t) -1 && rgid != old->gid &&
781 rgid != old->egid && rgid != old->sgid)
782 goto error;
783 if (egid != (gid_t) -1 && egid != old->gid &&
784 egid != old->egid && egid != old->sgid)
785 goto error;
786 if (sgid != (gid_t) -1 && sgid != old->gid &&
787 sgid != old->egid && sgid != old->sgid)
788 goto error;
789 }
790
791 if (rgid != (gid_t) -1)
792 new->gid = rgid;
793 if (egid != (gid_t) -1)
794 new->egid = egid;
795 if (sgid != (gid_t) -1)
796 new->sgid = sgid;
797 new->fsgid = new->egid;
798
799 return commit_creds(new);
800
801error:
802 abort_creds(new);
803 return retval;
804}
805
806SYSCALL_DEFINE3(getresgid, gid_t __user *, rgid, gid_t __user *, egid, gid_t __user *, sgid)
807{
808 const struct cred *cred = current_cred();
809 int retval;
810
811 if (!(retval = put_user(cred->gid, rgid)) &&
812 !(retval = put_user(cred->egid, egid)))
813 retval = put_user(cred->sgid, sgid);
814
815 return retval;
816}
817
818
819
820
821
822
823
824
825SYSCALL_DEFINE1(setfsuid, uid_t, uid)
826{
827 const struct cred *old;
828 struct cred *new;
829 uid_t old_fsuid;
830
831 new = prepare_creds();
832 if (!new)
833 return current_fsuid();
834 old = current_cred();
835 old_fsuid = old->fsuid;
836
837 if (uid == old->uid || uid == old->euid ||
838 uid == old->suid || uid == old->fsuid ||
839 capable(CAP_SETUID)) {
840 if (uid != old_fsuid) {
841 new->fsuid = uid;
842 if (security_task_fix_setuid(new, old, LSM_SETID_FS) == 0)
843 goto change_okay;
844 }
845 }
846
847 abort_creds(new);
848 return old_fsuid;
849
850change_okay:
851 commit_creds(new);
852 return old_fsuid;
853}
854
855
856
857
858SYSCALL_DEFINE1(setfsgid, gid_t, gid)
859{
860 const struct cred *old;
861 struct cred *new;
862 gid_t old_fsgid;
863
864 new = prepare_creds();
865 if (!new)
866 return current_fsgid();
867 old = current_cred();
868 old_fsgid = old->fsgid;
869
870 if (gid == old->gid || gid == old->egid ||
871 gid == old->sgid || gid == old->fsgid ||
872 capable(CAP_SETGID)) {
873 if (gid != old_fsgid) {
874 new->fsgid = gid;
875 goto change_okay;
876 }
877 }
878
879 abort_creds(new);
880 return old_fsgid;
881
882change_okay:
883 commit_creds(new);
884 return old_fsgid;
885}
886
887void do_sys_times(struct tms *tms)
888{
889 cputime_t tgutime, tgstime, cutime, cstime;
890
891 spin_lock_irq(¤t->sighand->siglock);
892 thread_group_times(current, &tgutime, &tgstime);
893 cutime = current->signal->cutime;
894 cstime = current->signal->cstime;
895 spin_unlock_irq(¤t->sighand->siglock);
896 tms->tms_utime = cputime_to_clock_t(tgutime);
897 tms->tms_stime = cputime_to_clock_t(tgstime);
898 tms->tms_cutime = cputime_to_clock_t(cutime);
899 tms->tms_cstime = cputime_to_clock_t(cstime);
900}
901
902SYSCALL_DEFINE1(times, struct tms __user *, tbuf)
903{
904 if (tbuf) {
905 struct tms tmp;
906
907 do_sys_times(&tmp);
908 if (copy_to_user(tbuf, &tmp, sizeof(struct tms)))
909 return -EFAULT;
910 }
911 force_successful_syscall_return();
912 return (long) jiffies_64_to_clock_t(get_jiffies_64());
913}
914
915
916
917
918
919
920
921
922
923
924
925
926
927SYSCALL_DEFINE2(setpgid, pid_t, pid, pid_t, pgid)
928{
929 struct task_struct *p;
930 struct task_struct *group_leader = current->group_leader;
931 struct pid *pgrp;
932 int err;
933
934 if (!pid)
935 pid = task_pid_vnr(group_leader);
936 if (!pgid)
937 pgid = pid;
938 if (pgid < 0)
939 return -EINVAL;
940 rcu_read_lock();
941
942
943
944
945 write_lock_irq(&tasklist_lock);
946
947 err = -ESRCH;
948 p = find_task_by_vpid(pid);
949 if (!p)
950 goto out;
951
952 err = -EINVAL;
953 if (!thread_group_leader(p))
954 goto out;
955
956 if (same_thread_group(p->real_parent, group_leader)) {
957 err = -EPERM;
958 if (task_session(p) != task_session(group_leader))
959 goto out;
960 err = -EACCES;
961 if (p->did_exec)
962 goto out;
963 } else {
964 err = -ESRCH;
965 if (p != group_leader)
966 goto out;
967 }
968
969 err = -EPERM;
970 if (p->signal->leader)
971 goto out;
972
973 pgrp = task_pid(p);
974 if (pgid != pid) {
975 struct task_struct *g;
976
977 pgrp = find_vpid(pgid);
978 g = pid_task(pgrp, PIDTYPE_PGID);
979 if (!g || task_session(g) != task_session(group_leader))
980 goto out;
981 }
982
983 err = security_task_setpgid(p, pgid);
984 if (err)
985 goto out;
986
987 if (task_pgrp(p) != pgrp)
988 change_pid(p, PIDTYPE_PGID, pgrp);
989
990 err = 0;
991out:
992
993 write_unlock_irq(&tasklist_lock);
994 rcu_read_unlock();
995 return err;
996}
997
998SYSCALL_DEFINE1(getpgid, pid_t, pid)
999{
1000 struct task_struct *p;
1001 struct pid *grp;
1002 int retval;
1003
1004 rcu_read_lock();
1005 if (!pid)
1006 grp = task_pgrp(current);
1007 else {
1008 retval = -ESRCH;
1009 p = find_task_by_vpid(pid);
1010 if (!p)
1011 goto out;
1012 grp = task_pgrp(p);
1013 if (!grp)
1014 goto out;
1015
1016 retval = security_task_getpgid(p);
1017 if (retval)
1018 goto out;
1019 }
1020 retval = pid_vnr(grp);
1021out:
1022 rcu_read_unlock();
1023 return retval;
1024}
1025
1026#ifdef __ARCH_WANT_SYS_GETPGRP
1027
1028SYSCALL_DEFINE0(getpgrp)
1029{
1030 return sys_getpgid(0);
1031}
1032
1033#endif
1034
1035SYSCALL_DEFINE1(getsid, pid_t, pid)
1036{
1037 struct task_struct *p;
1038 struct pid *sid;
1039 int retval;
1040
1041 rcu_read_lock();
1042 if (!pid)
1043 sid = task_session(current);
1044 else {
1045 retval = -ESRCH;
1046 p = find_task_by_vpid(pid);
1047 if (!p)
1048 goto out;
1049 sid = task_session(p);
1050 if (!sid)
1051 goto out;
1052
1053 retval = security_task_getsid(p);
1054 if (retval)
1055 goto out;
1056 }
1057 retval = pid_vnr(sid);
1058out:
1059 rcu_read_unlock();
1060 return retval;
1061}
1062
1063SYSCALL_DEFINE0(setsid)
1064{
1065 struct task_struct *group_leader = current->group_leader;
1066 struct pid *sid = task_pid(group_leader);
1067 pid_t session = pid_vnr(sid);
1068 int err = -EPERM;
1069
1070 write_lock_irq(&tasklist_lock);
1071
1072 if (group_leader->signal->leader)
1073 goto out;
1074
1075
1076
1077
1078 if (pid_task(sid, PIDTYPE_PGID))
1079 goto out;
1080
1081 group_leader->signal->leader = 1;
1082 __set_special_pids(sid);
1083
1084 proc_clear_tty(group_leader);
1085
1086 err = session;
1087out:
1088 write_unlock_irq(&tasklist_lock);
1089 if (err > 0) {
1090 proc_sid_connector(group_leader);
1091 sched_autogroup_create_attach(group_leader);
1092 }
1093 return err;
1094}
1095
1096DECLARE_RWSEM(uts_sem);
1097
1098#ifdef COMPAT_UTS_MACHINE
1099#define override_architecture(name) \
1100 (personality(current->personality) == PER_LINUX32 && \
1101 copy_to_user(name->machine, COMPAT_UTS_MACHINE, \
1102 sizeof(COMPAT_UTS_MACHINE)))
1103#else
1104#define override_architecture(name) 0
1105#endif
1106
1107SYSCALL_DEFINE1(newuname, struct new_utsname __user *, name)
1108{
1109 int errno = 0;
1110
1111 down_read(&uts_sem);
1112 if (copy_to_user(name, utsname(), sizeof *name))
1113 errno = -EFAULT;
1114 up_read(&uts_sem);
1115
1116 if (!errno && override_architecture(name))
1117 errno = -EFAULT;
1118 return errno;
1119}
1120
1121#ifdef __ARCH_WANT_SYS_OLD_UNAME
1122
1123
1124
1125SYSCALL_DEFINE1(uname, struct old_utsname __user *, name)
1126{
1127 int error = 0;
1128
1129 if (!name)
1130 return -EFAULT;
1131
1132 down_read(&uts_sem);
1133 if (copy_to_user(name, utsname(), sizeof(*name)))
1134 error = -EFAULT;
1135 up_read(&uts_sem);
1136
1137 if (!error && override_architecture(name))
1138 error = -EFAULT;
1139 return error;
1140}
1141
1142SYSCALL_DEFINE1(olduname, struct oldold_utsname __user *, name)
1143{
1144 int error;
1145
1146 if (!name)
1147 return -EFAULT;
1148 if (!access_ok(VERIFY_WRITE, name, sizeof(struct oldold_utsname)))
1149 return -EFAULT;
1150
1151 down_read(&uts_sem);
1152 error = __copy_to_user(&name->sysname, &utsname()->sysname,
1153 __OLD_UTS_LEN);
1154 error |= __put_user(0, name->sysname + __OLD_UTS_LEN);
1155 error |= __copy_to_user(&name->nodename, &utsname()->nodename,
1156 __OLD_UTS_LEN);
1157 error |= __put_user(0, name->nodename + __OLD_UTS_LEN);
1158 error |= __copy_to_user(&name->release, &utsname()->release,
1159 __OLD_UTS_LEN);
1160 error |= __put_user(0, name->release + __OLD_UTS_LEN);
1161 error |= __copy_to_user(&name->version, &utsname()->version,
1162 __OLD_UTS_LEN);
1163 error |= __put_user(0, name->version + __OLD_UTS_LEN);
1164 error |= __copy_to_user(&name->machine, &utsname()->machine,
1165 __OLD_UTS_LEN);
1166 error |= __put_user(0, name->machine + __OLD_UTS_LEN);
1167 up_read(&uts_sem);
1168
1169 if (!error && override_architecture(name))
1170 error = -EFAULT;
1171 return error ? -EFAULT : 0;
1172}
1173#endif
1174
1175SYSCALL_DEFINE2(sethostname, char __user *, name, int, len)
1176{
1177 int errno;
1178 char tmp[__NEW_UTS_LEN];
1179
1180 if (!capable(CAP_SYS_ADMIN))
1181 return -EPERM;
1182 if (len < 0 || len > __NEW_UTS_LEN)
1183 return -EINVAL;
1184 down_write(&uts_sem);
1185 errno = -EFAULT;
1186 if (!copy_from_user(tmp, name, len)) {
1187 struct new_utsname *u = utsname();
1188
1189 memcpy(u->nodename, tmp, len);
1190 memset(u->nodename + len, 0, sizeof(u->nodename) - len);
1191 errno = 0;
1192 }
1193 up_write(&uts_sem);
1194 return errno;
1195}
1196
1197#ifdef __ARCH_WANT_SYS_GETHOSTNAME
1198
1199SYSCALL_DEFINE2(gethostname, char __user *, name, int, len)
1200{
1201 int i, errno;
1202 struct new_utsname *u;
1203
1204 if (len < 0)
1205 return -EINVAL;
1206 down_read(&uts_sem);
1207 u = utsname();
1208 i = 1 + strlen(u->nodename);
1209 if (i > len)
1210 i = len;
1211 errno = 0;
1212 if (copy_to_user(name, u->nodename, i))
1213 errno = -EFAULT;
1214 up_read(&uts_sem);
1215 return errno;
1216}
1217
1218#endif
1219
1220
1221
1222
1223
1224SYSCALL_DEFINE2(setdomainname, char __user *, name, int, len)
1225{
1226 int errno;
1227 char tmp[__NEW_UTS_LEN];
1228
1229 if (!capable(CAP_SYS_ADMIN))
1230 return -EPERM;
1231 if (len < 0 || len > __NEW_UTS_LEN)
1232 return -EINVAL;
1233
1234 down_write(&uts_sem);
1235 errno = -EFAULT;
1236 if (!copy_from_user(tmp, name, len)) {
1237 struct new_utsname *u = utsname();
1238
1239 memcpy(u->domainname, tmp, len);
1240 memset(u->domainname + len, 0, sizeof(u->domainname) - len);
1241 errno = 0;
1242 }
1243 up_write(&uts_sem);
1244 return errno;
1245}
1246
1247SYSCALL_DEFINE2(getrlimit, unsigned int, resource, struct rlimit __user *, rlim)
1248{
1249 struct rlimit value;
1250 int ret;
1251
1252 ret = do_prlimit(current, resource, NULL, &value);
1253 if (!ret)
1254 ret = copy_to_user(rlim, &value, sizeof(*rlim)) ? -EFAULT : 0;
1255
1256 return ret;
1257}
1258
1259#ifdef __ARCH_WANT_SYS_OLD_GETRLIMIT
1260
1261
1262
1263
1264
1265SYSCALL_DEFINE2(old_getrlimit, unsigned int, resource,
1266 struct rlimit __user *, rlim)
1267{
1268 struct rlimit x;
1269 if (resource >= RLIM_NLIMITS)
1270 return -EINVAL;
1271
1272 task_lock(current->group_leader);
1273 x = current->signal->rlim[resource];
1274 task_unlock(current->group_leader);
1275 if (x.rlim_cur > 0x7FFFFFFF)
1276 x.rlim_cur = 0x7FFFFFFF;
1277 if (x.rlim_max > 0x7FFFFFFF)
1278 x.rlim_max = 0x7FFFFFFF;
1279 return copy_to_user(rlim, &x, sizeof(x))?-EFAULT:0;
1280}
1281
1282#endif
1283
1284static inline bool rlim64_is_infinity(__u64 rlim64)
1285{
1286#if BITS_PER_LONG < 64
1287 return rlim64 >= ULONG_MAX;
1288#else
1289 return rlim64 == RLIM64_INFINITY;
1290#endif
1291}
1292
1293static void rlim_to_rlim64(const struct rlimit *rlim, struct rlimit64 *rlim64)
1294{
1295 if (rlim->rlim_cur == RLIM_INFINITY)
1296 rlim64->rlim_cur = RLIM64_INFINITY;
1297 else
1298 rlim64->rlim_cur = rlim->rlim_cur;
1299 if (rlim->rlim_max == RLIM_INFINITY)
1300 rlim64->rlim_max = RLIM64_INFINITY;
1301 else
1302 rlim64->rlim_max = rlim->rlim_max;
1303}
1304
1305static void rlim64_to_rlim(const struct rlimit64 *rlim64, struct rlimit *rlim)
1306{
1307 if (rlim64_is_infinity(rlim64->rlim_cur))
1308 rlim->rlim_cur = RLIM_INFINITY;
1309 else
1310 rlim->rlim_cur = (unsigned long)rlim64->rlim_cur;
1311 if (rlim64_is_infinity(rlim64->rlim_max))
1312 rlim->rlim_max = RLIM_INFINITY;
1313 else
1314 rlim->rlim_max = (unsigned long)rlim64->rlim_max;
1315}
1316
1317
1318int do_prlimit(struct task_struct *tsk, unsigned int resource,
1319 struct rlimit *new_rlim, struct rlimit *old_rlim)
1320{
1321 struct rlimit *rlim;
1322 int retval = 0;
1323
1324 if (resource >= RLIM_NLIMITS)
1325 return -EINVAL;
1326 if (new_rlim) {
1327 if (new_rlim->rlim_cur > new_rlim->rlim_max)
1328 return -EINVAL;
1329 if (resource == RLIMIT_NOFILE &&
1330 new_rlim->rlim_max > sysctl_nr_open)
1331 return -EPERM;
1332 }
1333
1334
1335 read_lock(&tasklist_lock);
1336 if (!tsk->sighand) {
1337 retval = -ESRCH;
1338 goto out;
1339 }
1340
1341 rlim = tsk->signal->rlim + resource;
1342 task_lock(tsk->group_leader);
1343 if (new_rlim) {
1344 if (new_rlim->rlim_max > rlim->rlim_max &&
1345 !capable(CAP_SYS_RESOURCE))
1346 retval = -EPERM;
1347 if (!retval)
1348 retval = security_task_setrlimit(tsk->group_leader,
1349 resource, new_rlim);
1350 if (resource == RLIMIT_CPU && new_rlim->rlim_cur == 0) {
1351
1352
1353
1354
1355
1356
1357 new_rlim->rlim_cur = 1;
1358 }
1359 }
1360 if (!retval) {
1361 if (old_rlim)
1362 *old_rlim = *rlim;
1363 if (new_rlim)
1364 *rlim = *new_rlim;
1365 }
1366 task_unlock(tsk->group_leader);
1367
1368
1369
1370
1371
1372
1373
1374 if (!retval && new_rlim && resource == RLIMIT_CPU &&
1375 new_rlim->rlim_cur != RLIM_INFINITY)
1376 update_rlimit_cpu(tsk, new_rlim->rlim_cur);
1377out:
1378 read_unlock(&tasklist_lock);
1379 return retval;
1380}
1381
1382
1383static int check_prlimit_permission(struct task_struct *task)
1384{
1385 const struct cred *cred = current_cred(), *tcred;
1386
1387 tcred = __task_cred(task);
1388 if (current != task &&
1389 (cred->uid != tcred->euid ||
1390 cred->uid != tcred->suid ||
1391 cred->uid != tcred->uid ||
1392 cred->gid != tcred->egid ||
1393 cred->gid != tcred->sgid ||
1394 cred->gid != tcred->gid) &&
1395 !capable(CAP_SYS_RESOURCE)) {
1396 return -EPERM;
1397 }
1398
1399 return 0;
1400}
1401
1402SYSCALL_DEFINE4(prlimit64, pid_t, pid, unsigned int, resource,
1403 const struct rlimit64 __user *, new_rlim,
1404 struct rlimit64 __user *, old_rlim)
1405{
1406 struct rlimit64 old64, new64;
1407 struct rlimit old, new;
1408 struct task_struct *tsk;
1409 int ret;
1410
1411 if (new_rlim) {
1412 if (copy_from_user(&new64, new_rlim, sizeof(new64)))
1413 return -EFAULT;
1414 rlim64_to_rlim(&new64, &new);
1415 }
1416
1417 rcu_read_lock();
1418 tsk = pid ? find_task_by_vpid(pid) : current;
1419 if (!tsk) {
1420 rcu_read_unlock();
1421 return -ESRCH;
1422 }
1423 ret = check_prlimit_permission(tsk);
1424 if (ret) {
1425 rcu_read_unlock();
1426 return ret;
1427 }
1428 get_task_struct(tsk);
1429 rcu_read_unlock();
1430
1431 ret = do_prlimit(tsk, resource, new_rlim ? &new : NULL,
1432 old_rlim ? &old : NULL);
1433
1434 if (!ret && old_rlim) {
1435 rlim_to_rlim64(&old, &old64);
1436 if (copy_to_user(old_rlim, &old64, sizeof(old64)))
1437 ret = -EFAULT;
1438 }
1439
1440 put_task_struct(tsk);
1441 return ret;
1442}
1443
1444SYSCALL_DEFINE2(setrlimit, unsigned int, resource, struct rlimit __user *, rlim)
1445{
1446 struct rlimit new_rlim;
1447
1448 if (copy_from_user(&new_rlim, rlim, sizeof(*rlim)))
1449 return -EFAULT;
1450 return do_prlimit(current, resource, &new_rlim, NULL);
1451}
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486static void accumulate_thread_rusage(struct task_struct *t, struct rusage *r)
1487{
1488 r->ru_nvcsw += t->nvcsw;
1489 r->ru_nivcsw += t->nivcsw;
1490 r->ru_minflt += t->min_flt;
1491 r->ru_majflt += t->maj_flt;
1492 r->ru_inblock += task_io_get_inblock(t);
1493 r->ru_oublock += task_io_get_oublock(t);
1494}
1495
1496static void k_getrusage(struct task_struct *p, int who, struct rusage *r)
1497{
1498 struct task_struct *t;
1499 unsigned long flags;
1500 cputime_t tgutime, tgstime, utime, stime;
1501 unsigned long maxrss = 0;
1502
1503 memset((char *) r, 0, sizeof *r);
1504 utime = stime = cputime_zero;
1505
1506 if (who == RUSAGE_THREAD) {
1507 task_times(current, &utime, &stime);
1508 accumulate_thread_rusage(p, r);
1509 maxrss = p->signal->maxrss;
1510 goto out;
1511 }
1512
1513 if (!lock_task_sighand(p, &flags))
1514 return;
1515
1516 switch (who) {
1517 case RUSAGE_BOTH:
1518 case RUSAGE_CHILDREN:
1519 utime = p->signal->cutime;
1520 stime = p->signal->cstime;
1521 r->ru_nvcsw = p->signal->cnvcsw;
1522 r->ru_nivcsw = p->signal->cnivcsw;
1523 r->ru_minflt = p->signal->cmin_flt;
1524 r->ru_majflt = p->signal->cmaj_flt;
1525 r->ru_inblock = p->signal->cinblock;
1526 r->ru_oublock = p->signal->coublock;
1527 maxrss = p->signal->cmaxrss;
1528
1529 if (who == RUSAGE_CHILDREN)
1530 break;
1531
1532 case RUSAGE_SELF:
1533 thread_group_times(p, &tgutime, &tgstime);
1534 utime = cputime_add(utime, tgutime);
1535 stime = cputime_add(stime, tgstime);
1536 r->ru_nvcsw += p->signal->nvcsw;
1537 r->ru_nivcsw += p->signal->nivcsw;
1538 r->ru_minflt += p->signal->min_flt;
1539 r->ru_majflt += p->signal->maj_flt;
1540 r->ru_inblock += p->signal->inblock;
1541 r->ru_oublock += p->signal->oublock;
1542 if (maxrss < p->signal->maxrss)
1543 maxrss = p->signal->maxrss;
1544 t = p;
1545 do {
1546 accumulate_thread_rusage(t, r);
1547 t = next_thread(t);
1548 } while (t != p);
1549 break;
1550
1551 default:
1552 BUG();
1553 }
1554 unlock_task_sighand(p, &flags);
1555
1556out:
1557 cputime_to_timeval(utime, &r->ru_utime);
1558 cputime_to_timeval(stime, &r->ru_stime);
1559
1560 if (who != RUSAGE_CHILDREN) {
1561 struct mm_struct *mm = get_task_mm(p);
1562 if (mm) {
1563 setmax_mm_hiwater_rss(&maxrss, mm);
1564 mmput(mm);
1565 }
1566 }
1567 r->ru_maxrss = maxrss * (PAGE_SIZE / 1024);
1568}
1569
1570int getrusage(struct task_struct *p, int who, struct rusage __user *ru)
1571{
1572 struct rusage r;
1573 k_getrusage(p, who, &r);
1574 return copy_to_user(ru, &r, sizeof(r)) ? -EFAULT : 0;
1575}
1576
1577SYSCALL_DEFINE2(getrusage, int, who, struct rusage __user *, ru)
1578{
1579 if (who != RUSAGE_SELF && who != RUSAGE_CHILDREN &&
1580 who != RUSAGE_THREAD)
1581 return -EINVAL;
1582 return getrusage(current, who, ru);
1583}
1584
1585SYSCALL_DEFINE1(umask, int, mask)
1586{
1587 mask = xchg(¤t->fs->umask, mask & S_IRWXUGO);
1588 return mask;
1589}
1590
1591SYSCALL_DEFINE5(prctl, int, option, unsigned long, arg2, unsigned long, arg3,
1592 unsigned long, arg4, unsigned long, arg5)
1593{
1594 struct task_struct *me = current;
1595 unsigned char comm[sizeof(me->comm)];
1596 long error;
1597
1598 error = security_task_prctl(option, arg2, arg3, arg4, arg5);
1599 if (error != -ENOSYS)
1600 return error;
1601
1602 error = 0;
1603 switch (option) {
1604 case PR_SET_PDEATHSIG:
1605 if (!valid_signal(arg2)) {
1606 error = -EINVAL;
1607 break;
1608 }
1609 me->pdeath_signal = arg2;
1610 error = 0;
1611 break;
1612 case PR_GET_PDEATHSIG:
1613 error = put_user(me->pdeath_signal, (int __user *)arg2);
1614 break;
1615 case PR_GET_DUMPABLE:
1616 error = get_dumpable(me->mm);
1617 break;
1618 case PR_SET_DUMPABLE:
1619 if (arg2 < 0 || arg2 > 1) {
1620 error = -EINVAL;
1621 break;
1622 }
1623 set_dumpable(me->mm, arg2);
1624 error = 0;
1625 break;
1626
1627 case PR_SET_UNALIGN:
1628 error = SET_UNALIGN_CTL(me, arg2);
1629 break;
1630 case PR_GET_UNALIGN:
1631 error = GET_UNALIGN_CTL(me, arg2);
1632 break;
1633 case PR_SET_FPEMU:
1634 error = SET_FPEMU_CTL(me, arg2);
1635 break;
1636 case PR_GET_FPEMU:
1637 error = GET_FPEMU_CTL(me, arg2);
1638 break;
1639 case PR_SET_FPEXC:
1640 error = SET_FPEXC_CTL(me, arg2);
1641 break;
1642 case PR_GET_FPEXC:
1643 error = GET_FPEXC_CTL(me, arg2);
1644 break;
1645 case PR_GET_TIMING:
1646 error = PR_TIMING_STATISTICAL;
1647 break;
1648 case PR_SET_TIMING:
1649 if (arg2 != PR_TIMING_STATISTICAL)
1650 error = -EINVAL;
1651 else
1652 error = 0;
1653 break;
1654
1655 case PR_SET_NAME:
1656 comm[sizeof(me->comm)-1] = 0;
1657 if (strncpy_from_user(comm, (char __user *)arg2,
1658 sizeof(me->comm) - 1) < 0)
1659 return -EFAULT;
1660 set_task_comm(me, comm);
1661 return 0;
1662 case PR_GET_NAME:
1663 get_task_comm(comm, me);
1664 if (copy_to_user((char __user *)arg2, comm,
1665 sizeof(comm)))
1666 return -EFAULT;
1667 return 0;
1668 case PR_GET_ENDIAN:
1669 error = GET_ENDIAN(me, arg2);
1670 break;
1671 case PR_SET_ENDIAN:
1672 error = SET_ENDIAN(me, arg2);
1673 break;
1674
1675 case PR_GET_SECCOMP:
1676 error = prctl_get_seccomp();
1677 break;
1678 case PR_SET_SECCOMP:
1679 error = prctl_set_seccomp(arg2);
1680 break;
1681 case PR_GET_TSC:
1682 error = GET_TSC_CTL(arg2);
1683 break;
1684 case PR_SET_TSC:
1685 error = SET_TSC_CTL(arg2);
1686 break;
1687 case PR_TASK_PERF_EVENTS_DISABLE:
1688 error = perf_event_task_disable();
1689 break;
1690 case PR_TASK_PERF_EVENTS_ENABLE:
1691 error = perf_event_task_enable();
1692 break;
1693 case PR_GET_TIMERSLACK:
1694 error = current->timer_slack_ns;
1695 break;
1696 case PR_SET_TIMERSLACK:
1697 if (arg2 <= 0)
1698 current->timer_slack_ns =
1699 current->default_timer_slack_ns;
1700 else
1701 current->timer_slack_ns = arg2;
1702 error = 0;
1703 break;
1704 case PR_MCE_KILL:
1705 if (arg4 | arg5)
1706 return -EINVAL;
1707 switch (arg2) {
1708 case PR_MCE_KILL_CLEAR:
1709 if (arg3 != 0)
1710 return -EINVAL;
1711 current->flags &= ~PF_MCE_PROCESS;
1712 break;
1713 case PR_MCE_KILL_SET:
1714 current->flags |= PF_MCE_PROCESS;
1715 if (arg3 == PR_MCE_KILL_EARLY)
1716 current->flags |= PF_MCE_EARLY;
1717 else if (arg3 == PR_MCE_KILL_LATE)
1718 current->flags &= ~PF_MCE_EARLY;
1719 else if (arg3 == PR_MCE_KILL_DEFAULT)
1720 current->flags &=
1721 ~(PF_MCE_EARLY|PF_MCE_PROCESS);
1722 else
1723 return -EINVAL;
1724 break;
1725 default:
1726 return -EINVAL;
1727 }
1728 error = 0;
1729 break;
1730 case PR_MCE_KILL_GET:
1731 if (arg2 | arg3 | arg4 | arg5)
1732 return -EINVAL;
1733 if (current->flags & PF_MCE_PROCESS)
1734 error = (current->flags & PF_MCE_EARLY) ?
1735 PR_MCE_KILL_EARLY : PR_MCE_KILL_LATE;
1736 else
1737 error = PR_MCE_KILL_DEFAULT;
1738 break;
1739 default:
1740 error = -EINVAL;
1741 break;
1742 }
1743 return error;
1744}
1745
1746SYSCALL_DEFINE3(getcpu, unsigned __user *, cpup, unsigned __user *, nodep,
1747 struct getcpu_cache __user *, unused)
1748{
1749 int err = 0;
1750 int cpu = raw_smp_processor_id();
1751 if (cpup)
1752 err |= put_user(cpu, cpup);
1753 if (nodep)
1754 err |= put_user(cpu_to_node(cpu), nodep);
1755 return err ? -EFAULT : 0;
1756}
1757
1758char poweroff_cmd[POWEROFF_CMD_PATH_LEN] = "/sbin/poweroff";
1759
1760static void argv_cleanup(struct subprocess_info *info)
1761{
1762 argv_free(info->argv);
1763}
1764
1765
1766
1767
1768
1769
1770
1771
1772int orderly_poweroff(bool force)
1773{
1774 int argc;
1775 char **argv = argv_split(GFP_ATOMIC, poweroff_cmd, &argc);
1776 static char *envp[] = {
1777 "HOME=/",
1778 "PATH=/sbin:/bin:/usr/sbin:/usr/bin",
1779 NULL
1780 };
1781 int ret = -ENOMEM;
1782 struct subprocess_info *info;
1783
1784 if (argv == NULL) {
1785 printk(KERN_WARNING "%s failed to allocate memory for \"%s\"\n",
1786 __func__, poweroff_cmd);
1787 goto out;
1788 }
1789
1790 info = call_usermodehelper_setup(argv[0], argv, envp, GFP_ATOMIC);
1791 if (info == NULL) {
1792 argv_free(argv);
1793 goto out;
1794 }
1795
1796 call_usermodehelper_setfns(info, NULL, argv_cleanup, NULL);
1797
1798 ret = call_usermodehelper_exec(info, UMH_NO_WAIT);
1799
1800 out:
1801 if (ret && force) {
1802 printk(KERN_WARNING "Failed to start orderly shutdown: "
1803 "forcing the issue\n");
1804
1805
1806
1807
1808 emergency_sync();
1809 kernel_power_off();
1810 }
1811
1812 return ret;
1813}
1814EXPORT_SYMBOL_GPL(orderly_poweroff);
1815