1
2
3
4
5
6
7
8#include <linux/export.h>
9#include <linux/mm.h>
10#include <linux/utsname.h>
11#include <linux/mman.h>
12#include <linux/reboot.h>
13#include <linux/prctl.h>
14#include <linux/highuid.h>
15#include <linux/fs.h>
16#include <linux/kmod.h>
17#include <linux/perf_event.h>
18#include <linux/resource.h>
19#include <linux/kernel.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/file.h>
40#include <linux/mount.h>
41#include <linux/gfp.h>
42#include <linux/syscore_ops.h>
43#include <linux/version.h>
44#include <linux/ctype.h>
45
46#include <linux/compat.h>
47#include <linux/syscalls.h>
48#include <linux/kprobes.h>
49#include <linux/user_namespace.h>
50#include <linux/binfmts.h>
51
52#include <linux/sched.h>
53#include <linux/sched/autogroup.h>
54#include <linux/sched/loadavg.h>
55#include <linux/sched/stat.h>
56#include <linux/sched/mm.h>
57#include <linux/sched/coredump.h>
58#include <linux/sched/task.h>
59#include <linux/sched/cputime.h>
60#include <linux/rcupdate.h>
61#include <linux/uidgid.h>
62#include <linux/cred.h>
63
64#include <linux/nospec.h>
65
66#include <linux/kmsg_dump.h>
67
68#include <generated/utsrelease.h>
69
70#include <linux/uaccess.h>
71#include <asm/io.h>
72#include <asm/unistd.h>
73
74#include "uid16.h"
75
76#ifndef SET_UNALIGN_CTL
77# define SET_UNALIGN_CTL(a, b) (-EINVAL)
78#endif
79#ifndef GET_UNALIGN_CTL
80# define GET_UNALIGN_CTL(a, b) (-EINVAL)
81#endif
82#ifndef SET_FPEMU_CTL
83# define SET_FPEMU_CTL(a, b) (-EINVAL)
84#endif
85#ifndef GET_FPEMU_CTL
86# define GET_FPEMU_CTL(a, b) (-EINVAL)
87#endif
88#ifndef SET_FPEXC_CTL
89# define SET_FPEXC_CTL(a, b) (-EINVAL)
90#endif
91#ifndef GET_FPEXC_CTL
92# define GET_FPEXC_CTL(a, b) (-EINVAL)
93#endif
94#ifndef GET_ENDIAN
95# define GET_ENDIAN(a, b) (-EINVAL)
96#endif
97#ifndef SET_ENDIAN
98# define SET_ENDIAN(a, b) (-EINVAL)
99#endif
100#ifndef GET_TSC_CTL
101# define GET_TSC_CTL(a) (-EINVAL)
102#endif
103#ifndef SET_TSC_CTL
104# define SET_TSC_CTL(a) (-EINVAL)
105#endif
106#ifndef MPX_ENABLE_MANAGEMENT
107# define MPX_ENABLE_MANAGEMENT() (-EINVAL)
108#endif
109#ifndef MPX_DISABLE_MANAGEMENT
110# define MPX_DISABLE_MANAGEMENT() (-EINVAL)
111#endif
112#ifndef GET_FP_MODE
113# define GET_FP_MODE(a) (-EINVAL)
114#endif
115#ifndef SET_FP_MODE
116# define SET_FP_MODE(a,b) (-EINVAL)
117#endif
118#ifndef SVE_SET_VL
119# define SVE_SET_VL(a) (-EINVAL)
120#endif
121#ifndef SVE_GET_VL
122# define SVE_GET_VL() (-EINVAL)
123#endif
124#ifndef PAC_RESET_KEYS
125# define PAC_RESET_KEYS(a, b) (-EINVAL)
126#endif
127
128
129
130
131
132
133int overflowuid = DEFAULT_OVERFLOWUID;
134int overflowgid = DEFAULT_OVERFLOWGID;
135
136EXPORT_SYMBOL(overflowuid);
137EXPORT_SYMBOL(overflowgid);
138
139
140
141
142
143
144int fs_overflowuid = DEFAULT_FS_OVERFLOWUID;
145int fs_overflowgid = DEFAULT_FS_OVERFLOWGID;
146
147EXPORT_SYMBOL(fs_overflowuid);
148EXPORT_SYMBOL(fs_overflowgid);
149
150
151
152
153
154
155
156static bool set_one_prio_perm(struct task_struct *p)
157{
158 const struct cred *cred = current_cred(), *pcred = __task_cred(p);
159
160 if (uid_eq(pcred->uid, cred->euid) ||
161 uid_eq(pcred->euid, cred->euid))
162 return true;
163 if (ns_capable(pcred->user_ns, CAP_SYS_NICE))
164 return true;
165 return false;
166}
167
168
169
170
171
172static int set_one_prio(struct task_struct *p, int niceval, int error)
173{
174 int no_nice;
175
176 if (!set_one_prio_perm(p)) {
177 error = -EPERM;
178 goto out;
179 }
180 if (niceval < task_nice(p) && !can_nice(p, niceval)) {
181 error = -EACCES;
182 goto out;
183 }
184 no_nice = security_task_setnice(p, niceval);
185 if (no_nice) {
186 error = no_nice;
187 goto out;
188 }
189 if (error == -ESRCH)
190 error = 0;
191 set_user_nice(p, niceval);
192out:
193 return error;
194}
195
196SYSCALL_DEFINE3(setpriority, int, which, int, who, int, niceval)
197{
198 struct task_struct *g, *p;
199 struct user_struct *user;
200 const struct cred *cred = current_cred();
201 int error = -EINVAL;
202 struct pid *pgrp;
203 kuid_t uid;
204
205 if (which > PRIO_USER || which < PRIO_PROCESS)
206 goto out;
207
208
209 error = -ESRCH;
210 if (niceval < MIN_NICE)
211 niceval = MIN_NICE;
212 if (niceval > MAX_NICE)
213 niceval = MAX_NICE;
214
215 rcu_read_lock();
216 read_lock(&tasklist_lock);
217 switch (which) {
218 case PRIO_PROCESS:
219 if (who)
220 p = find_task_by_vpid(who);
221 else
222 p = current;
223 if (p)
224 error = set_one_prio(p, niceval, error);
225 break;
226 case PRIO_PGRP:
227 if (who)
228 pgrp = find_vpid(who);
229 else
230 pgrp = task_pgrp(current);
231 do_each_pid_thread(pgrp, PIDTYPE_PGID, p) {
232 error = set_one_prio(p, niceval, error);
233 } while_each_pid_thread(pgrp, PIDTYPE_PGID, p);
234 break;
235 case PRIO_USER:
236 uid = make_kuid(cred->user_ns, who);
237 user = cred->user;
238 if (!who)
239 uid = cred->uid;
240 else if (!uid_eq(uid, cred->uid)) {
241 user = find_user(uid);
242 if (!user)
243 goto out_unlock;
244 }
245 do_each_thread(g, p) {
246 if (uid_eq(task_uid(p), uid) && task_pid_vnr(p))
247 error = set_one_prio(p, niceval, error);
248 } while_each_thread(g, p);
249 if (!uid_eq(uid, cred->uid))
250 free_uid(user);
251 break;
252 }
253out_unlock:
254 read_unlock(&tasklist_lock);
255 rcu_read_unlock();
256out:
257 return error;
258}
259
260
261
262
263
264
265
266SYSCALL_DEFINE2(getpriority, int, which, int, who)
267{
268 struct task_struct *g, *p;
269 struct user_struct *user;
270 const struct cred *cred = current_cred();
271 long niceval, retval = -ESRCH;
272 struct pid *pgrp;
273 kuid_t uid;
274
275 if (which > PRIO_USER || which < PRIO_PROCESS)
276 return -EINVAL;
277
278 rcu_read_lock();
279 read_lock(&tasklist_lock);
280 switch (which) {
281 case PRIO_PROCESS:
282 if (who)
283 p = find_task_by_vpid(who);
284 else
285 p = current;
286 if (p) {
287 niceval = nice_to_rlimit(task_nice(p));
288 if (niceval > retval)
289 retval = niceval;
290 }
291 break;
292 case PRIO_PGRP:
293 if (who)
294 pgrp = find_vpid(who);
295 else
296 pgrp = task_pgrp(current);
297 do_each_pid_thread(pgrp, PIDTYPE_PGID, p) {
298 niceval = nice_to_rlimit(task_nice(p));
299 if (niceval > retval)
300 retval = niceval;
301 } while_each_pid_thread(pgrp, PIDTYPE_PGID, p);
302 break;
303 case PRIO_USER:
304 uid = make_kuid(cred->user_ns, who);
305 user = cred->user;
306 if (!who)
307 uid = cred->uid;
308 else if (!uid_eq(uid, cred->uid)) {
309 user = find_user(uid);
310 if (!user)
311 goto out_unlock;
312 }
313 do_each_thread(g, p) {
314 if (uid_eq(task_uid(p), uid) && task_pid_vnr(p)) {
315 niceval = nice_to_rlimit(task_nice(p));
316 if (niceval > retval)
317 retval = niceval;
318 }
319 } while_each_thread(g, p);
320 if (!uid_eq(uid, cred->uid))
321 free_uid(user);
322 break;
323 }
324out_unlock:
325 read_unlock(&tasklist_lock);
326 rcu_read_unlock();
327
328 return retval;
329}
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349#ifdef CONFIG_MULTIUSER
350long __sys_setregid(gid_t rgid, gid_t egid)
351{
352 struct user_namespace *ns = current_user_ns();
353 const struct cred *old;
354 struct cred *new;
355 int retval;
356 kgid_t krgid, kegid;
357
358 krgid = make_kgid(ns, rgid);
359 kegid = make_kgid(ns, egid);
360
361 if ((rgid != (gid_t) -1) && !gid_valid(krgid))
362 return -EINVAL;
363 if ((egid != (gid_t) -1) && !gid_valid(kegid))
364 return -EINVAL;
365
366 new = prepare_creds();
367 if (!new)
368 return -ENOMEM;
369 old = current_cred();
370
371 retval = -EPERM;
372 if (rgid != (gid_t) -1) {
373 if (gid_eq(old->gid, krgid) ||
374 gid_eq(old->egid, krgid) ||
375 ns_capable(old->user_ns, CAP_SETGID))
376 new->gid = krgid;
377 else
378 goto error;
379 }
380 if (egid != (gid_t) -1) {
381 if (gid_eq(old->gid, kegid) ||
382 gid_eq(old->egid, kegid) ||
383 gid_eq(old->sgid, kegid) ||
384 ns_capable(old->user_ns, CAP_SETGID))
385 new->egid = kegid;
386 else
387 goto error;
388 }
389
390 if (rgid != (gid_t) -1 ||
391 (egid != (gid_t) -1 && !gid_eq(kegid, old->gid)))
392 new->sgid = new->egid;
393 new->fsgid = new->egid;
394
395 return commit_creds(new);
396
397error:
398 abort_creds(new);
399 return retval;
400}
401
402SYSCALL_DEFINE2(setregid, gid_t, rgid, gid_t, egid)
403{
404 return __sys_setregid(rgid, egid);
405}
406
407
408
409
410
411
412long __sys_setgid(gid_t gid)
413{
414 struct user_namespace *ns = current_user_ns();
415 const struct cred *old;
416 struct cred *new;
417 int retval;
418 kgid_t kgid;
419
420 kgid = make_kgid(ns, gid);
421 if (!gid_valid(kgid))
422 return -EINVAL;
423
424 new = prepare_creds();
425 if (!new)
426 return -ENOMEM;
427 old = current_cred();
428
429 retval = -EPERM;
430 if (ns_capable(old->user_ns, CAP_SETGID))
431 new->gid = new->egid = new->sgid = new->fsgid = kgid;
432 else if (gid_eq(kgid, old->gid) || gid_eq(kgid, old->sgid))
433 new->egid = new->fsgid = kgid;
434 else
435 goto error;
436
437 return commit_creds(new);
438
439error:
440 abort_creds(new);
441 return retval;
442}
443
444SYSCALL_DEFINE1(setgid, gid_t, gid)
445{
446 return __sys_setgid(gid);
447}
448
449
450
451
452static int set_user(struct cred *new)
453{
454 struct user_struct *new_user;
455
456 new_user = alloc_uid(new->uid);
457 if (!new_user)
458 return -EAGAIN;
459
460
461
462
463
464
465
466
467 if (atomic_read(&new_user->processes) >= rlimit(RLIMIT_NPROC) &&
468 new_user != INIT_USER)
469 current->flags |= PF_NPROC_EXCEEDED;
470 else
471 current->flags &= ~PF_NPROC_EXCEEDED;
472
473 free_uid(new->user);
474 new->user = new_user;
475 return 0;
476}
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493long __sys_setreuid(uid_t ruid, uid_t euid)
494{
495 struct user_namespace *ns = current_user_ns();
496 const struct cred *old;
497 struct cred *new;
498 int retval;
499 kuid_t kruid, keuid;
500
501 kruid = make_kuid(ns, ruid);
502 keuid = make_kuid(ns, euid);
503
504 if ((ruid != (uid_t) -1) && !uid_valid(kruid))
505 return -EINVAL;
506 if ((euid != (uid_t) -1) && !uid_valid(keuid))
507 return -EINVAL;
508
509 new = prepare_creds();
510 if (!new)
511 return -ENOMEM;
512 old = current_cred();
513
514 retval = -EPERM;
515 if (ruid != (uid_t) -1) {
516 new->uid = kruid;
517 if (!uid_eq(old->uid, kruid) &&
518 !uid_eq(old->euid, kruid) &&
519 !ns_capable_setid(old->user_ns, CAP_SETUID))
520 goto error;
521 }
522
523 if (euid != (uid_t) -1) {
524 new->euid = keuid;
525 if (!uid_eq(old->uid, keuid) &&
526 !uid_eq(old->euid, keuid) &&
527 !uid_eq(old->suid, keuid) &&
528 !ns_capable_setid(old->user_ns, CAP_SETUID))
529 goto error;
530 }
531
532 if (!uid_eq(new->uid, old->uid)) {
533 retval = set_user(new);
534 if (retval < 0)
535 goto error;
536 }
537 if (ruid != (uid_t) -1 ||
538 (euid != (uid_t) -1 && !uid_eq(keuid, old->uid)))
539 new->suid = new->euid;
540 new->fsuid = new->euid;
541
542 retval = security_task_fix_setuid(new, old, LSM_SETID_RE);
543 if (retval < 0)
544 goto error;
545
546 return commit_creds(new);
547
548error:
549 abort_creds(new);
550 return retval;
551}
552
553SYSCALL_DEFINE2(setreuid, uid_t, ruid, uid_t, euid)
554{
555 return __sys_setreuid(ruid, euid);
556}
557
558
559
560
561
562
563
564
565
566
567
568
569long __sys_setuid(uid_t uid)
570{
571 struct user_namespace *ns = current_user_ns();
572 const struct cred *old;
573 struct cred *new;
574 int retval;
575 kuid_t kuid;
576
577 kuid = make_kuid(ns, uid);
578 if (!uid_valid(kuid))
579 return -EINVAL;
580
581 new = prepare_creds();
582 if (!new)
583 return -ENOMEM;
584 old = current_cred();
585
586 retval = -EPERM;
587 if (ns_capable_setid(old->user_ns, CAP_SETUID)) {
588 new->suid = new->uid = kuid;
589 if (!uid_eq(kuid, old->uid)) {
590 retval = set_user(new);
591 if (retval < 0)
592 goto error;
593 }
594 } else if (!uid_eq(kuid, old->uid) && !uid_eq(kuid, new->suid)) {
595 goto error;
596 }
597
598 new->fsuid = new->euid = kuid;
599
600 retval = security_task_fix_setuid(new, old, LSM_SETID_ID);
601 if (retval < 0)
602 goto error;
603
604 return commit_creds(new);
605
606error:
607 abort_creds(new);
608 return retval;
609}
610
611SYSCALL_DEFINE1(setuid, uid_t, uid)
612{
613 return __sys_setuid(uid);
614}
615
616
617
618
619
620
621long __sys_setresuid(uid_t ruid, uid_t euid, uid_t suid)
622{
623 struct user_namespace *ns = current_user_ns();
624 const struct cred *old;
625 struct cred *new;
626 int retval;
627 kuid_t kruid, keuid, ksuid;
628
629 kruid = make_kuid(ns, ruid);
630 keuid = make_kuid(ns, euid);
631 ksuid = make_kuid(ns, suid);
632
633 if ((ruid != (uid_t) -1) && !uid_valid(kruid))
634 return -EINVAL;
635
636 if ((euid != (uid_t) -1) && !uid_valid(keuid))
637 return -EINVAL;
638
639 if ((suid != (uid_t) -1) && !uid_valid(ksuid))
640 return -EINVAL;
641
642 new = prepare_creds();
643 if (!new)
644 return -ENOMEM;
645
646 old = current_cred();
647
648 retval = -EPERM;
649 if (!ns_capable_setid(old->user_ns, CAP_SETUID)) {
650 if (ruid != (uid_t) -1 && !uid_eq(kruid, old->uid) &&
651 !uid_eq(kruid, old->euid) && !uid_eq(kruid, old->suid))
652 goto error;
653 if (euid != (uid_t) -1 && !uid_eq(keuid, old->uid) &&
654 !uid_eq(keuid, old->euid) && !uid_eq(keuid, old->suid))
655 goto error;
656 if (suid != (uid_t) -1 && !uid_eq(ksuid, old->uid) &&
657 !uid_eq(ksuid, old->euid) && !uid_eq(ksuid, old->suid))
658 goto error;
659 }
660
661 if (ruid != (uid_t) -1) {
662 new->uid = kruid;
663 if (!uid_eq(kruid, old->uid)) {
664 retval = set_user(new);
665 if (retval < 0)
666 goto error;
667 }
668 }
669 if (euid != (uid_t) -1)
670 new->euid = keuid;
671 if (suid != (uid_t) -1)
672 new->suid = ksuid;
673 new->fsuid = new->euid;
674
675 retval = security_task_fix_setuid(new, old, LSM_SETID_RES);
676 if (retval < 0)
677 goto error;
678
679 return commit_creds(new);
680
681error:
682 abort_creds(new);
683 return retval;
684}
685
686SYSCALL_DEFINE3(setresuid, uid_t, ruid, uid_t, euid, uid_t, suid)
687{
688 return __sys_setresuid(ruid, euid, suid);
689}
690
691SYSCALL_DEFINE3(getresuid, uid_t __user *, ruidp, uid_t __user *, euidp, uid_t __user *, suidp)
692{
693 const struct cred *cred = current_cred();
694 int retval;
695 uid_t ruid, euid, suid;
696
697 ruid = from_kuid_munged(cred->user_ns, cred->uid);
698 euid = from_kuid_munged(cred->user_ns, cred->euid);
699 suid = from_kuid_munged(cred->user_ns, cred->suid);
700
701 retval = put_user(ruid, ruidp);
702 if (!retval) {
703 retval = put_user(euid, euidp);
704 if (!retval)
705 return put_user(suid, suidp);
706 }
707 return retval;
708}
709
710
711
712
713long __sys_setresgid(gid_t rgid, gid_t egid, gid_t sgid)
714{
715 struct user_namespace *ns = current_user_ns();
716 const struct cred *old;
717 struct cred *new;
718 int retval;
719 kgid_t krgid, kegid, ksgid;
720
721 krgid = make_kgid(ns, rgid);
722 kegid = make_kgid(ns, egid);
723 ksgid = make_kgid(ns, sgid);
724
725 if ((rgid != (gid_t) -1) && !gid_valid(krgid))
726 return -EINVAL;
727 if ((egid != (gid_t) -1) && !gid_valid(kegid))
728 return -EINVAL;
729 if ((sgid != (gid_t) -1) && !gid_valid(ksgid))
730 return -EINVAL;
731
732 new = prepare_creds();
733 if (!new)
734 return -ENOMEM;
735 old = current_cred();
736
737 retval = -EPERM;
738 if (!ns_capable(old->user_ns, CAP_SETGID)) {
739 if (rgid != (gid_t) -1 && !gid_eq(krgid, old->gid) &&
740 !gid_eq(krgid, old->egid) && !gid_eq(krgid, old->sgid))
741 goto error;
742 if (egid != (gid_t) -1 && !gid_eq(kegid, old->gid) &&
743 !gid_eq(kegid, old->egid) && !gid_eq(kegid, old->sgid))
744 goto error;
745 if (sgid != (gid_t) -1 && !gid_eq(ksgid, old->gid) &&
746 !gid_eq(ksgid, old->egid) && !gid_eq(ksgid, old->sgid))
747 goto error;
748 }
749
750 if (rgid != (gid_t) -1)
751 new->gid = krgid;
752 if (egid != (gid_t) -1)
753 new->egid = kegid;
754 if (sgid != (gid_t) -1)
755 new->sgid = ksgid;
756 new->fsgid = new->egid;
757
758 return commit_creds(new);
759
760error:
761 abort_creds(new);
762 return retval;
763}
764
765SYSCALL_DEFINE3(setresgid, gid_t, rgid, gid_t, egid, gid_t, sgid)
766{
767 return __sys_setresgid(rgid, egid, sgid);
768}
769
770SYSCALL_DEFINE3(getresgid, gid_t __user *, rgidp, gid_t __user *, egidp, gid_t __user *, sgidp)
771{
772 const struct cred *cred = current_cred();
773 int retval;
774 gid_t rgid, egid, sgid;
775
776 rgid = from_kgid_munged(cred->user_ns, cred->gid);
777 egid = from_kgid_munged(cred->user_ns, cred->egid);
778 sgid = from_kgid_munged(cred->user_ns, cred->sgid);
779
780 retval = put_user(rgid, rgidp);
781 if (!retval) {
782 retval = put_user(egid, egidp);
783 if (!retval)
784 retval = put_user(sgid, sgidp);
785 }
786
787 return retval;
788}
789
790
791
792
793
794
795
796
797long __sys_setfsuid(uid_t uid)
798{
799 const struct cred *old;
800 struct cred *new;
801 uid_t old_fsuid;
802 kuid_t kuid;
803
804 old = current_cred();
805 old_fsuid = from_kuid_munged(old->user_ns, old->fsuid);
806
807 kuid = make_kuid(old->user_ns, uid);
808 if (!uid_valid(kuid))
809 return old_fsuid;
810
811 new = prepare_creds();
812 if (!new)
813 return old_fsuid;
814
815 if (uid_eq(kuid, old->uid) || uid_eq(kuid, old->euid) ||
816 uid_eq(kuid, old->suid) || uid_eq(kuid, old->fsuid) ||
817 ns_capable_setid(old->user_ns, CAP_SETUID)) {
818 if (!uid_eq(kuid, old->fsuid)) {
819 new->fsuid = kuid;
820 if (security_task_fix_setuid(new, old, LSM_SETID_FS) == 0)
821 goto change_okay;
822 }
823 }
824
825 abort_creds(new);
826 return old_fsuid;
827
828change_okay:
829 commit_creds(new);
830 return old_fsuid;
831}
832
833SYSCALL_DEFINE1(setfsuid, uid_t, uid)
834{
835 return __sys_setfsuid(uid);
836}
837
838
839
840
841long __sys_setfsgid(gid_t gid)
842{
843 const struct cred *old;
844 struct cred *new;
845 gid_t old_fsgid;
846 kgid_t kgid;
847
848 old = current_cred();
849 old_fsgid = from_kgid_munged(old->user_ns, old->fsgid);
850
851 kgid = make_kgid(old->user_ns, gid);
852 if (!gid_valid(kgid))
853 return old_fsgid;
854
855 new = prepare_creds();
856 if (!new)
857 return old_fsgid;
858
859 if (gid_eq(kgid, old->gid) || gid_eq(kgid, old->egid) ||
860 gid_eq(kgid, old->sgid) || gid_eq(kgid, old->fsgid) ||
861 ns_capable(old->user_ns, CAP_SETGID)) {
862 if (!gid_eq(kgid, old->fsgid)) {
863 new->fsgid = kgid;
864 goto change_okay;
865 }
866 }
867
868 abort_creds(new);
869 return old_fsgid;
870
871change_okay:
872 commit_creds(new);
873 return old_fsgid;
874}
875
876SYSCALL_DEFINE1(setfsgid, gid_t, gid)
877{
878 return __sys_setfsgid(gid);
879}
880#endif
881
882
883
884
885
886
887
888
889
890
891SYSCALL_DEFINE0(getpid)
892{
893 return task_tgid_vnr(current);
894}
895
896
897SYSCALL_DEFINE0(gettid)
898{
899 return task_pid_vnr(current);
900}
901
902
903
904
905
906
907
908SYSCALL_DEFINE0(getppid)
909{
910 int pid;
911
912 rcu_read_lock();
913 pid = task_tgid_vnr(rcu_dereference(current->real_parent));
914 rcu_read_unlock();
915
916 return pid;
917}
918
919SYSCALL_DEFINE0(getuid)
920{
921
922 return from_kuid_munged(current_user_ns(), current_uid());
923}
924
925SYSCALL_DEFINE0(geteuid)
926{
927
928 return from_kuid_munged(current_user_ns(), current_euid());
929}
930
931SYSCALL_DEFINE0(getgid)
932{
933
934 return from_kgid_munged(current_user_ns(), current_gid());
935}
936
937SYSCALL_DEFINE0(getegid)
938{
939
940 return from_kgid_munged(current_user_ns(), current_egid());
941}
942
943static void do_sys_times(struct tms *tms)
944{
945 u64 tgutime, tgstime, cutime, cstime;
946
947 thread_group_cputime_adjusted(current, &tgutime, &tgstime);
948 cutime = current->signal->cutime;
949 cstime = current->signal->cstime;
950 tms->tms_utime = nsec_to_clock_t(tgutime);
951 tms->tms_stime = nsec_to_clock_t(tgstime);
952 tms->tms_cutime = nsec_to_clock_t(cutime);
953 tms->tms_cstime = nsec_to_clock_t(cstime);
954}
955
956SYSCALL_DEFINE1(times, struct tms __user *, tbuf)
957{
958 if (tbuf) {
959 struct tms tmp;
960
961 do_sys_times(&tmp);
962 if (copy_to_user(tbuf, &tmp, sizeof(struct tms)))
963 return -EFAULT;
964 }
965 force_successful_syscall_return();
966 return (long) jiffies_64_to_clock_t(get_jiffies_64());
967}
968
969#ifdef CONFIG_COMPAT
970static compat_clock_t clock_t_to_compat_clock_t(clock_t x)
971{
972 return compat_jiffies_to_clock_t(clock_t_to_jiffies(x));
973}
974
975COMPAT_SYSCALL_DEFINE1(times, struct compat_tms __user *, tbuf)
976{
977 if (tbuf) {
978 struct tms tms;
979 struct compat_tms tmp;
980
981 do_sys_times(&tms);
982
983 tmp.tms_utime = clock_t_to_compat_clock_t(tms.tms_utime);
984 tmp.tms_stime = clock_t_to_compat_clock_t(tms.tms_stime);
985 tmp.tms_cutime = clock_t_to_compat_clock_t(tms.tms_cutime);
986 tmp.tms_cstime = clock_t_to_compat_clock_t(tms.tms_cstime);
987 if (copy_to_user(tbuf, &tmp, sizeof(tmp)))
988 return -EFAULT;
989 }
990 force_successful_syscall_return();
991 return compat_jiffies_to_clock_t(jiffies);
992}
993#endif
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006SYSCALL_DEFINE2(setpgid, pid_t, pid, pid_t, pgid)
1007{
1008 struct task_struct *p;
1009 struct task_struct *group_leader = current->group_leader;
1010 struct pid *pgrp;
1011 int err;
1012
1013 if (!pid)
1014 pid = task_pid_vnr(group_leader);
1015 if (!pgid)
1016 pgid = pid;
1017 if (pgid < 0)
1018 return -EINVAL;
1019 rcu_read_lock();
1020
1021
1022
1023
1024 write_lock_irq(&tasklist_lock);
1025
1026 err = -ESRCH;
1027 p = find_task_by_vpid(pid);
1028 if (!p)
1029 goto out;
1030
1031 err = -EINVAL;
1032 if (!thread_group_leader(p))
1033 goto out;
1034
1035 if (same_thread_group(p->real_parent, group_leader)) {
1036 err = -EPERM;
1037 if (task_session(p) != task_session(group_leader))
1038 goto out;
1039 err = -EACCES;
1040 if (!(p->flags & PF_FORKNOEXEC))
1041 goto out;
1042 } else {
1043 err = -ESRCH;
1044 if (p != group_leader)
1045 goto out;
1046 }
1047
1048 err = -EPERM;
1049 if (p->signal->leader)
1050 goto out;
1051
1052 pgrp = task_pid(p);
1053 if (pgid != pid) {
1054 struct task_struct *g;
1055
1056 pgrp = find_vpid(pgid);
1057 g = pid_task(pgrp, PIDTYPE_PGID);
1058 if (!g || task_session(g) != task_session(group_leader))
1059 goto out;
1060 }
1061
1062 err = security_task_setpgid(p, pgid);
1063 if (err)
1064 goto out;
1065
1066 if (task_pgrp(p) != pgrp)
1067 change_pid(p, PIDTYPE_PGID, pgrp);
1068
1069 err = 0;
1070out:
1071
1072 write_unlock_irq(&tasklist_lock);
1073 rcu_read_unlock();
1074 return err;
1075}
1076
1077static int do_getpgid(pid_t pid)
1078{
1079 struct task_struct *p;
1080 struct pid *grp;
1081 int retval;
1082
1083 rcu_read_lock();
1084 if (!pid)
1085 grp = task_pgrp(current);
1086 else {
1087 retval = -ESRCH;
1088 p = find_task_by_vpid(pid);
1089 if (!p)
1090 goto out;
1091 grp = task_pgrp(p);
1092 if (!grp)
1093 goto out;
1094
1095 retval = security_task_getpgid(p);
1096 if (retval)
1097 goto out;
1098 }
1099 retval = pid_vnr(grp);
1100out:
1101 rcu_read_unlock();
1102 return retval;
1103}
1104
1105SYSCALL_DEFINE1(getpgid, pid_t, pid)
1106{
1107 return do_getpgid(pid);
1108}
1109
1110#ifdef __ARCH_WANT_SYS_GETPGRP
1111
1112SYSCALL_DEFINE0(getpgrp)
1113{
1114 return do_getpgid(0);
1115}
1116
1117#endif
1118
1119SYSCALL_DEFINE1(getsid, pid_t, pid)
1120{
1121 struct task_struct *p;
1122 struct pid *sid;
1123 int retval;
1124
1125 rcu_read_lock();
1126 if (!pid)
1127 sid = task_session(current);
1128 else {
1129 retval = -ESRCH;
1130 p = find_task_by_vpid(pid);
1131 if (!p)
1132 goto out;
1133 sid = task_session(p);
1134 if (!sid)
1135 goto out;
1136
1137 retval = security_task_getsid(p);
1138 if (retval)
1139 goto out;
1140 }
1141 retval = pid_vnr(sid);
1142out:
1143 rcu_read_unlock();
1144 return retval;
1145}
1146
1147static void set_special_pids(struct pid *pid)
1148{
1149 struct task_struct *curr = current->group_leader;
1150
1151 if (task_session(curr) != pid)
1152 change_pid(curr, PIDTYPE_SID, pid);
1153
1154 if (task_pgrp(curr) != pid)
1155 change_pid(curr, PIDTYPE_PGID, pid);
1156}
1157
1158int ksys_setsid(void)
1159{
1160 struct task_struct *group_leader = current->group_leader;
1161 struct pid *sid = task_pid(group_leader);
1162 pid_t session = pid_vnr(sid);
1163 int err = -EPERM;
1164
1165 write_lock_irq(&tasklist_lock);
1166
1167 if (group_leader->signal->leader)
1168 goto out;
1169
1170
1171
1172
1173 if (pid_task(sid, PIDTYPE_PGID))
1174 goto out;
1175
1176 group_leader->signal->leader = 1;
1177 set_special_pids(sid);
1178
1179 proc_clear_tty(group_leader);
1180
1181 err = session;
1182out:
1183 write_unlock_irq(&tasklist_lock);
1184 if (err > 0) {
1185 proc_sid_connector(group_leader);
1186 sched_autogroup_create_attach(group_leader);
1187 }
1188 return err;
1189}
1190
1191SYSCALL_DEFINE0(setsid)
1192{
1193 return ksys_setsid();
1194}
1195
1196DECLARE_RWSEM(uts_sem);
1197
1198#ifdef COMPAT_UTS_MACHINE
1199#define override_architecture(name) \
1200 (personality(current->personality) == PER_LINUX32 && \
1201 copy_to_user(name->machine, COMPAT_UTS_MACHINE, \
1202 sizeof(COMPAT_UTS_MACHINE)))
1203#else
1204#define override_architecture(name) 0
1205#endif
1206
1207
1208
1209
1210
1211
1212
1213static int override_release(char __user *release, size_t len)
1214{
1215 int ret = 0;
1216
1217 if (current->personality & UNAME26) {
1218 const char *rest = UTS_RELEASE;
1219 char buf[65] = { 0 };
1220 int ndots = 0;
1221 unsigned v;
1222 size_t copy;
1223
1224 while (*rest) {
1225 if (*rest == '.' && ++ndots >= 3)
1226 break;
1227 if (!isdigit(*rest) && *rest != '.')
1228 break;
1229 rest++;
1230 }
1231 v = ((LINUX_VERSION_CODE >> 8) & 0xff) + 60;
1232 copy = clamp_t(size_t, len, 1, sizeof(buf));
1233 copy = scnprintf(buf, copy, "2.6.%u%s", v, rest);
1234 ret = copy_to_user(release, buf, copy + 1);
1235 }
1236 return ret;
1237}
1238
1239SYSCALL_DEFINE1(newuname, struct new_utsname __user *, name)
1240{
1241 struct new_utsname tmp;
1242
1243 down_read(&uts_sem);
1244 memcpy(&tmp, utsname(), sizeof(tmp));
1245 up_read(&uts_sem);
1246 if (copy_to_user(name, &tmp, sizeof(tmp)))
1247 return -EFAULT;
1248
1249 if (override_release(name->release, sizeof(name->release)))
1250 return -EFAULT;
1251 if (override_architecture(name))
1252 return -EFAULT;
1253 return 0;
1254}
1255
1256#ifdef __ARCH_WANT_SYS_OLD_UNAME
1257
1258
1259
1260SYSCALL_DEFINE1(uname, struct old_utsname __user *, name)
1261{
1262 struct old_utsname tmp;
1263
1264 if (!name)
1265 return -EFAULT;
1266
1267 down_read(&uts_sem);
1268 memcpy(&tmp, utsname(), sizeof(tmp));
1269 up_read(&uts_sem);
1270 if (copy_to_user(name, &tmp, sizeof(tmp)))
1271 return -EFAULT;
1272
1273 if (override_release(name->release, sizeof(name->release)))
1274 return -EFAULT;
1275 if (override_architecture(name))
1276 return -EFAULT;
1277 return 0;
1278}
1279
1280SYSCALL_DEFINE1(olduname, struct oldold_utsname __user *, name)
1281{
1282 struct oldold_utsname tmp = {};
1283
1284 if (!name)
1285 return -EFAULT;
1286
1287 down_read(&uts_sem);
1288 memcpy(&tmp.sysname, &utsname()->sysname, __OLD_UTS_LEN);
1289 memcpy(&tmp.nodename, &utsname()->nodename, __OLD_UTS_LEN);
1290 memcpy(&tmp.release, &utsname()->release, __OLD_UTS_LEN);
1291 memcpy(&tmp.version, &utsname()->version, __OLD_UTS_LEN);
1292 memcpy(&tmp.machine, &utsname()->machine, __OLD_UTS_LEN);
1293 up_read(&uts_sem);
1294 if (copy_to_user(name, &tmp, sizeof(tmp)))
1295 return -EFAULT;
1296
1297 if (override_architecture(name))
1298 return -EFAULT;
1299 if (override_release(name->release, sizeof(name->release)))
1300 return -EFAULT;
1301 return 0;
1302}
1303#endif
1304
1305SYSCALL_DEFINE2(sethostname, char __user *, name, int, len)
1306{
1307 int errno;
1308 char tmp[__NEW_UTS_LEN];
1309
1310 if (!ns_capable(current->nsproxy->uts_ns->user_ns, CAP_SYS_ADMIN))
1311 return -EPERM;
1312
1313 if (len < 0 || len > __NEW_UTS_LEN)
1314 return -EINVAL;
1315 errno = -EFAULT;
1316 if (!copy_from_user(tmp, name, len)) {
1317 struct new_utsname *u;
1318
1319 down_write(&uts_sem);
1320 u = utsname();
1321 memcpy(u->nodename, tmp, len);
1322 memset(u->nodename + len, 0, sizeof(u->nodename) - len);
1323 errno = 0;
1324 uts_proc_notify(UTS_PROC_HOSTNAME);
1325 up_write(&uts_sem);
1326 }
1327 return errno;
1328}
1329
1330#ifdef __ARCH_WANT_SYS_GETHOSTNAME
1331
1332SYSCALL_DEFINE2(gethostname, char __user *, name, int, len)
1333{
1334 int i;
1335 struct new_utsname *u;
1336 char tmp[__NEW_UTS_LEN + 1];
1337
1338 if (len < 0)
1339 return -EINVAL;
1340 down_read(&uts_sem);
1341 u = utsname();
1342 i = 1 + strlen(u->nodename);
1343 if (i > len)
1344 i = len;
1345 memcpy(tmp, u->nodename, i);
1346 up_read(&uts_sem);
1347 if (copy_to_user(name, tmp, i))
1348 return -EFAULT;
1349 return 0;
1350}
1351
1352#endif
1353
1354
1355
1356
1357
1358SYSCALL_DEFINE2(setdomainname, char __user *, name, int, len)
1359{
1360 int errno;
1361 char tmp[__NEW_UTS_LEN];
1362
1363 if (!ns_capable(current->nsproxy->uts_ns->user_ns, CAP_SYS_ADMIN))
1364 return -EPERM;
1365 if (len < 0 || len > __NEW_UTS_LEN)
1366 return -EINVAL;
1367
1368 errno = -EFAULT;
1369 if (!copy_from_user(tmp, name, len)) {
1370 struct new_utsname *u;
1371
1372 down_write(&uts_sem);
1373 u = utsname();
1374 memcpy(u->domainname, tmp, len);
1375 memset(u->domainname + len, 0, sizeof(u->domainname) - len);
1376 errno = 0;
1377 uts_proc_notify(UTS_PROC_DOMAINNAME);
1378 up_write(&uts_sem);
1379 }
1380 return errno;
1381}
1382
1383SYSCALL_DEFINE2(getrlimit, unsigned int, resource, struct rlimit __user *, rlim)
1384{
1385 struct rlimit value;
1386 int ret;
1387
1388 ret = do_prlimit(current, resource, NULL, &value);
1389 if (!ret)
1390 ret = copy_to_user(rlim, &value, sizeof(*rlim)) ? -EFAULT : 0;
1391
1392 return ret;
1393}
1394
1395#ifdef CONFIG_COMPAT
1396
1397COMPAT_SYSCALL_DEFINE2(setrlimit, unsigned int, resource,
1398 struct compat_rlimit __user *, rlim)
1399{
1400 struct rlimit r;
1401 struct compat_rlimit r32;
1402
1403 if (copy_from_user(&r32, rlim, sizeof(struct compat_rlimit)))
1404 return -EFAULT;
1405
1406 if (r32.rlim_cur == COMPAT_RLIM_INFINITY)
1407 r.rlim_cur = RLIM_INFINITY;
1408 else
1409 r.rlim_cur = r32.rlim_cur;
1410 if (r32.rlim_max == COMPAT_RLIM_INFINITY)
1411 r.rlim_max = RLIM_INFINITY;
1412 else
1413 r.rlim_max = r32.rlim_max;
1414 return do_prlimit(current, resource, &r, NULL);
1415}
1416
1417COMPAT_SYSCALL_DEFINE2(getrlimit, unsigned int, resource,
1418 struct compat_rlimit __user *, rlim)
1419{
1420 struct rlimit r;
1421 int ret;
1422
1423 ret = do_prlimit(current, resource, NULL, &r);
1424 if (!ret) {
1425 struct compat_rlimit r32;
1426 if (r.rlim_cur > COMPAT_RLIM_INFINITY)
1427 r32.rlim_cur = COMPAT_RLIM_INFINITY;
1428 else
1429 r32.rlim_cur = r.rlim_cur;
1430 if (r.rlim_max > COMPAT_RLIM_INFINITY)
1431 r32.rlim_max = COMPAT_RLIM_INFINITY;
1432 else
1433 r32.rlim_max = r.rlim_max;
1434
1435 if (copy_to_user(rlim, &r32, sizeof(struct compat_rlimit)))
1436 return -EFAULT;
1437 }
1438 return ret;
1439}
1440
1441#endif
1442
1443#ifdef __ARCH_WANT_SYS_OLD_GETRLIMIT
1444
1445
1446
1447
1448SYSCALL_DEFINE2(old_getrlimit, unsigned int, resource,
1449 struct rlimit __user *, rlim)
1450{
1451 struct rlimit x;
1452 if (resource >= RLIM_NLIMITS)
1453 return -EINVAL;
1454
1455 resource = array_index_nospec(resource, RLIM_NLIMITS);
1456 task_lock(current->group_leader);
1457 x = current->signal->rlim[resource];
1458 task_unlock(current->group_leader);
1459 if (x.rlim_cur > 0x7FFFFFFF)
1460 x.rlim_cur = 0x7FFFFFFF;
1461 if (x.rlim_max > 0x7FFFFFFF)
1462 x.rlim_max = 0x7FFFFFFF;
1463 return copy_to_user(rlim, &x, sizeof(x)) ? -EFAULT : 0;
1464}
1465
1466#ifdef CONFIG_COMPAT
1467COMPAT_SYSCALL_DEFINE2(old_getrlimit, unsigned int, resource,
1468 struct compat_rlimit __user *, rlim)
1469{
1470 struct rlimit r;
1471
1472 if (resource >= RLIM_NLIMITS)
1473 return -EINVAL;
1474
1475 resource = array_index_nospec(resource, RLIM_NLIMITS);
1476 task_lock(current->group_leader);
1477 r = current->signal->rlim[resource];
1478 task_unlock(current->group_leader);
1479 if (r.rlim_cur > 0x7FFFFFFF)
1480 r.rlim_cur = 0x7FFFFFFF;
1481 if (r.rlim_max > 0x7FFFFFFF)
1482 r.rlim_max = 0x7FFFFFFF;
1483
1484 if (put_user(r.rlim_cur, &rlim->rlim_cur) ||
1485 put_user(r.rlim_max, &rlim->rlim_max))
1486 return -EFAULT;
1487 return 0;
1488}
1489#endif
1490
1491#endif
1492
1493static inline bool rlim64_is_infinity(__u64 rlim64)
1494{
1495#if BITS_PER_LONG < 64
1496 return rlim64 >= ULONG_MAX;
1497#else
1498 return rlim64 == RLIM64_INFINITY;
1499#endif
1500}
1501
1502static void rlim_to_rlim64(const struct rlimit *rlim, struct rlimit64 *rlim64)
1503{
1504 if (rlim->rlim_cur == RLIM_INFINITY)
1505 rlim64->rlim_cur = RLIM64_INFINITY;
1506 else
1507 rlim64->rlim_cur = rlim->rlim_cur;
1508 if (rlim->rlim_max == RLIM_INFINITY)
1509 rlim64->rlim_max = RLIM64_INFINITY;
1510 else
1511 rlim64->rlim_max = rlim->rlim_max;
1512}
1513
1514static void rlim64_to_rlim(const struct rlimit64 *rlim64, struct rlimit *rlim)
1515{
1516 if (rlim64_is_infinity(rlim64->rlim_cur))
1517 rlim->rlim_cur = RLIM_INFINITY;
1518 else
1519 rlim->rlim_cur = (unsigned long)rlim64->rlim_cur;
1520 if (rlim64_is_infinity(rlim64->rlim_max))
1521 rlim->rlim_max = RLIM_INFINITY;
1522 else
1523 rlim->rlim_max = (unsigned long)rlim64->rlim_max;
1524}
1525
1526
1527int do_prlimit(struct task_struct *tsk, unsigned int resource,
1528 struct rlimit *new_rlim, struct rlimit *old_rlim)
1529{
1530 struct rlimit *rlim;
1531 int retval = 0;
1532
1533 if (resource >= RLIM_NLIMITS)
1534 return -EINVAL;
1535 if (new_rlim) {
1536 if (new_rlim->rlim_cur > new_rlim->rlim_max)
1537 return -EINVAL;
1538 if (resource == RLIMIT_NOFILE &&
1539 new_rlim->rlim_max > sysctl_nr_open)
1540 return -EPERM;
1541 }
1542
1543
1544 read_lock(&tasklist_lock);
1545 if (!tsk->sighand) {
1546 retval = -ESRCH;
1547 goto out;
1548 }
1549
1550 rlim = tsk->signal->rlim + resource;
1551 task_lock(tsk->group_leader);
1552 if (new_rlim) {
1553
1554
1555 if (new_rlim->rlim_max > rlim->rlim_max &&
1556 !capable(CAP_SYS_RESOURCE))
1557 retval = -EPERM;
1558 if (!retval)
1559 retval = security_task_setrlimit(tsk, resource, new_rlim);
1560 if (resource == RLIMIT_CPU && new_rlim->rlim_cur == 0) {
1561
1562
1563
1564
1565
1566
1567 new_rlim->rlim_cur = 1;
1568 }
1569 }
1570 if (!retval) {
1571 if (old_rlim)
1572 *old_rlim = *rlim;
1573 if (new_rlim)
1574 *rlim = *new_rlim;
1575 }
1576 task_unlock(tsk->group_leader);
1577
1578
1579
1580
1581
1582
1583
1584 if (!retval && new_rlim && resource == RLIMIT_CPU &&
1585 new_rlim->rlim_cur != RLIM_INFINITY &&
1586 IS_ENABLED(CONFIG_POSIX_TIMERS))
1587 update_rlimit_cpu(tsk, new_rlim->rlim_cur);
1588out:
1589 read_unlock(&tasklist_lock);
1590 return retval;
1591}
1592
1593
1594static int check_prlimit_permission(struct task_struct *task,
1595 unsigned int flags)
1596{
1597 const struct cred *cred = current_cred(), *tcred;
1598 bool id_match;
1599
1600 if (current == task)
1601 return 0;
1602
1603 tcred = __task_cred(task);
1604 id_match = (uid_eq(cred->uid, tcred->euid) &&
1605 uid_eq(cred->uid, tcred->suid) &&
1606 uid_eq(cred->uid, tcred->uid) &&
1607 gid_eq(cred->gid, tcred->egid) &&
1608 gid_eq(cred->gid, tcred->sgid) &&
1609 gid_eq(cred->gid, tcred->gid));
1610 if (!id_match && !ns_capable(tcred->user_ns, CAP_SYS_RESOURCE))
1611 return -EPERM;
1612
1613 return security_task_prlimit(cred, tcred, flags);
1614}
1615
1616SYSCALL_DEFINE4(prlimit64, pid_t, pid, unsigned int, resource,
1617 const struct rlimit64 __user *, new_rlim,
1618 struct rlimit64 __user *, old_rlim)
1619{
1620 struct rlimit64 old64, new64;
1621 struct rlimit old, new;
1622 struct task_struct *tsk;
1623 unsigned int checkflags = 0;
1624 int ret;
1625
1626 if (old_rlim)
1627 checkflags |= LSM_PRLIMIT_READ;
1628
1629 if (new_rlim) {
1630 if (copy_from_user(&new64, new_rlim, sizeof(new64)))
1631 return -EFAULT;
1632 rlim64_to_rlim(&new64, &new);
1633 checkflags |= LSM_PRLIMIT_WRITE;
1634 }
1635
1636 rcu_read_lock();
1637 tsk = pid ? find_task_by_vpid(pid) : current;
1638 if (!tsk) {
1639 rcu_read_unlock();
1640 return -ESRCH;
1641 }
1642 ret = check_prlimit_permission(tsk, checkflags);
1643 if (ret) {
1644 rcu_read_unlock();
1645 return ret;
1646 }
1647 get_task_struct(tsk);
1648 rcu_read_unlock();
1649
1650 ret = do_prlimit(tsk, resource, new_rlim ? &new : NULL,
1651 old_rlim ? &old : NULL);
1652
1653 if (!ret && old_rlim) {
1654 rlim_to_rlim64(&old, &old64);
1655 if (copy_to_user(old_rlim, &old64, sizeof(old64)))
1656 ret = -EFAULT;
1657 }
1658
1659 put_task_struct(tsk);
1660 return ret;
1661}
1662
1663SYSCALL_DEFINE2(setrlimit, unsigned int, resource, struct rlimit __user *, rlim)
1664{
1665 struct rlimit new_rlim;
1666
1667 if (copy_from_user(&new_rlim, rlim, sizeof(*rlim)))
1668 return -EFAULT;
1669 return do_prlimit(current, resource, &new_rlim, NULL);
1670}
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705static void accumulate_thread_rusage(struct task_struct *t, struct rusage *r)
1706{
1707 r->ru_nvcsw += t->nvcsw;
1708 r->ru_nivcsw += t->nivcsw;
1709 r->ru_minflt += t->min_flt;
1710 r->ru_majflt += t->maj_flt;
1711 r->ru_inblock += task_io_get_inblock(t);
1712 r->ru_oublock += task_io_get_oublock(t);
1713}
1714
1715void getrusage(struct task_struct *p, int who, struct rusage *r)
1716{
1717 struct task_struct *t;
1718 unsigned long flags;
1719 u64 tgutime, tgstime, utime, stime;
1720 unsigned long maxrss = 0;
1721
1722 memset((char *)r, 0, sizeof (*r));
1723 utime = stime = 0;
1724
1725 if (who == RUSAGE_THREAD) {
1726 task_cputime_adjusted(current, &utime, &stime);
1727 accumulate_thread_rusage(p, r);
1728 maxrss = p->signal->maxrss;
1729 goto out;
1730 }
1731
1732 if (!lock_task_sighand(p, &flags))
1733 return;
1734
1735 switch (who) {
1736 case RUSAGE_BOTH:
1737 case RUSAGE_CHILDREN:
1738 utime = p->signal->cutime;
1739 stime = p->signal->cstime;
1740 r->ru_nvcsw = p->signal->cnvcsw;
1741 r->ru_nivcsw = p->signal->cnivcsw;
1742 r->ru_minflt = p->signal->cmin_flt;
1743 r->ru_majflt = p->signal->cmaj_flt;
1744 r->ru_inblock = p->signal->cinblock;
1745 r->ru_oublock = p->signal->coublock;
1746 maxrss = p->signal->cmaxrss;
1747
1748 if (who == RUSAGE_CHILDREN)
1749 break;
1750
1751
1752 case RUSAGE_SELF:
1753 thread_group_cputime_adjusted(p, &tgutime, &tgstime);
1754 utime += tgutime;
1755 stime += tgstime;
1756 r->ru_nvcsw += p->signal->nvcsw;
1757 r->ru_nivcsw += p->signal->nivcsw;
1758 r->ru_minflt += p->signal->min_flt;
1759 r->ru_majflt += p->signal->maj_flt;
1760 r->ru_inblock += p->signal->inblock;
1761 r->ru_oublock += p->signal->oublock;
1762 if (maxrss < p->signal->maxrss)
1763 maxrss = p->signal->maxrss;
1764 t = p;
1765 do {
1766 accumulate_thread_rusage(t, r);
1767 } while_each_thread(p, t);
1768 break;
1769
1770 default:
1771 BUG();
1772 }
1773 unlock_task_sighand(p, &flags);
1774
1775out:
1776 r->ru_utime = ns_to_timeval(utime);
1777 r->ru_stime = ns_to_timeval(stime);
1778
1779 if (who != RUSAGE_CHILDREN) {
1780 struct mm_struct *mm = get_task_mm(p);
1781
1782 if (mm) {
1783 setmax_mm_hiwater_rss(&maxrss, mm);
1784 mmput(mm);
1785 }
1786 }
1787 r->ru_maxrss = maxrss * (PAGE_SIZE / 1024);
1788}
1789
1790SYSCALL_DEFINE2(getrusage, int, who, struct rusage __user *, ru)
1791{
1792 struct rusage r;
1793
1794 if (who != RUSAGE_SELF && who != RUSAGE_CHILDREN &&
1795 who != RUSAGE_THREAD)
1796 return -EINVAL;
1797
1798 getrusage(current, who, &r);
1799 return copy_to_user(ru, &r, sizeof(r)) ? -EFAULT : 0;
1800}
1801
1802#ifdef CONFIG_COMPAT
1803COMPAT_SYSCALL_DEFINE2(getrusage, int, who, struct compat_rusage __user *, ru)
1804{
1805 struct rusage r;
1806
1807 if (who != RUSAGE_SELF && who != RUSAGE_CHILDREN &&
1808 who != RUSAGE_THREAD)
1809 return -EINVAL;
1810
1811 getrusage(current, who, &r);
1812 return put_compat_rusage(&r, ru);
1813}
1814#endif
1815
1816SYSCALL_DEFINE1(umask, int, mask)
1817{
1818 mask = xchg(¤t->fs->umask, mask & S_IRWXUGO);
1819 return mask;
1820}
1821
1822static int prctl_set_mm_exe_file(struct mm_struct *mm, unsigned int fd)
1823{
1824 struct fd exe;
1825 struct file *old_exe, *exe_file;
1826 struct inode *inode;
1827 int err;
1828
1829 exe = fdget(fd);
1830 if (!exe.file)
1831 return -EBADF;
1832
1833 inode = file_inode(exe.file);
1834
1835
1836
1837
1838
1839
1840 err = -EACCES;
1841 if (!S_ISREG(inode->i_mode) || path_noexec(&exe.file->f_path))
1842 goto exit;
1843
1844 err = inode_permission(inode, MAY_EXEC);
1845 if (err)
1846 goto exit;
1847
1848
1849
1850
1851 exe_file = get_mm_exe_file(mm);
1852 err = -EBUSY;
1853 if (exe_file) {
1854 struct vm_area_struct *vma;
1855
1856 down_read(&mm->mmap_sem);
1857 for (vma = mm->mmap; vma; vma = vma->vm_next) {
1858 if (!vma->vm_file)
1859 continue;
1860 if (path_equal(&vma->vm_file->f_path,
1861 &exe_file->f_path))
1862 goto exit_err;
1863 }
1864
1865 up_read(&mm->mmap_sem);
1866 fput(exe_file);
1867 }
1868
1869 err = 0;
1870
1871 get_file(exe.file);
1872 old_exe = xchg(&mm->exe_file, exe.file);
1873 if (old_exe)
1874 fput(old_exe);
1875exit:
1876 fdput(exe);
1877 return err;
1878exit_err:
1879 up_read(&mm->mmap_sem);
1880 fput(exe_file);
1881 goto exit;
1882}
1883
1884
1885
1886
1887
1888
1889
1890static int validate_prctl_map_addr(struct prctl_mm_map *prctl_map)
1891{
1892 unsigned long mmap_max_addr = TASK_SIZE;
1893 int error = -EINVAL, i;
1894
1895 static const unsigned char offsets[] = {
1896 offsetof(struct prctl_mm_map, start_code),
1897 offsetof(struct prctl_mm_map, end_code),
1898 offsetof(struct prctl_mm_map, start_data),
1899 offsetof(struct prctl_mm_map, end_data),
1900 offsetof(struct prctl_mm_map, start_brk),
1901 offsetof(struct prctl_mm_map, brk),
1902 offsetof(struct prctl_mm_map, start_stack),
1903 offsetof(struct prctl_mm_map, arg_start),
1904 offsetof(struct prctl_mm_map, arg_end),
1905 offsetof(struct prctl_mm_map, env_start),
1906 offsetof(struct prctl_mm_map, env_end),
1907 };
1908
1909
1910
1911
1912
1913 for (i = 0; i < ARRAY_SIZE(offsets); i++) {
1914 u64 val = *(u64 *)((char *)prctl_map + offsets[i]);
1915
1916 if ((unsigned long)val >= mmap_max_addr ||
1917 (unsigned long)val < mmap_min_addr)
1918 goto out;
1919 }
1920
1921
1922
1923
1924#define __prctl_check_order(__m1, __op, __m2) \
1925 ((unsigned long)prctl_map->__m1 __op \
1926 (unsigned long)prctl_map->__m2) ? 0 : -EINVAL
1927 error = __prctl_check_order(start_code, <, end_code);
1928 error |= __prctl_check_order(start_data,<=, end_data);
1929 error |= __prctl_check_order(start_brk, <=, brk);
1930 error |= __prctl_check_order(arg_start, <=, arg_end);
1931 error |= __prctl_check_order(env_start, <=, env_end);
1932 if (error)
1933 goto out;
1934#undef __prctl_check_order
1935
1936 error = -EINVAL;
1937
1938
1939
1940
1941 if (prctl_map->start_brk <= prctl_map->end_data ||
1942 prctl_map->brk <= prctl_map->end_data)
1943 goto out;
1944
1945
1946
1947
1948 if (check_data_rlimit(rlimit(RLIMIT_DATA), prctl_map->brk,
1949 prctl_map->start_brk, prctl_map->end_data,
1950 prctl_map->start_data))
1951 goto out;
1952
1953 error = 0;
1954out:
1955 return error;
1956}
1957
1958#ifdef CONFIG_CHECKPOINT_RESTORE
1959static int prctl_set_mm_map(int opt, const void __user *addr, unsigned long data_size)
1960{
1961 struct prctl_mm_map prctl_map = { .exe_fd = (u32)-1, };
1962 unsigned long user_auxv[AT_VECTOR_SIZE];
1963 struct mm_struct *mm = current->mm;
1964 int error;
1965
1966 BUILD_BUG_ON(sizeof(user_auxv) != sizeof(mm->saved_auxv));
1967 BUILD_BUG_ON(sizeof(struct prctl_mm_map) > 256);
1968
1969 if (opt == PR_SET_MM_MAP_SIZE)
1970 return put_user((unsigned int)sizeof(prctl_map),
1971 (unsigned int __user *)addr);
1972
1973 if (data_size != sizeof(prctl_map))
1974 return -EINVAL;
1975
1976 if (copy_from_user(&prctl_map, addr, sizeof(prctl_map)))
1977 return -EFAULT;
1978
1979 error = validate_prctl_map_addr(&prctl_map);
1980 if (error)
1981 return error;
1982
1983 if (prctl_map.auxv_size) {
1984
1985
1986
1987 if (!prctl_map.auxv ||
1988 prctl_map.auxv_size > sizeof(mm->saved_auxv))
1989 return -EINVAL;
1990
1991 memset(user_auxv, 0, sizeof(user_auxv));
1992 if (copy_from_user(user_auxv,
1993 (const void __user *)prctl_map.auxv,
1994 prctl_map.auxv_size))
1995 return -EFAULT;
1996
1997
1998 user_auxv[AT_VECTOR_SIZE - 2] = AT_NULL;
1999 user_auxv[AT_VECTOR_SIZE - 1] = AT_NULL;
2000 }
2001
2002 if (prctl_map.exe_fd != (u32)-1) {
2003
2004
2005
2006
2007
2008 if (!ns_capable(current_user_ns(), CAP_SYS_ADMIN))
2009 return -EINVAL;
2010
2011 error = prctl_set_mm_exe_file(mm, prctl_map.exe_fd);
2012 if (error)
2013 return error;
2014 }
2015
2016
2017
2018
2019
2020 down_read(&mm->mmap_sem);
2021
2022
2023
2024
2025
2026
2027
2028
2029
2030
2031
2032
2033
2034 spin_lock(&mm->arg_lock);
2035 mm->start_code = prctl_map.start_code;
2036 mm->end_code = prctl_map.end_code;
2037 mm->start_data = prctl_map.start_data;
2038 mm->end_data = prctl_map.end_data;
2039 mm->start_brk = prctl_map.start_brk;
2040 mm->brk = prctl_map.brk;
2041 mm->start_stack = prctl_map.start_stack;
2042 mm->arg_start = prctl_map.arg_start;
2043 mm->arg_end = prctl_map.arg_end;
2044 mm->env_start = prctl_map.env_start;
2045 mm->env_end = prctl_map.env_end;
2046 spin_unlock(&mm->arg_lock);
2047
2048
2049
2050
2051
2052
2053
2054
2055
2056 if (prctl_map.auxv_size)
2057 memcpy(mm->saved_auxv, user_auxv, sizeof(user_auxv));
2058
2059 up_read(&mm->mmap_sem);
2060 return 0;
2061}
2062#endif
2063
2064static int prctl_set_auxv(struct mm_struct *mm, unsigned long addr,
2065 unsigned long len)
2066{
2067
2068
2069
2070
2071
2072
2073 unsigned long user_auxv[AT_VECTOR_SIZE];
2074
2075 if (len > sizeof(user_auxv))
2076 return -EINVAL;
2077
2078 if (copy_from_user(user_auxv, (const void __user *)addr, len))
2079 return -EFAULT;
2080
2081
2082 user_auxv[AT_VECTOR_SIZE - 2] = 0;
2083 user_auxv[AT_VECTOR_SIZE - 1] = 0;
2084
2085 BUILD_BUG_ON(sizeof(user_auxv) != sizeof(mm->saved_auxv));
2086
2087 task_lock(current);
2088 memcpy(mm->saved_auxv, user_auxv, len);
2089 task_unlock(current);
2090
2091 return 0;
2092}
2093
2094static int prctl_set_mm(int opt, unsigned long addr,
2095 unsigned long arg4, unsigned long arg5)
2096{
2097 struct mm_struct *mm = current->mm;
2098 struct prctl_mm_map prctl_map = {
2099 .auxv = NULL,
2100 .auxv_size = 0,
2101 .exe_fd = -1,
2102 };
2103 struct vm_area_struct *vma;
2104 int error;
2105
2106 if (arg5 || (arg4 && (opt != PR_SET_MM_AUXV &&
2107 opt != PR_SET_MM_MAP &&
2108 opt != PR_SET_MM_MAP_SIZE)))
2109 return -EINVAL;
2110
2111#ifdef CONFIG_CHECKPOINT_RESTORE
2112 if (opt == PR_SET_MM_MAP || opt == PR_SET_MM_MAP_SIZE)
2113 return prctl_set_mm_map(opt, (const void __user *)addr, arg4);
2114#endif
2115
2116 if (!capable(CAP_SYS_RESOURCE))
2117 return -EPERM;
2118
2119 if (opt == PR_SET_MM_EXE_FILE)
2120 return prctl_set_mm_exe_file(mm, (unsigned int)addr);
2121
2122 if (opt == PR_SET_MM_AUXV)
2123 return prctl_set_auxv(mm, addr, arg4);
2124
2125 if (addr >= TASK_SIZE || addr < mmap_min_addr)
2126 return -EINVAL;
2127
2128 error = -EINVAL;
2129
2130
2131
2132
2133
2134
2135 down_read(&mm->mmap_sem);
2136 vma = find_vma(mm, addr);
2137
2138 spin_lock(&mm->arg_lock);
2139 prctl_map.start_code = mm->start_code;
2140 prctl_map.end_code = mm->end_code;
2141 prctl_map.start_data = mm->start_data;
2142 prctl_map.end_data = mm->end_data;
2143 prctl_map.start_brk = mm->start_brk;
2144 prctl_map.brk = mm->brk;
2145 prctl_map.start_stack = mm->start_stack;
2146 prctl_map.arg_start = mm->arg_start;
2147 prctl_map.arg_end = mm->arg_end;
2148 prctl_map.env_start = mm->env_start;
2149 prctl_map.env_end = mm->env_end;
2150
2151 switch (opt) {
2152 case PR_SET_MM_START_CODE:
2153 prctl_map.start_code = addr;
2154 break;
2155 case PR_SET_MM_END_CODE:
2156 prctl_map.end_code = addr;
2157 break;
2158 case PR_SET_MM_START_DATA:
2159 prctl_map.start_data = addr;
2160 break;
2161 case PR_SET_MM_END_DATA:
2162 prctl_map.end_data = addr;
2163 break;
2164 case PR_SET_MM_START_STACK:
2165 prctl_map.start_stack = addr;
2166 break;
2167 case PR_SET_MM_START_BRK:
2168 prctl_map.start_brk = addr;
2169 break;
2170 case PR_SET_MM_BRK:
2171 prctl_map.brk = addr;
2172 break;
2173 case PR_SET_MM_ARG_START:
2174 prctl_map.arg_start = addr;
2175 break;
2176 case PR_SET_MM_ARG_END:
2177 prctl_map.arg_end = addr;
2178 break;
2179 case PR_SET_MM_ENV_START:
2180 prctl_map.env_start = addr;
2181 break;
2182 case PR_SET_MM_ENV_END:
2183 prctl_map.env_end = addr;
2184 break;
2185 default:
2186 goto out;
2187 }
2188
2189 error = validate_prctl_map_addr(&prctl_map);
2190 if (error)
2191 goto out;
2192
2193 switch (opt) {
2194
2195
2196
2197
2198
2199
2200
2201 case PR_SET_MM_START_STACK:
2202 case PR_SET_MM_ARG_START:
2203 case PR_SET_MM_ARG_END:
2204 case PR_SET_MM_ENV_START:
2205 case PR_SET_MM_ENV_END:
2206 if (!vma) {
2207 error = -EFAULT;
2208 goto out;
2209 }
2210 }
2211
2212 mm->start_code = prctl_map.start_code;
2213 mm->end_code = prctl_map.end_code;
2214 mm->start_data = prctl_map.start_data;
2215 mm->end_data = prctl_map.end_data;
2216 mm->start_brk = prctl_map.start_brk;
2217 mm->brk = prctl_map.brk;
2218 mm->start_stack = prctl_map.start_stack;
2219 mm->arg_start = prctl_map.arg_start;
2220 mm->arg_end = prctl_map.arg_end;
2221 mm->env_start = prctl_map.env_start;
2222 mm->env_end = prctl_map.env_end;
2223
2224 error = 0;
2225out:
2226 spin_unlock(&mm->arg_lock);
2227 up_read(&mm->mmap_sem);
2228 return error;
2229}
2230
2231#ifdef CONFIG_CHECKPOINT_RESTORE
2232static int prctl_get_tid_address(struct task_struct *me, int __user **tid_addr)
2233{
2234 return put_user(me->clear_child_tid, tid_addr);
2235}
2236#else
2237static int prctl_get_tid_address(struct task_struct *me, int __user **tid_addr)
2238{
2239 return -EINVAL;
2240}
2241#endif
2242
2243static int propagate_has_child_subreaper(struct task_struct *p, void *data)
2244{
2245
2246
2247
2248
2249
2250
2251
2252
2253 if (p->signal->has_child_subreaper ||
2254 is_child_reaper(task_pid(p)))
2255 return 0;
2256
2257 p->signal->has_child_subreaper = 1;
2258 return 1;
2259}
2260
2261int __weak arch_prctl_spec_ctrl_get(struct task_struct *t, unsigned long which)
2262{
2263 return -EINVAL;
2264}
2265
2266int __weak arch_prctl_spec_ctrl_set(struct task_struct *t, unsigned long which,
2267 unsigned long ctrl)
2268{
2269 return -EINVAL;
2270}
2271
2272SYSCALL_DEFINE5(prctl, int, option, unsigned long, arg2, unsigned long, arg3,
2273 unsigned long, arg4, unsigned long, arg5)
2274{
2275 struct task_struct *me = current;
2276 unsigned char comm[sizeof(me->comm)];
2277 long error;
2278
2279 error = security_task_prctl(option, arg2, arg3, arg4, arg5);
2280 if (error != -ENOSYS)
2281 return error;
2282
2283 error = 0;
2284 switch (option) {
2285 case PR_SET_PDEATHSIG:
2286 if (!valid_signal(arg2)) {
2287 error = -EINVAL;
2288 break;
2289 }
2290 me->pdeath_signal = arg2;
2291 break;
2292 case PR_GET_PDEATHSIG:
2293 error = put_user(me->pdeath_signal, (int __user *)arg2);
2294 break;
2295 case PR_GET_DUMPABLE:
2296 error = get_dumpable(me->mm);
2297 break;
2298 case PR_SET_DUMPABLE:
2299 if (arg2 != SUID_DUMP_DISABLE && arg2 != SUID_DUMP_USER) {
2300 error = -EINVAL;
2301 break;
2302 }
2303 set_dumpable(me->mm, arg2);
2304 break;
2305
2306 case PR_SET_UNALIGN:
2307 error = SET_UNALIGN_CTL(me, arg2);
2308 break;
2309 case PR_GET_UNALIGN:
2310 error = GET_UNALIGN_CTL(me, arg2);
2311 break;
2312 case PR_SET_FPEMU:
2313 error = SET_FPEMU_CTL(me, arg2);
2314 break;
2315 case PR_GET_FPEMU:
2316 error = GET_FPEMU_CTL(me, arg2);
2317 break;
2318 case PR_SET_FPEXC:
2319 error = SET_FPEXC_CTL(me, arg2);
2320 break;
2321 case PR_GET_FPEXC:
2322 error = GET_FPEXC_CTL(me, arg2);
2323 break;
2324 case PR_GET_TIMING:
2325 error = PR_TIMING_STATISTICAL;
2326 break;
2327 case PR_SET_TIMING:
2328 if (arg2 != PR_TIMING_STATISTICAL)
2329 error = -EINVAL;
2330 break;
2331 case PR_SET_NAME:
2332 comm[sizeof(me->comm) - 1] = 0;
2333 if (strncpy_from_user(comm, (char __user *)arg2,
2334 sizeof(me->comm) - 1) < 0)
2335 return -EFAULT;
2336 set_task_comm(me, comm);
2337 proc_comm_connector(me);
2338 break;
2339 case PR_GET_NAME:
2340 get_task_comm(comm, me);
2341 if (copy_to_user((char __user *)arg2, comm, sizeof(comm)))
2342 return -EFAULT;
2343 break;
2344 case PR_GET_ENDIAN:
2345 error = GET_ENDIAN(me, arg2);
2346 break;
2347 case PR_SET_ENDIAN:
2348 error = SET_ENDIAN(me, arg2);
2349 break;
2350 case PR_GET_SECCOMP:
2351 error = prctl_get_seccomp();
2352 break;
2353 case PR_SET_SECCOMP:
2354 error = prctl_set_seccomp(arg2, (char __user *)arg3);
2355 break;
2356 case PR_GET_TSC:
2357 error = GET_TSC_CTL(arg2);
2358 break;
2359 case PR_SET_TSC:
2360 error = SET_TSC_CTL(arg2);
2361 break;
2362 case PR_TASK_PERF_EVENTS_DISABLE:
2363 error = perf_event_task_disable();
2364 break;
2365 case PR_TASK_PERF_EVENTS_ENABLE:
2366 error = perf_event_task_enable();
2367 break;
2368 case PR_GET_TIMERSLACK:
2369 if (current->timer_slack_ns > ULONG_MAX)
2370 error = ULONG_MAX;
2371 else
2372 error = current->timer_slack_ns;
2373 break;
2374 case PR_SET_TIMERSLACK:
2375 if (arg2 <= 0)
2376 current->timer_slack_ns =
2377 current->default_timer_slack_ns;
2378 else
2379 current->timer_slack_ns = arg2;
2380 break;
2381 case PR_MCE_KILL:
2382 if (arg4 | arg5)
2383 return -EINVAL;
2384 switch (arg2) {
2385 case PR_MCE_KILL_CLEAR:
2386 if (arg3 != 0)
2387 return -EINVAL;
2388 current->flags &= ~PF_MCE_PROCESS;
2389 break;
2390 case PR_MCE_KILL_SET:
2391 current->flags |= PF_MCE_PROCESS;
2392 if (arg3 == PR_MCE_KILL_EARLY)
2393 current->flags |= PF_MCE_EARLY;
2394 else if (arg3 == PR_MCE_KILL_LATE)
2395 current->flags &= ~PF_MCE_EARLY;
2396 else if (arg3 == PR_MCE_KILL_DEFAULT)
2397 current->flags &=
2398 ~(PF_MCE_EARLY|PF_MCE_PROCESS);
2399 else
2400 return -EINVAL;
2401 break;
2402 default:
2403 return -EINVAL;
2404 }
2405 break;
2406 case PR_MCE_KILL_GET:
2407 if (arg2 | arg3 | arg4 | arg5)
2408 return -EINVAL;
2409 if (current->flags & PF_MCE_PROCESS)
2410 error = (current->flags & PF_MCE_EARLY) ?
2411 PR_MCE_KILL_EARLY : PR_MCE_KILL_LATE;
2412 else
2413 error = PR_MCE_KILL_DEFAULT;
2414 break;
2415 case PR_SET_MM:
2416 error = prctl_set_mm(arg2, arg3, arg4, arg5);
2417 break;
2418 case PR_GET_TID_ADDRESS:
2419 error = prctl_get_tid_address(me, (int __user **)arg2);
2420 break;
2421 case PR_SET_CHILD_SUBREAPER:
2422 me->signal->is_child_subreaper = !!arg2;
2423 if (!arg2)
2424 break;
2425
2426 walk_process_tree(me, propagate_has_child_subreaper, NULL);
2427 break;
2428 case PR_GET_CHILD_SUBREAPER:
2429 error = put_user(me->signal->is_child_subreaper,
2430 (int __user *)arg2);
2431 break;
2432 case PR_SET_NO_NEW_PRIVS:
2433 if (arg2 != 1 || arg3 || arg4 || arg5)
2434 return -EINVAL;
2435
2436 task_set_no_new_privs(current);
2437 break;
2438 case PR_GET_NO_NEW_PRIVS:
2439 if (arg2 || arg3 || arg4 || arg5)
2440 return -EINVAL;
2441 return task_no_new_privs(current) ? 1 : 0;
2442 case PR_GET_THP_DISABLE:
2443 if (arg2 || arg3 || arg4 || arg5)
2444 return -EINVAL;
2445 error = !!test_bit(MMF_DISABLE_THP, &me->mm->flags);
2446 break;
2447 case PR_SET_THP_DISABLE:
2448 if (arg3 || arg4 || arg5)
2449 return -EINVAL;
2450 if (down_write_killable(&me->mm->mmap_sem))
2451 return -EINTR;
2452 if (arg2)
2453 set_bit(MMF_DISABLE_THP, &me->mm->flags);
2454 else
2455 clear_bit(MMF_DISABLE_THP, &me->mm->flags);
2456 up_write(&me->mm->mmap_sem);
2457 break;
2458 case PR_MPX_ENABLE_MANAGEMENT:
2459 if (arg2 || arg3 || arg4 || arg5)
2460 return -EINVAL;
2461 error = MPX_ENABLE_MANAGEMENT();
2462 break;
2463 case PR_MPX_DISABLE_MANAGEMENT:
2464 if (arg2 || arg3 || arg4 || arg5)
2465 return -EINVAL;
2466 error = MPX_DISABLE_MANAGEMENT();
2467 break;
2468 case PR_SET_FP_MODE:
2469 error = SET_FP_MODE(me, arg2);
2470 break;
2471 case PR_GET_FP_MODE:
2472 error = GET_FP_MODE(me);
2473 break;
2474 case PR_SVE_SET_VL:
2475 error = SVE_SET_VL(arg2);
2476 break;
2477 case PR_SVE_GET_VL:
2478 error = SVE_GET_VL();
2479 break;
2480 case PR_GET_SPECULATION_CTRL:
2481 if (arg3 || arg4 || arg5)
2482 return -EINVAL;
2483 error = arch_prctl_spec_ctrl_get(me, arg2);
2484 break;
2485 case PR_SET_SPECULATION_CTRL:
2486 if (arg4 || arg5)
2487 return -EINVAL;
2488 error = arch_prctl_spec_ctrl_set(me, arg2, arg3);
2489 break;
2490 case PR_PAC_RESET_KEYS:
2491 if (arg3 || arg4 || arg5)
2492 return -EINVAL;
2493 error = PAC_RESET_KEYS(me, arg2);
2494 break;
2495 default:
2496 error = -EINVAL;
2497 break;
2498 }
2499 return error;
2500}
2501
2502SYSCALL_DEFINE3(getcpu, unsigned __user *, cpup, unsigned __user *, nodep,
2503 struct getcpu_cache __user *, unused)
2504{
2505 int err = 0;
2506 int cpu = raw_smp_processor_id();
2507
2508 if (cpup)
2509 err |= put_user(cpu, cpup);
2510 if (nodep)
2511 err |= put_user(cpu_to_node(cpu), nodep);
2512 return err ? -EFAULT : 0;
2513}
2514
2515
2516
2517
2518
2519static int do_sysinfo(struct sysinfo *info)
2520{
2521 unsigned long mem_total, sav_total;
2522 unsigned int mem_unit, bitcount;
2523 struct timespec64 tp;
2524
2525 memset(info, 0, sizeof(struct sysinfo));
2526
2527 ktime_get_boottime_ts64(&tp);
2528 info->uptime = tp.tv_sec + (tp.tv_nsec ? 1 : 0);
2529
2530 get_avenrun(info->loads, 0, SI_LOAD_SHIFT - FSHIFT);
2531
2532 info->procs = nr_threads;
2533
2534 si_meminfo(info);
2535 si_swapinfo(info);
2536
2537
2538
2539
2540
2541
2542
2543
2544
2545
2546 mem_total = info->totalram + info->totalswap;
2547 if (mem_total < info->totalram || mem_total < info->totalswap)
2548 goto out;
2549 bitcount = 0;
2550 mem_unit = info->mem_unit;
2551 while (mem_unit > 1) {
2552 bitcount++;
2553 mem_unit >>= 1;
2554 sav_total = mem_total;
2555 mem_total <<= 1;
2556 if (mem_total < sav_total)
2557 goto out;
2558 }
2559
2560
2561
2562
2563
2564
2565
2566
2567 info->mem_unit = 1;
2568 info->totalram <<= bitcount;
2569 info->freeram <<= bitcount;
2570 info->sharedram <<= bitcount;
2571 info->bufferram <<= bitcount;
2572 info->totalswap <<= bitcount;
2573 info->freeswap <<= bitcount;
2574 info->totalhigh <<= bitcount;
2575 info->freehigh <<= bitcount;
2576
2577out:
2578 return 0;
2579}
2580
2581SYSCALL_DEFINE1(sysinfo, struct sysinfo __user *, info)
2582{
2583 struct sysinfo val;
2584
2585 do_sysinfo(&val);
2586
2587 if (copy_to_user(info, &val, sizeof(struct sysinfo)))
2588 return -EFAULT;
2589
2590 return 0;
2591}
2592
2593#ifdef CONFIG_COMPAT
2594struct compat_sysinfo {
2595 s32 uptime;
2596 u32 loads[3];
2597 u32 totalram;
2598 u32 freeram;
2599 u32 sharedram;
2600 u32 bufferram;
2601 u32 totalswap;
2602 u32 freeswap;
2603 u16 procs;
2604 u16 pad;
2605 u32 totalhigh;
2606 u32 freehigh;
2607 u32 mem_unit;
2608 char _f[20-2*sizeof(u32)-sizeof(int)];
2609};
2610
2611COMPAT_SYSCALL_DEFINE1(sysinfo, struct compat_sysinfo __user *, info)
2612{
2613 struct sysinfo s;
2614
2615 do_sysinfo(&s);
2616
2617
2618
2619
2620 if (upper_32_bits(s.totalram) || upper_32_bits(s.totalswap)) {
2621 int bitcount = 0;
2622
2623 while (s.mem_unit < PAGE_SIZE) {
2624 s.mem_unit <<= 1;
2625 bitcount++;
2626 }
2627
2628 s.totalram >>= bitcount;
2629 s.freeram >>= bitcount;
2630 s.sharedram >>= bitcount;
2631 s.bufferram >>= bitcount;
2632 s.totalswap >>= bitcount;
2633 s.freeswap >>= bitcount;
2634 s.totalhigh >>= bitcount;
2635 s.freehigh >>= bitcount;
2636 }
2637
2638 if (!access_ok(info, sizeof(struct compat_sysinfo)) ||
2639 __put_user(s.uptime, &info->uptime) ||
2640 __put_user(s.loads[0], &info->loads[0]) ||
2641 __put_user(s.loads[1], &info->loads[1]) ||
2642 __put_user(s.loads[2], &info->loads[2]) ||
2643 __put_user(s.totalram, &info->totalram) ||
2644 __put_user(s.freeram, &info->freeram) ||
2645 __put_user(s.sharedram, &info->sharedram) ||
2646 __put_user(s.bufferram, &info->bufferram) ||
2647 __put_user(s.totalswap, &info->totalswap) ||
2648 __put_user(s.freeswap, &info->freeswap) ||
2649 __put_user(s.procs, &info->procs) ||
2650 __put_user(s.totalhigh, &info->totalhigh) ||
2651 __put_user(s.freehigh, &info->freehigh) ||
2652 __put_user(s.mem_unit, &info->mem_unit))
2653 return -EFAULT;
2654
2655 return 0;
2656}
2657#endif
2658