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