1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * linux/kernel/sys.c 4 * 5 * Copyright (C) 1991, 1992 Linus Torvalds 6 */ 7 8 #include <linux/export.h> 9 #include <linux/mm.h> 10 #include <linux/mm_inline.h> 11 #include <linux/utsname.h> 12 #include <linux/mman.h> 13 #include <linux/reboot.h> 14 #include <linux/prctl.h> 15 #include <linux/highuid.h> 16 #include <linux/fs.h> 17 #include <linux/kmod.h> 18 #include <linux/ksm.h> 19 #include <linux/perf_event.h> 20 #include <linux/resource.h> 21 #include <linux/kernel.h> 22 #include <linux/workqueue.h> 23 #include <linux/capability.h> 24 #include <linux/device.h> 25 #include <linux/key.h> 26 #include <linux/times.h> 27 #include <linux/posix-timers.h> 28 #include <linux/security.h> 29 #include <linux/random.h> 30 #include <linux/suspend.h> 31 #include <linux/tty.h> 32 #include <linux/signal.h> 33 #include <linux/cn_proc.h> 34 #include <linux/getcpu.h> 35 #include <linux/task_io_accounting_ops.h> 36 #include <linux/seccomp.h> 37 #include <linux/cpu.h> 38 #include <linux/personality.h> 39 #include <linux/ptrace.h> 40 #include <linux/fs_struct.h> 41 #include <linux/file.h> 42 #include <linux/mount.h> 43 #include <linux/gfp.h> 44 #include <linux/syscore_ops.h> 45 #include <linux/version.h> 46 #include <linux/ctype.h> 47 #include <linux/syscall_user_dispatch.h> 48 49 #include <linux/compat.h> 50 #include <linux/syscalls.h> 51 #include <linux/kprobes.h> 52 #include <linux/user_namespace.h> 53 #include <linux/time_namespace.h> 54 #include <linux/binfmts.h> 55 56 #include <linux/sched.h> 57 #include <linux/sched/autogroup.h> 58 #include <linux/sched/loadavg.h> 59 #include <linux/sched/stat.h> 60 #include <linux/sched/mm.h> 61 #include <linux/sched/coredump.h> 62 #include <linux/sched/task.h> 63 #include <linux/sched/cputime.h> 64 #include <linux/rcupdate.h> 65 #include <linux/uidgid.h> 66 #include <linux/cred.h> 67 68 #include <linux/nospec.h> 69 70 #include <linux/kmsg_dump.h> 71 /* Move somewhere else to avoid recompiling? */ 72 #include <generated/utsrelease.h> 73 74 #include <linux/uaccess.h> 75 #include <asm/io.h> 76 #include <asm/unistd.h> 77 78 #include "uid16.h" 79 80 #ifndef SET_UNALIGN_CTL 81 # define SET_UNALIGN_CTL(a, b) (-EINVAL) 82 #endif 83 #ifndef GET_UNALIGN_CTL 84 # define GET_UNALIGN_CTL(a, b) (-EINVAL) 85 #endif 86 #ifndef SET_FPEMU_CTL 87 # define SET_FPEMU_CTL(a, b) (-EINVAL) 88 #endif 89 #ifndef GET_FPEMU_CTL 90 # define GET_FPEMU_CTL(a, b) (-EINVAL) 91 #endif 92 #ifndef SET_FPEXC_CTL 93 # define SET_FPEXC_CTL(a, b) (-EINVAL) 94 #endif 95 #ifndef GET_FPEXC_CTL 96 # define GET_FPEXC_CTL(a, b) (-EINVAL) 97 #endif 98 #ifndef GET_ENDIAN 99 # define GET_ENDIAN(a, b) (-EINVAL) 100 #endif 101 #ifndef SET_ENDIAN 102 # define SET_ENDIAN(a, b) (-EINVAL) 103 #endif 104 #ifndef GET_TSC_CTL 105 # define GET_TSC_CTL(a) (-EINVAL) 106 #endif 107 #ifndef SET_TSC_CTL 108 # define SET_TSC_CTL(a) (-EINVAL) 109 #endif 110 #ifndef GET_FP_MODE 111 # define GET_FP_MODE(a) (-EINVAL) 112 #endif 113 #ifndef SET_FP_MODE 114 # define SET_FP_MODE(a,b) (-EINVAL) 115 #endif 116 #ifndef SVE_SET_VL 117 # define SVE_SET_VL(a) (-EINVAL) 118 #endif 119 #ifndef SVE_GET_VL 120 # define SVE_GET_VL() (-EINVAL) 121 #endif 122 #ifndef SME_SET_VL 123 # define SME_SET_VL(a) (-EINVAL) 124 #endif 125 #ifndef SME_GET_VL 126 # define SME_GET_VL() (-EINVAL) 127 #endif 128 #ifndef PAC_RESET_KEYS 129 # define PAC_RESET_KEYS(a, b) (-EINVAL) 130 #endif 131 #ifndef PAC_SET_ENABLED_KEYS 132 # define PAC_SET_ENABLED_KEYS(a, b, c) (-EINVAL) 133 #endif 134 #ifndef PAC_GET_ENABLED_KEYS 135 # define PAC_GET_ENABLED_KEYS(a) (-EINVAL) 136 #endif 137 #ifndef SET_TAGGED_ADDR_CTRL 138 # define SET_TAGGED_ADDR_CTRL(a) (-EINVAL) 139 #endif 140 #ifndef GET_TAGGED_ADDR_CTRL 141 # define GET_TAGGED_ADDR_CTRL() (-EINVAL) 142 #endif 143 #ifndef RISCV_V_SET_CONTROL 144 # define RISCV_V_SET_CONTROL(a) (-EINVAL) 145 #endif 146 #ifndef RISCV_V_GET_CONTROL 147 # define RISCV_V_GET_CONTROL() (-EINVAL) 148 #endif 149 #ifndef RISCV_SET_ICACHE_FLUSH_CTX 150 # define RISCV_SET_ICACHE_FLUSH_CTX(a, b) (-EINVAL) 151 #endif 152 #ifndef PPC_GET_DEXCR_ASPECT 153 # define PPC_GET_DEXCR_ASPECT(a, b) (-EINVAL) 154 #endif 155 #ifndef PPC_SET_DEXCR_ASPECT 156 # define PPC_SET_DEXCR_ASPECT(a, b, c) (-EINVAL) 157 #endif 158 159 /* 160 * this is where the system-wide overflow UID and GID are defined, for 161 * architectures that now have 32-bit UID/GID but didn't in the past 162 */ 163 164 int overflowuid = DEFAULT_OVERFLOWUID; 165 int overflowgid = DEFAULT_OVERFLOWGID; 166 167 EXPORT_SYMBOL(overflowuid); 168 EXPORT_SYMBOL(overflowgid); 169 170 /* 171 * the same as above, but for filesystems which can only store a 16-bit 172 * UID and GID. as such, this is needed on all architectures 173 */ 174 175 int fs_overflowuid = DEFAULT_FS_OVERFLOWUID; 176 int fs_overflowgid = DEFAULT_FS_OVERFLOWGID; 177 178 EXPORT_SYMBOL(fs_overflowuid); 179 EXPORT_SYMBOL(fs_overflowgid); 180 181 /* 182 * Returns true if current's euid is same as p's uid or euid, 183 * or has CAP_SYS_NICE to p's user_ns. 184 * 185 * Called with rcu_read_lock, creds are safe 186 */ 187 static bool set_one_prio_perm(struct task_struct *p) 188 { 189 const struct cred *cred = current_cred(), *pcred = __task_cred(p); 190 191 if (uid_eq(pcred->uid, cred->euid) || 192 uid_eq(pcred->euid, cred->euid)) 193 return true; 194 if (ns_capable(pcred->user_ns, CAP_SYS_NICE)) 195 return true; 196 return false; 197 } 198 199 /* 200 * set the priority of a task 201 * - the caller must hold the RCU read lock 202 */ 203 static int set_one_prio(struct task_struct *p, int niceval, int error) 204 { 205 int no_nice; 206 207 if (!set_one_prio_perm(p)) { 208 error = -EPERM; 209 goto out; 210 } 211 if (niceval < task_nice(p) && !can_nice(p, niceval)) { 212 error = -EACCES; 213 goto out; 214 } 215 no_nice = security_task_setnice(p, niceval); 216 if (no_nice) { 217 error = no_nice; 218 goto out; 219 } 220 if (error == -ESRCH) 221 error = 0; 222 set_user_nice(p, niceval); 223 out: 224 return error; 225 } 226 227 SYSCALL_DEFINE3(setpriority, int, which, int, who, int, niceval) 228 { 229 struct task_struct *g, *p; 230 struct user_struct *user; 231 const struct cred *cred = current_cred(); 232 int error = -EINVAL; 233 struct pid *pgrp; 234 kuid_t uid; 235 236 if (which > PRIO_USER || which < PRIO_PROCESS) 237 goto out; 238 239 /* normalize: avoid signed division (rounding problems) */ 240 error = -ESRCH; 241 if (niceval < MIN_NICE) 242 niceval = MIN_NICE; 243 if (niceval > MAX_NICE) 244 niceval = MAX_NICE; 245 246 rcu_read_lock(); 247 switch (which) { 248 case PRIO_PROCESS: 249 if (who) 250 p = find_task_by_vpid(who); 251 else 252 p = current; 253 if (p) 254 error = set_one_prio(p, niceval, error); 255 break; 256 case PRIO_PGRP: 257 if (who) 258 pgrp = find_vpid(who); 259 else 260 pgrp = task_pgrp(current); 261 read_lock(&tasklist_lock); 262 do_each_pid_thread(pgrp, PIDTYPE_PGID, p) { 263 error = set_one_prio(p, niceval, error); 264 } while_each_pid_thread(pgrp, PIDTYPE_PGID, p); 265 read_unlock(&tasklist_lock); 266 break; 267 case PRIO_USER: 268 uid = make_kuid(cred->user_ns, who); 269 user = cred->user; 270 if (!who) 271 uid = cred->uid; 272 else if (!uid_eq(uid, cred->uid)) { 273 user = find_user(uid); 274 if (!user) 275 goto out_unlock; /* No processes for this user */ 276 } 277 for_each_process_thread(g, p) { 278 if (uid_eq(task_uid(p), uid) && task_pid_vnr(p)) 279 error = set_one_prio(p, niceval, error); 280 } 281 if (!uid_eq(uid, cred->uid)) 282 free_uid(user); /* For find_user() */ 283 break; 284 } 285 out_unlock: 286 rcu_read_unlock(); 287 out: 288 return error; 289 } 290 291 /* 292 * Ugh. To avoid negative return values, "getpriority()" will 293 * not return the normal nice-value, but a negated value that 294 * has been offset by 20 (ie it returns 40..1 instead of -20..19) 295 * to stay compatible. 296 */ 297 SYSCALL_DEFINE2(getpriority, int, which, int, who) 298 { 299 struct task_struct *g, *p; 300 struct user_struct *user; 301 const struct cred *cred = current_cred(); 302 long niceval, retval = -ESRCH; 303 struct pid *pgrp; 304 kuid_t uid; 305 306 if (which > PRIO_USER || which < PRIO_PROCESS) 307 return -EINVAL; 308 309 rcu_read_lock(); 310 switch (which) { 311 case PRIO_PROCESS: 312 if (who) 313 p = find_task_by_vpid(who); 314 else 315 p = current; 316 if (p) { 317 niceval = nice_to_rlimit(task_nice(p)); 318 if (niceval > retval) 319 retval = niceval; 320 } 321 break; 322 case PRIO_PGRP: 323 if (who) 324 pgrp = find_vpid(who); 325 else 326 pgrp = task_pgrp(current); 327 read_lock(&tasklist_lock); 328 do_each_pid_thread(pgrp, PIDTYPE_PGID, p) { 329 niceval = nice_to_rlimit(task_nice(p)); 330 if (niceval > retval) 331 retval = niceval; 332 } while_each_pid_thread(pgrp, PIDTYPE_PGID, p); 333 read_unlock(&tasklist_lock); 334 break; 335 case PRIO_USER: 336 uid = make_kuid(cred->user_ns, who); 337 user = cred->user; 338 if (!who) 339 uid = cred->uid; 340 else if (!uid_eq(uid, cred->uid)) { 341 user = find_user(uid); 342 if (!user) 343 goto out_unlock; /* No processes for this user */ 344 } 345 for_each_process_thread(g, p) { 346 if (uid_eq(task_uid(p), uid) && task_pid_vnr(p)) { 347 niceval = nice_to_rlimit(task_nice(p)); 348 if (niceval > retval) 349 retval = niceval; 350 } 351 } 352 if (!uid_eq(uid, cred->uid)) 353 free_uid(user); /* for find_user() */ 354 break; 355 } 356 out_unlock: 357 rcu_read_unlock(); 358 359 return retval; 360 } 361 362 /* 363 * Unprivileged users may change the real gid to the effective gid 364 * or vice versa. (BSD-style) 365 * 366 * If you set the real gid at all, or set the effective gid to a value not 367 * equal to the real gid, then the saved gid is set to the new effective gid. 368 * 369 * This makes it possible for a setgid program to completely drop its 370 * privileges, which is often a useful assertion to make when you are doing 371 * a security audit over a program. 372 * 373 * The general idea is that a program which uses just setregid() will be 374 * 100% compatible with BSD. A program which uses just setgid() will be 375 * 100% compatible with POSIX with saved IDs. 376 * 377 * SMP: There are not races, the GIDs are checked only by filesystem 378 * operations (as far as semantic preservation is concerned). 379 */ 380 #ifdef CONFIG_MULTIUSER 381 long __sys_setregid(gid_t rgid, gid_t egid) 382 { 383 struct user_namespace *ns = current_user_ns(); 384 const struct cred *old; 385 struct cred *new; 386 int retval; 387 kgid_t krgid, kegid; 388 389 krgid = make_kgid(ns, rgid); 390 kegid = make_kgid(ns, egid); 391 392 if ((rgid != (gid_t) -1) && !gid_valid(krgid)) 393 return -EINVAL; 394 if ((egid != (gid_t) -1) && !gid_valid(kegid)) 395 return -EINVAL; 396 397 new = prepare_creds(); 398 if (!new) 399 return -ENOMEM; 400 old = current_cred(); 401 402 retval = -EPERM; 403 if (rgid != (gid_t) -1) { 404 if (gid_eq(old->gid, krgid) || 405 gid_eq(old->egid, krgid) || 406 ns_capable_setid(old->user_ns, CAP_SETGID)) 407 new->gid = krgid; 408 else 409 goto error; 410 } 411 if (egid != (gid_t) -1) { 412 if (gid_eq(old->gid, kegid) || 413 gid_eq(old->egid, kegid) || 414 gid_eq(old->sgid, kegid) || 415 ns_capable_setid(old->user_ns, CAP_SETGID)) 416 new->egid = kegid; 417 else 418 goto error; 419 } 420 421 if (rgid != (gid_t) -1 || 422 (egid != (gid_t) -1 && !gid_eq(kegid, old->gid))) 423 new->sgid = new->egid; 424 new->fsgid = new->egid; 425 426 retval = security_task_fix_setgid(new, old, LSM_SETID_RE); 427 if (retval < 0) 428 goto error; 429 430 return commit_creds(new); 431 432 error: 433 abort_creds(new); 434 return retval; 435 } 436 437 SYSCALL_DEFINE2(setregid, gid_t, rgid, gid_t, egid) 438 { 439 return __sys_setregid(rgid, egid); 440 } 441 442 /* 443 * setgid() is implemented like SysV w/ SAVED_IDS 444 * 445 * SMP: Same implicit races as above. 446 */ 447 long __sys_setgid(gid_t gid) 448 { 449 struct user_namespace *ns = current_user_ns(); 450 const struct cred *old; 451 struct cred *new; 452 int retval; 453 kgid_t kgid; 454 455 kgid = make_kgid(ns, gid); 456 if (!gid_valid(kgid)) 457 return -EINVAL; 458 459 new = prepare_creds(); 460 if (!new) 461 return -ENOMEM; 462 old = current_cred(); 463 464 retval = -EPERM; 465 if (ns_capable_setid(old->user_ns, CAP_SETGID)) 466 new->gid = new->egid = new->sgid = new->fsgid = kgid; 467 else if (gid_eq(kgid, old->gid) || gid_eq(kgid, old->sgid)) 468 new->egid = new->fsgid = kgid; 469 else 470 goto error; 471 472 retval = security_task_fix_setgid(new, old, LSM_SETID_ID); 473 if (retval < 0) 474 goto error; 475 476 return commit_creds(new); 477 478 error: 479 abort_creds(new); 480 return retval; 481 } 482 483 SYSCALL_DEFINE1(setgid, gid_t, gid) 484 { 485 return __sys_setgid(gid); 486 } 487 488 /* 489 * change the user struct in a credentials set to match the new UID 490 */ 491 static int set_user(struct cred *new) 492 { 493 struct user_struct *new_user; 494 495 new_user = alloc_uid(new->uid); 496 if (!new_user) 497 return -EAGAIN; 498 499 free_uid(new->user); 500 new->user = new_user; 501 return 0; 502 } 503 504 static void flag_nproc_exceeded(struct cred *new) 505 { 506 if (new->ucounts == current_ucounts()) 507 return; 508 509 /* 510 * We don't fail in case of NPROC limit excess here because too many 511 * poorly written programs don't check set*uid() return code, assuming 512 * it never fails if called by root. We may still enforce NPROC limit 513 * for programs doing set*uid()+execve() by harmlessly deferring the 514 * failure to the execve() stage. 515 */ 516 if (is_rlimit_overlimit(new->ucounts, UCOUNT_RLIMIT_NPROC, rlimit(RLIMIT_NPROC)) && 517 new->user != INIT_USER) 518 current->flags |= PF_NPROC_EXCEEDED; 519 else 520 current->flags &= ~PF_NPROC_EXCEEDED; 521 } 522 523 /* 524 * Unprivileged users may change the real uid to the effective uid 525 * or vice versa. (BSD-style) 526 * 527 * If you set the real uid at all, or set the effective uid to a value not 528 * equal to the real uid, then the saved uid is set to the new effective uid. 529 * 530 * This makes it possible for a setuid program to completely drop its 531 * privileges, which is often a useful assertion to make when you are doing 532 * a security audit over a program. 533 * 534 * The general idea is that a program which uses just setreuid() will be 535 * 100% compatible with BSD. A program which uses just setuid() will be 536 * 100% compatible with POSIX with saved IDs. 537 */ 538 long __sys_setreuid(uid_t ruid, uid_t euid) 539 { 540 struct user_namespace *ns = current_user_ns(); 541 const struct cred *old; 542 struct cred *new; 543 int retval; 544 kuid_t kruid, keuid; 545 546 kruid = make_kuid(ns, ruid); 547 keuid = make_kuid(ns, euid); 548 549 if ((ruid != (uid_t) -1) && !uid_valid(kruid)) 550 return -EINVAL; 551 if ((euid != (uid_t) -1) && !uid_valid(keuid)) 552 return -EINVAL; 553 554 new = prepare_creds(); 555 if (!new) 556 return -ENOMEM; 557 old = current_cred(); 558 559 retval = -EPERM; 560 if (ruid != (uid_t) -1) { 561 new->uid = kruid; 562 if (!uid_eq(old->uid, kruid) && 563 !uid_eq(old->euid, kruid) && 564 !ns_capable_setid(old->user_ns, CAP_SETUID)) 565 goto error; 566 } 567 568 if (euid != (uid_t) -1) { 569 new->euid = keuid; 570 if (!uid_eq(old->uid, keuid) && 571 !uid_eq(old->euid, keuid) && 572 !uid_eq(old->suid, keuid) && 573 !ns_capable_setid(old->user_ns, CAP_SETUID)) 574 goto error; 575 } 576 577 if (!uid_eq(new->uid, old->uid)) { 578 retval = set_user(new); 579 if (retval < 0) 580 goto error; 581 } 582 if (ruid != (uid_t) -1 || 583 (euid != (uid_t) -1 && !uid_eq(keuid, old->uid))) 584 new->suid = new->euid; 585 new->fsuid = new->euid; 586 587 retval = security_task_fix_setuid(new, old, LSM_SETID_RE); 588 if (retval < 0) 589 goto error; 590 591 retval = set_cred_ucounts(new); 592 if (retval < 0) 593 goto error; 594 595 flag_nproc_exceeded(new); 596 return commit_creds(new); 597 598 error: 599 abort_creds(new); 600 return retval; 601 } 602 603 SYSCALL_DEFINE2(setreuid, uid_t, ruid, uid_t, euid) 604 { 605 return __sys_setreuid(ruid, euid); 606 } 607 608 /* 609 * setuid() is implemented like SysV with SAVED_IDS 610 * 611 * Note that SAVED_ID's is deficient in that a setuid root program 612 * like sendmail, for example, cannot set its uid to be a normal 613 * user and then switch back, because if you're root, setuid() sets 614 * the saved uid too. If you don't like this, blame the bright people 615 * in the POSIX committee and/or USG. Note that the BSD-style setreuid() 616 * will allow a root program to temporarily drop privileges and be able to 617 * regain them by swapping the real and effective uid. 618 */ 619 long __sys_setuid(uid_t uid) 620 { 621 struct user_namespace *ns = current_user_ns(); 622 const struct cred *old; 623 struct cred *new; 624 int retval; 625 kuid_t kuid; 626 627 kuid = make_kuid(ns, uid); 628 if (!uid_valid(kuid)) 629 return -EINVAL; 630 631 new = prepare_creds(); 632 if (!new) 633 return -ENOMEM; 634 old = current_cred(); 635 636 retval = -EPERM; 637 if (ns_capable_setid(old->user_ns, CAP_SETUID)) { 638 new->suid = new->uid = kuid; 639 if (!uid_eq(kuid, old->uid)) { 640 retval = set_user(new); 641 if (retval < 0) 642 goto error; 643 } 644 } else if (!uid_eq(kuid, old->uid) && !uid_eq(kuid, new->suid)) { 645 goto error; 646 } 647 648 new->fsuid = new->euid = kuid; 649 650 retval = security_task_fix_setuid(new, old, LSM_SETID_ID); 651 if (retval < 0) 652 goto error; 653 654 retval = set_cred_ucounts(new); 655 if (retval < 0) 656 goto error; 657 658 flag_nproc_exceeded(new); 659 return commit_creds(new); 660 661 error: 662 abort_creds(new); 663 return retval; 664 } 665 666 SYSCALL_DEFINE1(setuid, uid_t, uid) 667 { 668 return __sys_setuid(uid); 669 } 670 671 672 /* 673 * This function implements a generic ability to update ruid, euid, 674 * and suid. This allows you to implement the 4.4 compatible seteuid(). 675 */ 676 long __sys_setresuid(uid_t ruid, uid_t euid, uid_t suid) 677 { 678 struct user_namespace *ns = current_user_ns(); 679 const struct cred *old; 680 struct cred *new; 681 int retval; 682 kuid_t kruid, keuid, ksuid; 683 bool ruid_new, euid_new, suid_new; 684 685 kruid = make_kuid(ns, ruid); 686 keuid = make_kuid(ns, euid); 687 ksuid = make_kuid(ns, suid); 688 689 if ((ruid != (uid_t) -1) && !uid_valid(kruid)) 690 return -EINVAL; 691 692 if ((euid != (uid_t) -1) && !uid_valid(keuid)) 693 return -EINVAL; 694 695 if ((suid != (uid_t) -1) && !uid_valid(ksuid)) 696 return -EINVAL; 697 698 old = current_cred(); 699 700 /* check for no-op */ 701 if ((ruid == (uid_t) -1 || uid_eq(kruid, old->uid)) && 702 (euid == (uid_t) -1 || (uid_eq(keuid, old->euid) && 703 uid_eq(keuid, old->fsuid))) && 704 (suid == (uid_t) -1 || uid_eq(ksuid, old->suid))) 705 return 0; 706 707 ruid_new = ruid != (uid_t) -1 && !uid_eq(kruid, old->uid) && 708 !uid_eq(kruid, old->euid) && !uid_eq(kruid, old->suid); 709 euid_new = euid != (uid_t) -1 && !uid_eq(keuid, old->uid) && 710 !uid_eq(keuid, old->euid) && !uid_eq(keuid, old->suid); 711 suid_new = suid != (uid_t) -1 && !uid_eq(ksuid, old->uid) && 712 !uid_eq(ksuid, old->euid) && !uid_eq(ksuid, old->suid); 713 if ((ruid_new || euid_new || suid_new) && 714 !ns_capable_setid(old->user_ns, CAP_SETUID)) 715 return -EPERM; 716 717 new = prepare_creds(); 718 if (!new) 719 return -ENOMEM; 720 721 if (ruid != (uid_t) -1) { 722 new->uid = kruid; 723 if (!uid_eq(kruid, old->uid)) { 724 retval = set_user(new); 725 if (retval < 0) 726 goto error; 727 } 728 } 729 if (euid != (uid_t) -1) 730 new->euid = keuid; 731 if (suid != (uid_t) -1) 732 new->suid = ksuid; 733 new->fsuid = new->euid; 734 735 retval = security_task_fix_setuid(new, old, LSM_SETID_RES); 736 if (retval < 0) 737 goto error; 738 739 retval = set_cred_ucounts(new); 740 if (retval < 0) 741 goto error; 742 743 flag_nproc_exceeded(new); 744 return commit_creds(new); 745 746 error: 747 abort_creds(new); 748 return retval; 749 } 750 751 SYSCALL_DEFINE3(setresuid, uid_t, ruid, uid_t, euid, uid_t, suid) 752 { 753 return __sys_setresuid(ruid, euid, suid); 754 } 755 756 SYSCALL_DEFINE3(getresuid, uid_t __user *, ruidp, uid_t __user *, euidp, uid_t __user *, suidp) 757 { 758 const struct cred *cred = current_cred(); 759 int retval; 760 uid_t ruid, euid, suid; 761 762 ruid = from_kuid_munged(cred->user_ns, cred->uid); 763 euid = from_kuid_munged(cred->user_ns, cred->euid); 764 suid = from_kuid_munged(cred->user_ns, cred->suid); 765 766 retval = put_user(ruid, ruidp); 767 if (!retval) { 768 retval = put_user(euid, euidp); 769 if (!retval) 770 return put_user(suid, suidp); 771 } 772 return retval; 773 } 774 775 /* 776 * Same as above, but for rgid, egid, sgid. 777 */ 778 long __sys_setresgid(gid_t rgid, gid_t egid, gid_t sgid) 779 { 780 struct user_namespace *ns = current_user_ns(); 781 const struct cred *old; 782 struct cred *new; 783 int retval; 784 kgid_t krgid, kegid, ksgid; 785 bool rgid_new, egid_new, sgid_new; 786 787 krgid = make_kgid(ns, rgid); 788 kegid = make_kgid(ns, egid); 789 ksgid = make_kgid(ns, sgid); 790 791 if ((rgid != (gid_t) -1) && !gid_valid(krgid)) 792 return -EINVAL; 793 if ((egid != (gid_t) -1) && !gid_valid(kegid)) 794 return -EINVAL; 795 if ((sgid != (gid_t) -1) && !gid_valid(ksgid)) 796 return -EINVAL; 797 798 old = current_cred(); 799 800 /* check for no-op */ 801 if ((rgid == (gid_t) -1 || gid_eq(krgid, old->gid)) && 802 (egid == (gid_t) -1 || (gid_eq(kegid, old->egid) && 803 gid_eq(kegid, old->fsgid))) && 804 (sgid == (gid_t) -1 || gid_eq(ksgid, old->sgid))) 805 return 0; 806 807 rgid_new = rgid != (gid_t) -1 && !gid_eq(krgid, old->gid) && 808 !gid_eq(krgid, old->egid) && !gid_eq(krgid, old->sgid); 809 egid_new = egid != (gid_t) -1 && !gid_eq(kegid, old->gid) && 810 !gid_eq(kegid, old->egid) && !gid_eq(kegid, old->sgid); 811 sgid_new = sgid != (gid_t) -1 && !gid_eq(ksgid, old->gid) && 812 !gid_eq(ksgid, old->egid) && !gid_eq(ksgid, old->sgid); 813 if ((rgid_new || egid_new || sgid_new) && 814 !ns_capable_setid(old->user_ns, CAP_SETGID)) 815 return -EPERM; 816 817 new = prepare_creds(); 818 if (!new) 819 return -ENOMEM; 820 821 if (rgid != (gid_t) -1) 822 new->gid = krgid; 823 if (egid != (gid_t) -1) 824 new->egid = kegid; 825 if (sgid != (gid_t) -1) 826 new->sgid = ksgid; 827 new->fsgid = new->egid; 828 829 retval = security_task_fix_setgid(new, old, LSM_SETID_RES); 830 if (retval < 0) 831 goto error; 832 833 return commit_creds(new); 834 835 error: 836 abort_creds(new); 837 return retval; 838 } 839 840 SYSCALL_DEFINE3(setresgid, gid_t, rgid, gid_t, egid, gid_t, sgid) 841 { 842 return __sys_setresgid(rgid, egid, sgid); 843 } 844 845 SYSCALL_DEFINE3(getresgid, gid_t __user *, rgidp, gid_t __user *, egidp, gid_t __user *, sgidp) 846 { 847 const struct cred *cred = current_cred(); 848 int retval; 849 gid_t rgid, egid, sgid; 850 851 rgid = from_kgid_munged(cred->user_ns, cred->gid); 852 egid = from_kgid_munged(cred->user_ns, cred->egid); 853 sgid = from_kgid_munged(cred->user_ns, cred->sgid); 854 855 retval = put_user(rgid, rgidp); 856 if (!retval) { 857 retval = put_user(egid, egidp); 858 if (!retval) 859 retval = put_user(sgid, sgidp); 860 } 861 862 return retval; 863 } 864 865 866 /* 867 * "setfsuid()" sets the fsuid - the uid used for filesystem checks. This 868 * is used for "access()" and for the NFS daemon (letting nfsd stay at 869 * whatever uid it wants to). It normally shadows "euid", except when 870 * explicitly set by setfsuid() or for access.. 871 */ 872 long __sys_setfsuid(uid_t uid) 873 { 874 const struct cred *old; 875 struct cred *new; 876 uid_t old_fsuid; 877 kuid_t kuid; 878 879 old = current_cred(); 880 old_fsuid = from_kuid_munged(old->user_ns, old->fsuid); 881 882 kuid = make_kuid(old->user_ns, uid); 883 if (!uid_valid(kuid)) 884 return old_fsuid; 885 886 new = prepare_creds(); 887 if (!new) 888 return old_fsuid; 889 890 if (uid_eq(kuid, old->uid) || uid_eq(kuid, old->euid) || 891 uid_eq(kuid, old->suid) || uid_eq(kuid, old->fsuid) || 892 ns_capable_setid(old->user_ns, CAP_SETUID)) { 893 if (!uid_eq(kuid, old->fsuid)) { 894 new->fsuid = kuid; 895 if (security_task_fix_setuid(new, old, LSM_SETID_FS) == 0) 896 goto change_okay; 897 } 898 } 899 900 abort_creds(new); 901 return old_fsuid; 902 903 change_okay: 904 commit_creds(new); 905 return old_fsuid; 906 } 907 908 SYSCALL_DEFINE1(setfsuid, uid_t, uid) 909 { 910 return __sys_setfsuid(uid); 911 } 912 913 /* 914 * Samma på svenska.. 915 */ 916 long __sys_setfsgid(gid_t gid) 917 { 918 const struct cred *old; 919 struct cred *new; 920 gid_t old_fsgid; 921 kgid_t kgid; 922 923 old = current_cred(); 924 old_fsgid = from_kgid_munged(old->user_ns, old->fsgid); 925 926 kgid = make_kgid(old->user_ns, gid); 927 if (!gid_valid(kgid)) 928 return old_fsgid; 929 930 new = prepare_creds(); 931 if (!new) 932 return old_fsgid; 933 934 if (gid_eq(kgid, old->gid) || gid_eq(kgid, old->egid) || 935 gid_eq(kgid, old->sgid) || gid_eq(kgid, old->fsgid) || 936 ns_capable_setid(old->user_ns, CAP_SETGID)) { 937 if (!gid_eq(kgid, old->fsgid)) { 938 new->fsgid = kgid; 939 if (security_task_fix_setgid(new,old,LSM_SETID_FS) == 0) 940 goto change_okay; 941 } 942 } 943 944 abort_creds(new); 945 return old_fsgid; 946 947 change_okay: 948 commit_creds(new); 949 return old_fsgid; 950 } 951 952 SYSCALL_DEFINE1(setfsgid, gid_t, gid) 953 { 954 return __sys_setfsgid(gid); 955 } 956 #endif /* CONFIG_MULTIUSER */ 957 958 /** 959 * sys_getpid - return the thread group id of the current process 960 * 961 * Note, despite the name, this returns the tgid not the pid. The tgid and 962 * the pid are identical unless CLONE_THREAD was specified on clone() in 963 * which case the tgid is the same in all threads of the same group. 964 * 965 * This is SMP safe as current->tgid does not change. 966 */ 967 SYSCALL_DEFINE0(getpid) 968 { 969 return task_tgid_vnr(current); 970 } 971 972 /* Thread ID - the internal kernel "pid" */ 973 SYSCALL_DEFINE0(gettid) 974 { 975 return task_pid_vnr(current); 976 } 977 978 /* 979 * Accessing ->real_parent is not SMP-safe, it could 980 * change from under us. However, we can use a stale 981 * value of ->real_parent under rcu_read_lock(), see 982 * release_task()->call_rcu(delayed_put_task_struct). 983 */ 984 SYSCALL_DEFINE0(getppid) 985 { 986 int pid; 987 988 rcu_read_lock(); 989 pid = task_tgid_vnr(rcu_dereference(current->real_parent)); 990 rcu_read_unlock(); 991 992 return pid; 993 } 994 995 SYSCALL_DEFINE0(getuid) 996 { 997 /* Only we change this so SMP safe */ 998 return from_kuid_munged(current_user_ns(), current_uid()); 999 } 1000 1001 SYSCALL_DEFINE0(geteuid) 1002 { 1003 /* Only we change this so SMP safe */ 1004 return from_kuid_munged(current_user_ns(), current_euid()); 1005 } 1006 1007 SYSCALL_DEFINE0(getgid) 1008 { 1009 /* Only we change this so SMP safe */ 1010 return from_kgid_munged(current_user_ns(), current_gid()); 1011 } 1012 1013 SYSCALL_DEFINE0(getegid) 1014 { 1015 /* Only we change this so SMP safe */ 1016 return from_kgid_munged(current_user_ns(), current_egid()); 1017 } 1018 1019 static void do_sys_times(struct tms *tms) 1020 { 1021 u64 tgutime, tgstime, cutime, cstime; 1022 1023 thread_group_cputime_adjusted(current, &tgutime, &tgstime); 1024 cutime = current->signal->cutime; 1025 cstime = current->signal->cstime; 1026 tms->tms_utime = nsec_to_clock_t(tgutime); 1027 tms->tms_stime = nsec_to_clock_t(tgstime); 1028 tms->tms_cutime = nsec_to_clock_t(cutime); 1029 tms->tms_cstime = nsec_to_clock_t(cstime); 1030 } 1031 1032 SYSCALL_DEFINE1(times, struct tms __user *, tbuf) 1033 { 1034 if (tbuf) { 1035 struct tms tmp; 1036 1037 do_sys_times(&tmp); 1038 if (copy_to_user(tbuf, &tmp, sizeof(struct tms))) 1039 return -EFAULT; 1040 } 1041 force_successful_syscall_return(); 1042 return (long) jiffies_64_to_clock_t(get_jiffies_64()); 1043 } 1044 1045 #ifdef CONFIG_COMPAT 1046 static compat_clock_t clock_t_to_compat_clock_t(clock_t x) 1047 { 1048 return compat_jiffies_to_clock_t(clock_t_to_jiffies(x)); 1049 } 1050 1051 COMPAT_SYSCALL_DEFINE1(times, struct compat_tms __user *, tbuf) 1052 { 1053 if (tbuf) { 1054 struct tms tms; 1055 struct compat_tms tmp; 1056 1057 do_sys_times(&tms); 1058 /* Convert our struct tms to the compat version. */ 1059 tmp.tms_utime = clock_t_to_compat_clock_t(tms.tms_utime); 1060 tmp.tms_stime = clock_t_to_compat_clock_t(tms.tms_stime); 1061 tmp.tms_cutime = clock_t_to_compat_clock_t(tms.tms_cutime); 1062 tmp.tms_cstime = clock_t_to_compat_clock_t(tms.tms_cstime); 1063 if (copy_to_user(tbuf, &tmp, sizeof(tmp))) 1064 return -EFAULT; 1065 } 1066 force_successful_syscall_return(); 1067 return compat_jiffies_to_clock_t(jiffies); 1068 } 1069 #endif 1070 1071 /* 1072 * This needs some heavy checking ... 1073 * I just haven't the stomach for it. I also don't fully 1074 * understand sessions/pgrp etc. Let somebody who does explain it. 1075 * 1076 * OK, I think I have the protection semantics right.... this is really 1077 * only important on a multi-user system anyway, to make sure one user 1078 * can't send a signal to a process owned by another. -TYT, 12/12/91 1079 * 1080 * !PF_FORKNOEXEC check to conform completely to POSIX. 1081 */ 1082 SYSCALL_DEFINE2(setpgid, pid_t, pid, pid_t, pgid) 1083 { 1084 struct task_struct *p; 1085 struct task_struct *group_leader = current->group_leader; 1086 struct pid *pgrp; 1087 int err; 1088 1089 if (!pid) 1090 pid = task_pid_vnr(group_leader); 1091 if (!pgid) 1092 pgid = pid; 1093 if (pgid < 0) 1094 return -EINVAL; 1095 rcu_read_lock(); 1096 1097 /* From this point forward we keep holding onto the tasklist lock 1098 * so that our parent does not change from under us. -DaveM 1099 */ 1100 write_lock_irq(&tasklist_lock); 1101 1102 err = -ESRCH; 1103 p = find_task_by_vpid(pid); 1104 if (!p) 1105 goto out; 1106 1107 err = -EINVAL; 1108 if (!thread_group_leader(p)) 1109 goto out; 1110 1111 if (same_thread_group(p->real_parent, group_leader)) { 1112 err = -EPERM; 1113 if (task_session(p) != task_session(group_leader)) 1114 goto out; 1115 err = -EACCES; 1116 if (!(p->flags & PF_FORKNOEXEC)) 1117 goto out; 1118 } else { 1119 err = -ESRCH; 1120 if (p != group_leader) 1121 goto out; 1122 } 1123 1124 err = -EPERM; 1125 if (p->signal->leader) 1126 goto out; 1127 1128 pgrp = task_pid(p); 1129 if (pgid != pid) { 1130 struct task_struct *g; 1131 1132 pgrp = find_vpid(pgid); 1133 g = pid_task(pgrp, PIDTYPE_PGID); 1134 if (!g || task_session(g) != task_session(group_leader)) 1135 goto out; 1136 } 1137 1138 err = security_task_setpgid(p, pgid); 1139 if (err) 1140 goto out; 1141 1142 if (task_pgrp(p) != pgrp) 1143 change_pid(p, PIDTYPE_PGID, pgrp); 1144 1145 err = 0; 1146 out: 1147 /* All paths lead to here, thus we are safe. -DaveM */ 1148 write_unlock_irq(&tasklist_lock); 1149 rcu_read_unlock(); 1150 return err; 1151 } 1152 1153 static int do_getpgid(pid_t pid) 1154 { 1155 struct task_struct *p; 1156 struct pid *grp; 1157 int retval; 1158 1159 rcu_read_lock(); 1160 if (!pid) 1161 grp = task_pgrp(current); 1162 else { 1163 retval = -ESRCH; 1164 p = find_task_by_vpid(pid); 1165 if (!p) 1166 goto out; 1167 grp = task_pgrp(p); 1168 if (!grp) 1169 goto out; 1170 1171 retval = security_task_getpgid(p); 1172 if (retval) 1173 goto out; 1174 } 1175 retval = pid_vnr(grp); 1176 out: 1177 rcu_read_unlock(); 1178 return retval; 1179 } 1180 1181 SYSCALL_DEFINE1(getpgid, pid_t, pid) 1182 { 1183 return do_getpgid(pid); 1184 } 1185 1186 #ifdef __ARCH_WANT_SYS_GETPGRP 1187 1188 SYSCALL_DEFINE0(getpgrp) 1189 { 1190 return do_getpgid(0); 1191 } 1192 1193 #endif 1194 1195 SYSCALL_DEFINE1(getsid, pid_t, pid) 1196 { 1197 struct task_struct *p; 1198 struct pid *sid; 1199 int retval; 1200 1201 rcu_read_lock(); 1202 if (!pid) 1203 sid = task_session(current); 1204 else { 1205 retval = -ESRCH; 1206 p = find_task_by_vpid(pid); 1207 if (!p) 1208 goto out; 1209 sid = task_session(p); 1210 if (!sid) 1211 goto out; 1212 1213 retval = security_task_getsid(p); 1214 if (retval) 1215 goto out; 1216 } 1217 retval = pid_vnr(sid); 1218 out: 1219 rcu_read_unlock(); 1220 return retval; 1221 } 1222 1223 static void set_special_pids(struct pid *pid) 1224 { 1225 struct task_struct *curr = current->group_leader; 1226 1227 if (task_session(curr) != pid) 1228 change_pid(curr, PIDTYPE_SID, pid); 1229 1230 if (task_pgrp(curr) != pid) 1231 change_pid(curr, PIDTYPE_PGID, pid); 1232 } 1233 1234 int ksys_setsid(void) 1235 { 1236 struct task_struct *group_leader = current->group_leader; 1237 struct pid *sid = task_pid(group_leader); 1238 pid_t session = pid_vnr(sid); 1239 int err = -EPERM; 1240 1241 write_lock_irq(&tasklist_lock); 1242 /* Fail if I am already a session leader */ 1243 if (group_leader->signal->leader) 1244 goto out; 1245 1246 /* Fail if a process group id already exists that equals the 1247 * proposed session id. 1248 */ 1249 if (pid_task(sid, PIDTYPE_PGID)) 1250 goto out; 1251 1252 group_leader->signal->leader = 1; 1253 set_special_pids(sid); 1254 1255 proc_clear_tty(group_leader); 1256 1257 err = session; 1258 out: 1259 write_unlock_irq(&tasklist_lock); 1260 if (err > 0) { 1261 proc_sid_connector(group_leader); 1262 sched_autogroup_create_attach(group_leader); 1263 } 1264 return err; 1265 } 1266 1267 SYSCALL_DEFINE0(setsid) 1268 { 1269 return ksys_setsid(); 1270 } 1271 1272 DECLARE_RWSEM(uts_sem); 1273 1274 #ifdef COMPAT_UTS_MACHINE 1275 #define override_architecture(name) \ 1276 (personality(current->personality) == PER_LINUX32 && \ 1277 copy_to_user(name->machine, COMPAT_UTS_MACHINE, \ 1278 sizeof(COMPAT_UTS_MACHINE))) 1279 #else 1280 #define override_architecture(name) 0 1281 #endif 1282 1283 /* 1284 * Work around broken programs that cannot handle "Linux 3.0". 1285 * Instead we map 3.x to 2.6.40+x, so e.g. 3.0 would be 2.6.40 1286 * And we map 4.x and later versions to 2.6.60+x, so 4.0/5.0/6.0/... would be 1287 * 2.6.60. 1288 */ 1289 static int override_release(char __user *release, size_t len) 1290 { 1291 int ret = 0; 1292 1293 if (current->personality & UNAME26) { 1294 const char *rest = UTS_RELEASE; 1295 char buf[65] = { 0 }; 1296 int ndots = 0; 1297 unsigned v; 1298 size_t copy; 1299 1300 while (*rest) { 1301 if (*rest == '.' && ++ndots >= 3) 1302 break; 1303 if (!isdigit(*rest) && *rest != '.') 1304 break; 1305 rest++; 1306 } 1307 v = LINUX_VERSION_PATCHLEVEL + 60; 1308 copy = clamp_t(size_t, len, 1, sizeof(buf)); 1309 copy = scnprintf(buf, copy, "2.6.%u%s", v, rest); 1310 ret = copy_to_user(release, buf, copy + 1); 1311 } 1312 return ret; 1313 } 1314 1315 SYSCALL_DEFINE1(newuname, struct new_utsname __user *, name) 1316 { 1317 struct new_utsname tmp; 1318 1319 down_read(&uts_sem); 1320 memcpy(&tmp, utsname(), sizeof(tmp)); 1321 up_read(&uts_sem); 1322 if (copy_to_user(name, &tmp, sizeof(tmp))) 1323 return -EFAULT; 1324 1325 if (override_release(name->release, sizeof(name->release))) 1326 return -EFAULT; 1327 if (override_architecture(name)) 1328 return -EFAULT; 1329 return 0; 1330 } 1331 1332 #ifdef __ARCH_WANT_SYS_OLD_UNAME 1333 /* 1334 * Old cruft 1335 */ 1336 SYSCALL_DEFINE1(uname, struct old_utsname __user *, name) 1337 { 1338 struct old_utsname tmp; 1339 1340 if (!name) 1341 return -EFAULT; 1342 1343 down_read(&uts_sem); 1344 memcpy(&tmp, utsname(), sizeof(tmp)); 1345 up_read(&uts_sem); 1346 if (copy_to_user(name, &tmp, sizeof(tmp))) 1347 return -EFAULT; 1348 1349 if (override_release(name->release, sizeof(name->release))) 1350 return -EFAULT; 1351 if (override_architecture(name)) 1352 return -EFAULT; 1353 return 0; 1354 } 1355 1356 SYSCALL_DEFINE1(olduname, struct oldold_utsname __user *, name) 1357 { 1358 struct oldold_utsname tmp; 1359 1360 if (!name) 1361 return -EFAULT; 1362 1363 memset(&tmp, 0, sizeof(tmp)); 1364 1365 down_read(&uts_sem); 1366 memcpy(&tmp.sysname, &utsname()->sysname, __OLD_UTS_LEN); 1367 memcpy(&tmp.nodename, &utsname()->nodename, __OLD_UTS_LEN); 1368 memcpy(&tmp.release, &utsname()->release, __OLD_UTS_LEN); 1369 memcpy(&tmp.version, &utsname()->version, __OLD_UTS_LEN); 1370 memcpy(&tmp.machine, &utsname()->machine, __OLD_UTS_LEN); 1371 up_read(&uts_sem); 1372 if (copy_to_user(name, &tmp, sizeof(tmp))) 1373 return -EFAULT; 1374 1375 if (override_architecture(name)) 1376 return -EFAULT; 1377 if (override_release(name->release, sizeof(name->release))) 1378 return -EFAULT; 1379 return 0; 1380 } 1381 #endif 1382 1383 SYSCALL_DEFINE2(sethostname, char __user *, name, int, len) 1384 { 1385 int errno; 1386 char tmp[__NEW_UTS_LEN]; 1387 1388 if (!ns_capable(current->nsproxy->uts_ns->user_ns, CAP_SYS_ADMIN)) 1389 return -EPERM; 1390 1391 if (len < 0 || len > __NEW_UTS_LEN) 1392 return -EINVAL; 1393 errno = -EFAULT; 1394 if (!copy_from_user(tmp, name, len)) { 1395 struct new_utsname *u; 1396 1397 add_device_randomness(tmp, len); 1398 down_write(&uts_sem); 1399 u = utsname(); 1400 memcpy(u->nodename, tmp, len); 1401 memset(u->nodename + len, 0, sizeof(u->nodename) - len); 1402 errno = 0; 1403 uts_proc_notify(UTS_PROC_HOSTNAME); 1404 up_write(&uts_sem); 1405 } 1406 return errno; 1407 } 1408 1409 #ifdef __ARCH_WANT_SYS_GETHOSTNAME 1410 1411 SYSCALL_DEFINE2(gethostname, char __user *, name, int, len) 1412 { 1413 int i; 1414 struct new_utsname *u; 1415 char tmp[__NEW_UTS_LEN + 1]; 1416 1417 if (len < 0) 1418 return -EINVAL; 1419 down_read(&uts_sem); 1420 u = utsname(); 1421 i = 1 + strlen(u->nodename); 1422 if (i > len) 1423 i = len; 1424 memcpy(tmp, u->nodename, i); 1425 up_read(&uts_sem); 1426 if (copy_to_user(name, tmp, i)) 1427 return -EFAULT; 1428 return 0; 1429 } 1430 1431 #endif 1432 1433 /* 1434 * Only setdomainname; getdomainname can be implemented by calling 1435 * uname() 1436 */ 1437 SYSCALL_DEFINE2(setdomainname, char __user *, name, int, len) 1438 { 1439 int errno; 1440 char tmp[__NEW_UTS_LEN]; 1441 1442 if (!ns_capable(current->nsproxy->uts_ns->user_ns, CAP_SYS_ADMIN)) 1443 return -EPERM; 1444 if (len < 0 || len > __NEW_UTS_LEN) 1445 return -EINVAL; 1446 1447 errno = -EFAULT; 1448 if (!copy_from_user(tmp, name, len)) { 1449 struct new_utsname *u; 1450 1451 add_device_randomness(tmp, len); 1452 down_write(&uts_sem); 1453 u = utsname(); 1454 memcpy(u->domainname, tmp, len); 1455 memset(u->domainname + len, 0, sizeof(u->domainname) - len); 1456 errno = 0; 1457 uts_proc_notify(UTS_PROC_DOMAINNAME); 1458 up_write(&uts_sem); 1459 } 1460 return errno; 1461 } 1462 1463 /* make sure you are allowed to change @tsk limits before calling this */ 1464 static int do_prlimit(struct task_struct *tsk, unsigned int resource, 1465 struct rlimit *new_rlim, struct rlimit *old_rlim) 1466 { 1467 struct rlimit *rlim; 1468 int retval = 0; 1469 1470 if (resource >= RLIM_NLIMITS) 1471 return -EINVAL; 1472 resource = array_index_nospec(resource, RLIM_NLIMITS); 1473 1474 if (new_rlim) { 1475 if (new_rlim->rlim_cur > new_rlim->rlim_max) 1476 return -EINVAL; 1477 if (resource == RLIMIT_NOFILE && 1478 new_rlim->rlim_max > sysctl_nr_open) 1479 return -EPERM; 1480 } 1481 1482 /* Holding a refcount on tsk protects tsk->signal from disappearing. */ 1483 rlim = tsk->signal->rlim + resource; 1484 task_lock(tsk->group_leader); 1485 if (new_rlim) { 1486 /* 1487 * Keep the capable check against init_user_ns until cgroups can 1488 * contain all limits. 1489 */ 1490 if (new_rlim->rlim_max > rlim->rlim_max && 1491 !capable(CAP_SYS_RESOURCE)) 1492 retval = -EPERM; 1493 if (!retval) 1494 retval = security_task_setrlimit(tsk, resource, new_rlim); 1495 } 1496 if (!retval) { 1497 if (old_rlim) 1498 *old_rlim = *rlim; 1499 if (new_rlim) 1500 *rlim = *new_rlim; 1501 } 1502 task_unlock(tsk->group_leader); 1503 1504 /* 1505 * RLIMIT_CPU handling. Arm the posix CPU timer if the limit is not 1506 * infinite. In case of RLIM_INFINITY the posix CPU timer code 1507 * ignores the rlimit. 1508 */ 1509 if (!retval && new_rlim && resource == RLIMIT_CPU && 1510 new_rlim->rlim_cur != RLIM_INFINITY && 1511 IS_ENABLED(CONFIG_POSIX_TIMERS)) { 1512 /* 1513 * update_rlimit_cpu can fail if the task is exiting, but there 1514 * may be other tasks in the thread group that are not exiting, 1515 * and they need their cpu timers adjusted. 1516 * 1517 * The group_leader is the last task to be released, so if we 1518 * cannot update_rlimit_cpu on it, then the entire process is 1519 * exiting and we do not need to update at all. 1520 */ 1521 update_rlimit_cpu(tsk->group_leader, new_rlim->rlim_cur); 1522 } 1523 1524 return retval; 1525 } 1526 1527 SYSCALL_DEFINE2(getrlimit, unsigned int, resource, struct rlimit __user *, rlim) 1528 { 1529 struct rlimit value; 1530 int ret; 1531 1532 ret = do_prlimit(current, resource, NULL, &value); 1533 if (!ret) 1534 ret = copy_to_user(rlim, &value, sizeof(*rlim)) ? -EFAULT : 0; 1535 1536 return ret; 1537 } 1538 1539 #ifdef CONFIG_COMPAT 1540 1541 COMPAT_SYSCALL_DEFINE2(setrlimit, unsigned int, resource, 1542 struct compat_rlimit __user *, rlim) 1543 { 1544 struct rlimit r; 1545 struct compat_rlimit r32; 1546 1547 if (copy_from_user(&r32, rlim, sizeof(struct compat_rlimit))) 1548 return -EFAULT; 1549 1550 if (r32.rlim_cur == COMPAT_RLIM_INFINITY) 1551 r.rlim_cur = RLIM_INFINITY; 1552 else 1553 r.rlim_cur = r32.rlim_cur; 1554 if (r32.rlim_max == COMPAT_RLIM_INFINITY) 1555 r.rlim_max = RLIM_INFINITY; 1556 else 1557 r.rlim_max = r32.rlim_max; 1558 return do_prlimit(current, resource, &r, NULL); 1559 } 1560 1561 COMPAT_SYSCALL_DEFINE2(getrlimit, unsigned int, resource, 1562 struct compat_rlimit __user *, rlim) 1563 { 1564 struct rlimit r; 1565 int ret; 1566 1567 ret = do_prlimit(current, resource, NULL, &r); 1568 if (!ret) { 1569 struct compat_rlimit r32; 1570 if (r.rlim_cur > COMPAT_RLIM_INFINITY) 1571 r32.rlim_cur = COMPAT_RLIM_INFINITY; 1572 else 1573 r32.rlim_cur = r.rlim_cur; 1574 if (r.rlim_max > COMPAT_RLIM_INFINITY) 1575 r32.rlim_max = COMPAT_RLIM_INFINITY; 1576 else 1577 r32.rlim_max = r.rlim_max; 1578 1579 if (copy_to_user(rlim, &r32, sizeof(struct compat_rlimit))) 1580 return -EFAULT; 1581 } 1582 return ret; 1583 } 1584 1585 #endif 1586 1587 #ifdef __ARCH_WANT_SYS_OLD_GETRLIMIT 1588 1589 /* 1590 * Back compatibility for getrlimit. Needed for some apps. 1591 */ 1592 SYSCALL_DEFINE2(old_getrlimit, unsigned int, resource, 1593 struct rlimit __user *, rlim) 1594 { 1595 struct rlimit x; 1596 if (resource >= RLIM_NLIMITS) 1597 return -EINVAL; 1598 1599 resource = array_index_nospec(resource, RLIM_NLIMITS); 1600 task_lock(current->group_leader); 1601 x = current->signal->rlim[resource]; 1602 task_unlock(current->group_leader); 1603 if (x.rlim_cur > 0x7FFFFFFF) 1604 x.rlim_cur = 0x7FFFFFFF; 1605 if (x.rlim_max > 0x7FFFFFFF) 1606 x.rlim_max = 0x7FFFFFFF; 1607 return copy_to_user(rlim, &x, sizeof(x)) ? -EFAULT : 0; 1608 } 1609 1610 #ifdef CONFIG_COMPAT 1611 COMPAT_SYSCALL_DEFINE2(old_getrlimit, unsigned int, resource, 1612 struct compat_rlimit __user *, rlim) 1613 { 1614 struct rlimit r; 1615 1616 if (resource >= RLIM_NLIMITS) 1617 return -EINVAL; 1618 1619 resource = array_index_nospec(resource, RLIM_NLIMITS); 1620 task_lock(current->group_leader); 1621 r = current->signal->rlim[resource]; 1622 task_unlock(current->group_leader); 1623 if (r.rlim_cur > 0x7FFFFFFF) 1624 r.rlim_cur = 0x7FFFFFFF; 1625 if (r.rlim_max > 0x7FFFFFFF) 1626 r.rlim_max = 0x7FFFFFFF; 1627 1628 if (put_user(r.rlim_cur, &rlim->rlim_cur) || 1629 put_user(r.rlim_max, &rlim->rlim_max)) 1630 return -EFAULT; 1631 return 0; 1632 } 1633 #endif 1634 1635 #endif 1636 1637 static inline bool rlim64_is_infinity(__u64 rlim64) 1638 { 1639 #if BITS_PER_LONG < 64 1640 return rlim64 >= ULONG_MAX; 1641 #else 1642 return rlim64 == RLIM64_INFINITY; 1643 #endif 1644 } 1645 1646 static void rlim_to_rlim64(const struct rlimit *rlim, struct rlimit64 *rlim64) 1647 { 1648 if (rlim->rlim_cur == RLIM_INFINITY) 1649 rlim64->rlim_cur = RLIM64_INFINITY; 1650 else 1651 rlim64->rlim_cur = rlim->rlim_cur; 1652 if (rlim->rlim_max == RLIM_INFINITY) 1653 rlim64->rlim_max = RLIM64_INFINITY; 1654 else 1655 rlim64->rlim_max = rlim->rlim_max; 1656 } 1657 1658 static void rlim64_to_rlim(const struct rlimit64 *rlim64, struct rlimit *rlim) 1659 { 1660 if (rlim64_is_infinity(rlim64->rlim_cur)) 1661 rlim->rlim_cur = RLIM_INFINITY; 1662 else 1663 rlim->rlim_cur = (unsigned long)rlim64->rlim_cur; 1664 if (rlim64_is_infinity(rlim64->rlim_max)) 1665 rlim->rlim_max = RLIM_INFINITY; 1666 else 1667 rlim->rlim_max = (unsigned long)rlim64->rlim_max; 1668 } 1669 1670 /* rcu lock must be held */ 1671 static int check_prlimit_permission(struct task_struct *task, 1672 unsigned int flags) 1673 { 1674 const struct cred *cred = current_cred(), *tcred; 1675 bool id_match; 1676 1677 if (current == task) 1678 return 0; 1679 1680 tcred = __task_cred(task); 1681 id_match = (uid_eq(cred->uid, tcred->euid) && 1682 uid_eq(cred->uid, tcred->suid) && 1683 uid_eq(cred->uid, tcred->uid) && 1684 gid_eq(cred->gid, tcred->egid) && 1685 gid_eq(cred->gid, tcred->sgid) && 1686 gid_eq(cred->gid, tcred->gid)); 1687 if (!id_match && !ns_capable(tcred->user_ns, CAP_SYS_RESOURCE)) 1688 return -EPERM; 1689 1690 return security_task_prlimit(cred, tcred, flags); 1691 } 1692 1693 SYSCALL_DEFINE4(prlimit64, pid_t, pid, unsigned int, resource, 1694 const struct rlimit64 __user *, new_rlim, 1695 struct rlimit64 __user *, old_rlim) 1696 { 1697 struct rlimit64 old64, new64; 1698 struct rlimit old, new; 1699 struct task_struct *tsk; 1700 unsigned int checkflags = 0; 1701 int ret; 1702 1703 if (old_rlim) 1704 checkflags |= LSM_PRLIMIT_READ; 1705 1706 if (new_rlim) { 1707 if (copy_from_user(&new64, new_rlim, sizeof(new64))) 1708 return -EFAULT; 1709 rlim64_to_rlim(&new64, &new); 1710 checkflags |= LSM_PRLIMIT_WRITE; 1711 } 1712 1713 rcu_read_lock(); 1714 tsk = pid ? find_task_by_vpid(pid) : current; 1715 if (!tsk) { 1716 rcu_read_unlock(); 1717 return -ESRCH; 1718 } 1719 ret = check_prlimit_permission(tsk, checkflags); 1720 if (ret) { 1721 rcu_read_unlock(); 1722 return ret; 1723 } 1724 get_task_struct(tsk); 1725 rcu_read_unlock(); 1726 1727 ret = do_prlimit(tsk, resource, new_rlim ? &new : NULL, 1728 old_rlim ? &old : NULL); 1729 1730 if (!ret && old_rlim) { 1731 rlim_to_rlim64(&old, &old64); 1732 if (copy_to_user(old_rlim, &old64, sizeof(old64))) 1733 ret = -EFAULT; 1734 } 1735 1736 put_task_struct(tsk); 1737 return ret; 1738 } 1739 1740 SYSCALL_DEFINE2(setrlimit, unsigned int, resource, struct rlimit __user *, rlim) 1741 { 1742 struct rlimit new_rlim; 1743 1744 if (copy_from_user(&new_rlim, rlim, sizeof(*rlim))) 1745 return -EFAULT; 1746 return do_prlimit(current, resource, &new_rlim, NULL); 1747 } 1748 1749 /* 1750 * It would make sense to put struct rusage in the task_struct, 1751 * except that would make the task_struct be *really big*. After 1752 * task_struct gets moved into malloc'ed memory, it would 1753 * make sense to do this. It will make moving the rest of the information 1754 * a lot simpler! (Which we're not doing right now because we're not 1755 * measuring them yet). 1756 * 1757 * When sampling multiple threads for RUSAGE_SELF, under SMP we might have 1758 * races with threads incrementing their own counters. But since word 1759 * reads are atomic, we either get new values or old values and we don't 1760 * care which for the sums. We always take the siglock to protect reading 1761 * the c* fields from p->signal from races with exit.c updating those 1762 * fields when reaping, so a sample either gets all the additions of a 1763 * given child after it's reaped, or none so this sample is before reaping. 1764 * 1765 * Locking: 1766 * We need to take the siglock for CHILDEREN, SELF and BOTH 1767 * for the cases current multithreaded, non-current single threaded 1768 * non-current multithreaded. Thread traversal is now safe with 1769 * the siglock held. 1770 * Strictly speaking, we donot need to take the siglock if we are current and 1771 * single threaded, as no one else can take our signal_struct away, no one 1772 * else can reap the children to update signal->c* counters, and no one else 1773 * can race with the signal-> fields. If we do not take any lock, the 1774 * signal-> fields could be read out of order while another thread was just 1775 * exiting. So we should place a read memory barrier when we avoid the lock. 1776 * On the writer side, write memory barrier is implied in __exit_signal 1777 * as __exit_signal releases the siglock spinlock after updating the signal-> 1778 * fields. But we don't do this yet to keep things simple. 1779 * 1780 */ 1781 1782 static void accumulate_thread_rusage(struct task_struct *t, struct rusage *r) 1783 { 1784 r->ru_nvcsw += t->nvcsw; 1785 r->ru_nivcsw += t->nivcsw; 1786 r->ru_minflt += t->min_flt; 1787 r->ru_majflt += t->maj_flt; 1788 r->ru_inblock += task_io_get_inblock(t); 1789 r->ru_oublock += task_io_get_oublock(t); 1790 } 1791 1792 void getrusage(struct task_struct *p, int who, struct rusage *r) 1793 { 1794 struct task_struct *t; 1795 unsigned long flags; 1796 u64 tgutime, tgstime, utime, stime; 1797 unsigned long maxrss; 1798 struct mm_struct *mm; 1799 struct signal_struct *sig = p->signal; 1800 unsigned int seq = 0; 1801 1802 retry: 1803 memset(r, 0, sizeof(*r)); 1804 utime = stime = 0; 1805 maxrss = 0; 1806 1807 if (who == RUSAGE_THREAD) { 1808 task_cputime_adjusted(current, &utime, &stime); 1809 accumulate_thread_rusage(p, r); 1810 maxrss = sig->maxrss; 1811 goto out_thread; 1812 } 1813 1814 flags = read_seqbegin_or_lock_irqsave(&sig->stats_lock, &seq); 1815 1816 switch (who) { 1817 case RUSAGE_BOTH: 1818 case RUSAGE_CHILDREN: 1819 utime = sig->cutime; 1820 stime = sig->cstime; 1821 r->ru_nvcsw = sig->cnvcsw; 1822 r->ru_nivcsw = sig->cnivcsw; 1823 r->ru_minflt = sig->cmin_flt; 1824 r->ru_majflt = sig->cmaj_flt; 1825 r->ru_inblock = sig->cinblock; 1826 r->ru_oublock = sig->coublock; 1827 maxrss = sig->cmaxrss; 1828 1829 if (who == RUSAGE_CHILDREN) 1830 break; 1831 fallthrough; 1832 1833 case RUSAGE_SELF: 1834 r->ru_nvcsw += sig->nvcsw; 1835 r->ru_nivcsw += sig->nivcsw; 1836 r->ru_minflt += sig->min_flt; 1837 r->ru_majflt += sig->maj_flt; 1838 r->ru_inblock += sig->inblock; 1839 r->ru_oublock += sig->oublock; 1840 if (maxrss < sig->maxrss) 1841 maxrss = sig->maxrss; 1842 1843 rcu_read_lock(); 1844 __for_each_thread(sig, t) 1845 accumulate_thread_rusage(t, r); 1846 rcu_read_unlock(); 1847 1848 break; 1849 1850 default: 1851 BUG(); 1852 } 1853 1854 if (need_seqretry(&sig->stats_lock, seq)) { 1855 seq = 1; 1856 goto retry; 1857 } 1858 done_seqretry_irqrestore(&sig->stats_lock, seq, flags); 1859 1860 if (who == RUSAGE_CHILDREN) 1861 goto out_children; 1862 1863 thread_group_cputime_adjusted(p, &tgutime, &tgstime); 1864 utime += tgutime; 1865 stime += tgstime; 1866 1867 out_thread: 1868 mm = get_task_mm(p); 1869 if (mm) { 1870 setmax_mm_hiwater_rss(&maxrss, mm); 1871 mmput(mm); 1872 } 1873 1874 out_children: 1875 r->ru_maxrss = maxrss * (PAGE_SIZE / 1024); /* convert pages to KBs */ 1876 r->ru_utime = ns_to_kernel_old_timeval(utime); 1877 r->ru_stime = ns_to_kernel_old_timeval(stime); 1878 } 1879 1880 SYSCALL_DEFINE2(getrusage, int, who, struct rusage __user *, ru) 1881 { 1882 struct rusage r; 1883 1884 if (who != RUSAGE_SELF && who != RUSAGE_CHILDREN && 1885 who != RUSAGE_THREAD) 1886 return -EINVAL; 1887 1888 getrusage(current, who, &r); 1889 return copy_to_user(ru, &r, sizeof(r)) ? -EFAULT : 0; 1890 } 1891 1892 #ifdef CONFIG_COMPAT 1893 COMPAT_SYSCALL_DEFINE2(getrusage, int, who, struct compat_rusage __user *, ru) 1894 { 1895 struct rusage r; 1896 1897 if (who != RUSAGE_SELF && who != RUSAGE_CHILDREN && 1898 who != RUSAGE_THREAD) 1899 return -EINVAL; 1900 1901 getrusage(current, who, &r); 1902 return put_compat_rusage(&r, ru); 1903 } 1904 #endif 1905 1906 SYSCALL_DEFINE1(umask, int, mask) 1907 { 1908 mask = xchg(¤t->fs->umask, mask & S_IRWXUGO); 1909 return mask; 1910 } 1911 1912 static int prctl_set_mm_exe_file(struct mm_struct *mm, unsigned int fd) 1913 { 1914 struct fd exe; 1915 struct inode *inode; 1916 int err; 1917 1918 exe = fdget(fd); 1919 if (!fd_file(exe)) 1920 return -EBADF; 1921 1922 inode = file_inode(fd_file(exe)); 1923 1924 /* 1925 * Because the original mm->exe_file points to executable file, make 1926 * sure that this one is executable as well, to avoid breaking an 1927 * overall picture. 1928 */ 1929 err = -EACCES; 1930 if (!S_ISREG(inode->i_mode) || path_noexec(&fd_file(exe)->f_path)) 1931 goto exit; 1932 1933 err = file_permission(fd_file(exe), MAY_EXEC); 1934 if (err) 1935 goto exit; 1936 1937 err = replace_mm_exe_file(mm, fd_file(exe)); 1938 exit: 1939 fdput(exe); 1940 return err; 1941 } 1942 1943 /* 1944 * Check arithmetic relations of passed addresses. 1945 * 1946 * WARNING: we don't require any capability here so be very careful 1947 * in what is allowed for modification from userspace. 1948 */ 1949 static int validate_prctl_map_addr(struct prctl_mm_map *prctl_map) 1950 { 1951 unsigned long mmap_max_addr = TASK_SIZE; 1952 int error = -EINVAL, i; 1953 1954 static const unsigned char offsets[] = { 1955 offsetof(struct prctl_mm_map, start_code), 1956 offsetof(struct prctl_mm_map, end_code), 1957 offsetof(struct prctl_mm_map, start_data), 1958 offsetof(struct prctl_mm_map, end_data), 1959 offsetof(struct prctl_mm_map, start_brk), 1960 offsetof(struct prctl_mm_map, brk), 1961 offsetof(struct prctl_mm_map, start_stack), 1962 offsetof(struct prctl_mm_map, arg_start), 1963 offsetof(struct prctl_mm_map, arg_end), 1964 offsetof(struct prctl_mm_map, env_start), 1965 offsetof(struct prctl_mm_map, env_end), 1966 }; 1967 1968 /* 1969 * Make sure the members are not somewhere outside 1970 * of allowed address space. 1971 */ 1972 for (i = 0; i < ARRAY_SIZE(offsets); i++) { 1973 u64 val = *(u64 *)((char *)prctl_map + offsets[i]); 1974 1975 if ((unsigned long)val >= mmap_max_addr || 1976 (unsigned long)val < mmap_min_addr) 1977 goto out; 1978 } 1979 1980 /* 1981 * Make sure the pairs are ordered. 1982 */ 1983 #define __prctl_check_order(__m1, __op, __m2) \ 1984 ((unsigned long)prctl_map->__m1 __op \ 1985 (unsigned long)prctl_map->__m2) ? 0 : -EINVAL 1986 error = __prctl_check_order(start_code, <, end_code); 1987 error |= __prctl_check_order(start_data,<=, end_data); 1988 error |= __prctl_check_order(start_brk, <=, brk); 1989 error |= __prctl_check_order(arg_start, <=, arg_end); 1990 error |= __prctl_check_order(env_start, <=, env_end); 1991 if (error) 1992 goto out; 1993 #undef __prctl_check_order 1994 1995 error = -EINVAL; 1996 1997 /* 1998 * Neither we should allow to override limits if they set. 1999 */ 2000 if (check_data_rlimit(rlimit(RLIMIT_DATA), prctl_map->brk, 2001 prctl_map->start_brk, prctl_map->end_data, 2002 prctl_map->start_data)) 2003 goto out; 2004 2005 error = 0; 2006 out: 2007 return error; 2008 } 2009 2010 #ifdef CONFIG_CHECKPOINT_RESTORE 2011 static int prctl_set_mm_map(int opt, const void __user *addr, unsigned long data_size) 2012 { 2013 struct prctl_mm_map prctl_map = { .exe_fd = (u32)-1, }; 2014 unsigned long user_auxv[AT_VECTOR_SIZE]; 2015 struct mm_struct *mm = current->mm; 2016 int error; 2017 2018 BUILD_BUG_ON(sizeof(user_auxv) != sizeof(mm->saved_auxv)); 2019 BUILD_BUG_ON(sizeof(struct prctl_mm_map) > 256); 2020 2021 if (opt == PR_SET_MM_MAP_SIZE) 2022 return put_user((unsigned int)sizeof(prctl_map), 2023 (unsigned int __user *)addr); 2024 2025 if (data_size != sizeof(prctl_map)) 2026 return -EINVAL; 2027 2028 if (copy_from_user(&prctl_map, addr, sizeof(prctl_map))) 2029 return -EFAULT; 2030 2031 error = validate_prctl_map_addr(&prctl_map); 2032 if (error) 2033 return error; 2034 2035 if (prctl_map.auxv_size) { 2036 /* 2037 * Someone is trying to cheat the auxv vector. 2038 */ 2039 if (!prctl_map.auxv || 2040 prctl_map.auxv_size > sizeof(mm->saved_auxv)) 2041 return -EINVAL; 2042 2043 memset(user_auxv, 0, sizeof(user_auxv)); 2044 if (copy_from_user(user_auxv, 2045 (const void __user *)prctl_map.auxv, 2046 prctl_map.auxv_size)) 2047 return -EFAULT; 2048 2049 /* Last entry must be AT_NULL as specification requires */ 2050 user_auxv[AT_VECTOR_SIZE - 2] = AT_NULL; 2051 user_auxv[AT_VECTOR_SIZE - 1] = AT_NULL; 2052 } 2053 2054 if (prctl_map.exe_fd != (u32)-1) { 2055 /* 2056 * Check if the current user is checkpoint/restore capable. 2057 * At the time of this writing, it checks for CAP_SYS_ADMIN 2058 * or CAP_CHECKPOINT_RESTORE. 2059 * Note that a user with access to ptrace can masquerade an 2060 * arbitrary program as any executable, even setuid ones. 2061 * This may have implications in the tomoyo subsystem. 2062 */ 2063 if (!checkpoint_restore_ns_capable(current_user_ns())) 2064 return -EPERM; 2065 2066 error = prctl_set_mm_exe_file(mm, prctl_map.exe_fd); 2067 if (error) 2068 return error; 2069 } 2070 2071 /* 2072 * arg_lock protects concurrent updates but we still need mmap_lock for 2073 * read to exclude races with sys_brk. 2074 */ 2075 mmap_read_lock(mm); 2076 2077 /* 2078 * We don't validate if these members are pointing to 2079 * real present VMAs because application may have correspond 2080 * VMAs already unmapped and kernel uses these members for statistics 2081 * output in procfs mostly, except 2082 * 2083 * - @start_brk/@brk which are used in do_brk_flags but kernel lookups 2084 * for VMAs when updating these members so anything wrong written 2085 * here cause kernel to swear at userspace program but won't lead 2086 * to any problem in kernel itself 2087 */ 2088 2089 spin_lock(&mm->arg_lock); 2090 mm->start_code = prctl_map.start_code; 2091 mm->end_code = prctl_map.end_code; 2092 mm->start_data = prctl_map.start_data; 2093 mm->end_data = prctl_map.end_data; 2094 mm->start_brk = prctl_map.start_brk; 2095 mm->brk = prctl_map.brk; 2096 mm->start_stack = prctl_map.start_stack; 2097 mm->arg_start = prctl_map.arg_start; 2098 mm->arg_end = prctl_map.arg_end; 2099 mm->env_start = prctl_map.env_start; 2100 mm->env_end = prctl_map.env_end; 2101 spin_unlock(&mm->arg_lock); 2102 2103 /* 2104 * Note this update of @saved_auxv is lockless thus 2105 * if someone reads this member in procfs while we're 2106 * updating -- it may get partly updated results. It's 2107 * known and acceptable trade off: we leave it as is to 2108 * not introduce additional locks here making the kernel 2109 * more complex. 2110 */ 2111 if (prctl_map.auxv_size) 2112 memcpy(mm->saved_auxv, user_auxv, sizeof(user_auxv)); 2113 2114 mmap_read_unlock(mm); 2115 return 0; 2116 } 2117 #endif /* CONFIG_CHECKPOINT_RESTORE */ 2118 2119 static int prctl_set_auxv(struct mm_struct *mm, unsigned long addr, 2120 unsigned long len) 2121 { 2122 /* 2123 * This doesn't move the auxiliary vector itself since it's pinned to 2124 * mm_struct, but it permits filling the vector with new values. It's 2125 * up to the caller to provide sane values here, otherwise userspace 2126 * tools which use this vector might be unhappy. 2127 */ 2128 unsigned long user_auxv[AT_VECTOR_SIZE] = {}; 2129 2130 if (len > sizeof(user_auxv)) 2131 return -EINVAL; 2132 2133 if (copy_from_user(user_auxv, (const void __user *)addr, len)) 2134 return -EFAULT; 2135 2136 /* Make sure the last entry is always AT_NULL */ 2137 user_auxv[AT_VECTOR_SIZE - 2] = 0; 2138 user_auxv[AT_VECTOR_SIZE - 1] = 0; 2139 2140 BUILD_BUG_ON(sizeof(user_auxv) != sizeof(mm->saved_auxv)); 2141 2142 task_lock(current); 2143 memcpy(mm->saved_auxv, user_auxv, len); 2144 task_unlock(current); 2145 2146 return 0; 2147 } 2148 2149 static int prctl_set_mm(int opt, unsigned long addr, 2150 unsigned long arg4, unsigned long arg5) 2151 { 2152 struct mm_struct *mm = current->mm; 2153 struct prctl_mm_map prctl_map = { 2154 .auxv = NULL, 2155 .auxv_size = 0, 2156 .exe_fd = -1, 2157 }; 2158 struct vm_area_struct *vma; 2159 int error; 2160 2161 if (arg5 || (arg4 && (opt != PR_SET_MM_AUXV && 2162 opt != PR_SET_MM_MAP && 2163 opt != PR_SET_MM_MAP_SIZE))) 2164 return -EINVAL; 2165 2166 #ifdef CONFIG_CHECKPOINT_RESTORE 2167 if (opt == PR_SET_MM_MAP || opt == PR_SET_MM_MAP_SIZE) 2168 return prctl_set_mm_map(opt, (const void __user *)addr, arg4); 2169 #endif 2170 2171 if (!capable(CAP_SYS_RESOURCE)) 2172 return -EPERM; 2173 2174 if (opt == PR_SET_MM_EXE_FILE) 2175 return prctl_set_mm_exe_file(mm, (unsigned int)addr); 2176 2177 if (opt == PR_SET_MM_AUXV) 2178 return prctl_set_auxv(mm, addr, arg4); 2179 2180 if (addr >= TASK_SIZE || addr < mmap_min_addr) 2181 return -EINVAL; 2182 2183 error = -EINVAL; 2184 2185 /* 2186 * arg_lock protects concurrent updates of arg boundaries, we need 2187 * mmap_lock for a) concurrent sys_brk, b) finding VMA for addr 2188 * validation. 2189 */ 2190 mmap_read_lock(mm); 2191 vma = find_vma(mm, addr); 2192 2193 spin_lock(&mm->arg_lock); 2194 prctl_map.start_code = mm->start_code; 2195 prctl_map.end_code = mm->end_code; 2196 prctl_map.start_data = mm->start_data; 2197 prctl_map.end_data = mm->end_data; 2198 prctl_map.start_brk = mm->start_brk; 2199 prctl_map.brk = mm->brk; 2200 prctl_map.start_stack = mm->start_stack; 2201 prctl_map.arg_start = mm->arg_start; 2202 prctl_map.arg_end = mm->arg_end; 2203 prctl_map.env_start = mm->env_start; 2204 prctl_map.env_end = mm->env_end; 2205 2206 switch (opt) { 2207 case PR_SET_MM_START_CODE: 2208 prctl_map.start_code = addr; 2209 break; 2210 case PR_SET_MM_END_CODE: 2211 prctl_map.end_code = addr; 2212 break; 2213 case PR_SET_MM_START_DATA: 2214 prctl_map.start_data = addr; 2215 break; 2216 case PR_SET_MM_END_DATA: 2217 prctl_map.end_data = addr; 2218 break; 2219 case PR_SET_MM_START_STACK: 2220 prctl_map.start_stack = addr; 2221 break; 2222 case PR_SET_MM_START_BRK: 2223 prctl_map.start_brk = addr; 2224 break; 2225 case PR_SET_MM_BRK: 2226 prctl_map.brk = addr; 2227 break; 2228 case PR_SET_MM_ARG_START: 2229 prctl_map.arg_start = addr; 2230 break; 2231 case PR_SET_MM_ARG_END: 2232 prctl_map.arg_end = addr; 2233 break; 2234 case PR_SET_MM_ENV_START: 2235 prctl_map.env_start = addr; 2236 break; 2237 case PR_SET_MM_ENV_END: 2238 prctl_map.env_end = addr; 2239 break; 2240 default: 2241 goto out; 2242 } 2243 2244 error = validate_prctl_map_addr(&prctl_map); 2245 if (error) 2246 goto out; 2247 2248 switch (opt) { 2249 /* 2250 * If command line arguments and environment 2251 * are placed somewhere else on stack, we can 2252 * set them up here, ARG_START/END to setup 2253 * command line arguments and ENV_START/END 2254 * for environment. 2255 */ 2256 case PR_SET_MM_START_STACK: 2257 case PR_SET_MM_ARG_START: 2258 case PR_SET_MM_ARG_END: 2259 case PR_SET_MM_ENV_START: 2260 case PR_SET_MM_ENV_END: 2261 if (!vma) { 2262 error = -EFAULT; 2263 goto out; 2264 } 2265 } 2266 2267 mm->start_code = prctl_map.start_code; 2268 mm->end_code = prctl_map.end_code; 2269 mm->start_data = prctl_map.start_data; 2270 mm->end_data = prctl_map.end_data; 2271 mm->start_brk = prctl_map.start_brk; 2272 mm->brk = prctl_map.brk; 2273 mm->start_stack = prctl_map.start_stack; 2274 mm->arg_start = prctl_map.arg_start; 2275 mm->arg_end = prctl_map.arg_end; 2276 mm->env_start = prctl_map.env_start; 2277 mm->env_end = prctl_map.env_end; 2278 2279 error = 0; 2280 out: 2281 spin_unlock(&mm->arg_lock); 2282 mmap_read_unlock(mm); 2283 return error; 2284 } 2285 2286 #ifdef CONFIG_CHECKPOINT_RESTORE 2287 static int prctl_get_tid_address(struct task_struct *me, int __user * __user *tid_addr) 2288 { 2289 return put_user(me->clear_child_tid, tid_addr); 2290 } 2291 #else 2292 static int prctl_get_tid_address(struct task_struct *me, int __user * __user *tid_addr) 2293 { 2294 return -EINVAL; 2295 } 2296 #endif 2297 2298 static int propagate_has_child_subreaper(struct task_struct *p, void *data) 2299 { 2300 /* 2301 * If task has has_child_subreaper - all its descendants 2302 * already have these flag too and new descendants will 2303 * inherit it on fork, skip them. 2304 * 2305 * If we've found child_reaper - skip descendants in 2306 * it's subtree as they will never get out pidns. 2307 */ 2308 if (p->signal->has_child_subreaper || 2309 is_child_reaper(task_pid(p))) 2310 return 0; 2311 2312 p->signal->has_child_subreaper = 1; 2313 return 1; 2314 } 2315 2316 int __weak arch_prctl_spec_ctrl_get(struct task_struct *t, unsigned long which) 2317 { 2318 return -EINVAL; 2319 } 2320 2321 int __weak arch_prctl_spec_ctrl_set(struct task_struct *t, unsigned long which, 2322 unsigned long ctrl) 2323 { 2324 return -EINVAL; 2325 } 2326 2327 #define PR_IO_FLUSHER (PF_MEMALLOC_NOIO | PF_LOCAL_THROTTLE) 2328 2329 #ifdef CONFIG_ANON_VMA_NAME 2330 2331 #define ANON_VMA_NAME_MAX_LEN 80 2332 #define ANON_VMA_NAME_INVALID_CHARS "\\`$[]" 2333 2334 static inline bool is_valid_name_char(char ch) 2335 { 2336 /* printable ascii characters, excluding ANON_VMA_NAME_INVALID_CHARS */ 2337 return ch > 0x1f && ch < 0x7f && 2338 !strchr(ANON_VMA_NAME_INVALID_CHARS, ch); 2339 } 2340 2341 static int prctl_set_vma(unsigned long opt, unsigned long addr, 2342 unsigned long size, unsigned long arg) 2343 { 2344 struct mm_struct *mm = current->mm; 2345 const char __user *uname; 2346 struct anon_vma_name *anon_name = NULL; 2347 int error; 2348 2349 switch (opt) { 2350 case PR_SET_VMA_ANON_NAME: 2351 uname = (const char __user *)arg; 2352 if (uname) { 2353 char *name, *pch; 2354 2355 name = strndup_user(uname, ANON_VMA_NAME_MAX_LEN); 2356 if (IS_ERR(name)) 2357 return PTR_ERR(name); 2358 2359 for (pch = name; *pch != '\0'; pch++) { 2360 if (!is_valid_name_char(*pch)) { 2361 kfree(name); 2362 return -EINVAL; 2363 } 2364 } 2365 /* anon_vma has its own copy */ 2366 anon_name = anon_vma_name_alloc(name); 2367 kfree(name); 2368 if (!anon_name) 2369 return -ENOMEM; 2370 2371 } 2372 2373 mmap_write_lock(mm); 2374 error = madvise_set_anon_name(mm, addr, size, anon_name); 2375 mmap_write_unlock(mm); 2376 anon_vma_name_put(anon_name); 2377 break; 2378 default: 2379 error = -EINVAL; 2380 } 2381 2382 return error; 2383 } 2384 2385 #else /* CONFIG_ANON_VMA_NAME */ 2386 static int prctl_set_vma(unsigned long opt, unsigned long start, 2387 unsigned long size, unsigned long arg) 2388 { 2389 return -EINVAL; 2390 } 2391 #endif /* CONFIG_ANON_VMA_NAME */ 2392 2393 static inline unsigned long get_current_mdwe(void) 2394 { 2395 unsigned long ret = 0; 2396 2397 if (test_bit(MMF_HAS_MDWE, ¤t->mm->flags)) 2398 ret |= PR_MDWE_REFUSE_EXEC_GAIN; 2399 if (test_bit(MMF_HAS_MDWE_NO_INHERIT, ¤t->mm->flags)) 2400 ret |= PR_MDWE_NO_INHERIT; 2401 2402 return ret; 2403 } 2404 2405 static inline int prctl_set_mdwe(unsigned long bits, unsigned long arg3, 2406 unsigned long arg4, unsigned long arg5) 2407 { 2408 unsigned long current_bits; 2409 2410 if (arg3 || arg4 || arg5) 2411 return -EINVAL; 2412 2413 if (bits & ~(PR_MDWE_REFUSE_EXEC_GAIN | PR_MDWE_NO_INHERIT)) 2414 return -EINVAL; 2415 2416 /* NO_INHERIT only makes sense with REFUSE_EXEC_GAIN */ 2417 if (bits & PR_MDWE_NO_INHERIT && !(bits & PR_MDWE_REFUSE_EXEC_GAIN)) 2418 return -EINVAL; 2419 2420 /* 2421 * EOPNOTSUPP might be more appropriate here in principle, but 2422 * existing userspace depends on EINVAL specifically. 2423 */ 2424 if (!arch_memory_deny_write_exec_supported()) 2425 return -EINVAL; 2426 2427 current_bits = get_current_mdwe(); 2428 if (current_bits && current_bits != bits) 2429 return -EPERM; /* Cannot unset the flags */ 2430 2431 if (bits & PR_MDWE_NO_INHERIT) 2432 set_bit(MMF_HAS_MDWE_NO_INHERIT, ¤t->mm->flags); 2433 if (bits & PR_MDWE_REFUSE_EXEC_GAIN) 2434 set_bit(MMF_HAS_MDWE, ¤t->mm->flags); 2435 2436 return 0; 2437 } 2438 2439 static inline int prctl_get_mdwe(unsigned long arg2, unsigned long arg3, 2440 unsigned long arg4, unsigned long arg5) 2441 { 2442 if (arg2 || arg3 || arg4 || arg5) 2443 return -EINVAL; 2444 return get_current_mdwe(); 2445 } 2446 2447 static int prctl_get_auxv(void __user *addr, unsigned long len) 2448 { 2449 struct mm_struct *mm = current->mm; 2450 unsigned long size = min_t(unsigned long, sizeof(mm->saved_auxv), len); 2451 2452 if (size && copy_to_user(addr, mm->saved_auxv, size)) 2453 return -EFAULT; 2454 return sizeof(mm->saved_auxv); 2455 } 2456 2457 SYSCALL_DEFINE5(prctl, int, option, unsigned long, arg2, unsigned long, arg3, 2458 unsigned long, arg4, unsigned long, arg5) 2459 { 2460 struct task_struct *me = current; 2461 unsigned char comm[sizeof(me->comm)]; 2462 long error; 2463 2464 error = security_task_prctl(option, arg2, arg3, arg4, arg5); 2465 if (error != -ENOSYS) 2466 return error; 2467 2468 error = 0; 2469 switch (option) { 2470 case PR_SET_PDEATHSIG: 2471 if (!valid_signal(arg2)) { 2472 error = -EINVAL; 2473 break; 2474 } 2475 me->pdeath_signal = arg2; 2476 break; 2477 case PR_GET_PDEATHSIG: 2478 error = put_user(me->pdeath_signal, (int __user *)arg2); 2479 break; 2480 case PR_GET_DUMPABLE: 2481 error = get_dumpable(me->mm); 2482 break; 2483 case PR_SET_DUMPABLE: 2484 if (arg2 != SUID_DUMP_DISABLE && arg2 != SUID_DUMP_USER) { 2485 error = -EINVAL; 2486 break; 2487 } 2488 set_dumpable(me->mm, arg2); 2489 break; 2490 2491 case PR_SET_UNALIGN: 2492 error = SET_UNALIGN_CTL(me, arg2); 2493 break; 2494 case PR_GET_UNALIGN: 2495 error = GET_UNALIGN_CTL(me, arg2); 2496 break; 2497 case PR_SET_FPEMU: 2498 error = SET_FPEMU_CTL(me, arg2); 2499 break; 2500 case PR_GET_FPEMU: 2501 error = GET_FPEMU_CTL(me, arg2); 2502 break; 2503 case PR_SET_FPEXC: 2504 error = SET_FPEXC_CTL(me, arg2); 2505 break; 2506 case PR_GET_FPEXC: 2507 error = GET_FPEXC_CTL(me, arg2); 2508 break; 2509 case PR_GET_TIMING: 2510 error = PR_TIMING_STATISTICAL; 2511 break; 2512 case PR_SET_TIMING: 2513 if (arg2 != PR_TIMING_STATISTICAL) 2514 error = -EINVAL; 2515 break; 2516 case PR_SET_NAME: 2517 comm[sizeof(me->comm) - 1] = 0; 2518 if (strncpy_from_user(comm, (char __user *)arg2, 2519 sizeof(me->comm) - 1) < 0) 2520 return -EFAULT; 2521 set_task_comm(me, comm); 2522 proc_comm_connector(me); 2523 break; 2524 case PR_GET_NAME: 2525 get_task_comm(comm, me); 2526 if (copy_to_user((char __user *)arg2, comm, sizeof(comm))) 2527 return -EFAULT; 2528 break; 2529 case PR_GET_ENDIAN: 2530 error = GET_ENDIAN(me, arg2); 2531 break; 2532 case PR_SET_ENDIAN: 2533 error = SET_ENDIAN(me, arg2); 2534 break; 2535 case PR_GET_SECCOMP: 2536 error = prctl_get_seccomp(); 2537 break; 2538 case PR_SET_SECCOMP: 2539 error = prctl_set_seccomp(arg2, (char __user *)arg3); 2540 break; 2541 case PR_GET_TSC: 2542 error = GET_TSC_CTL(arg2); 2543 break; 2544 case PR_SET_TSC: 2545 error = SET_TSC_CTL(arg2); 2546 break; 2547 case PR_TASK_PERF_EVENTS_DISABLE: 2548 error = perf_event_task_disable(); 2549 break; 2550 case PR_TASK_PERF_EVENTS_ENABLE: 2551 error = perf_event_task_enable(); 2552 break; 2553 case PR_GET_TIMERSLACK: 2554 if (current->timer_slack_ns > ULONG_MAX) 2555 error = ULONG_MAX; 2556 else 2557 error = current->timer_slack_ns; 2558 break; 2559 case PR_SET_TIMERSLACK: 2560 if (rt_or_dl_task_policy(current)) 2561 break; 2562 if (arg2 <= 0) 2563 current->timer_slack_ns = 2564 current->default_timer_slack_ns; 2565 else 2566 current->timer_slack_ns = arg2; 2567 break; 2568 case PR_MCE_KILL: 2569 if (arg4 | arg5) 2570 return -EINVAL; 2571 switch (arg2) { 2572 case PR_MCE_KILL_CLEAR: 2573 if (arg3 != 0) 2574 return -EINVAL; 2575 current->flags &= ~PF_MCE_PROCESS; 2576 break; 2577 case PR_MCE_KILL_SET: 2578 current->flags |= PF_MCE_PROCESS; 2579 if (arg3 == PR_MCE_KILL_EARLY) 2580 current->flags |= PF_MCE_EARLY; 2581 else if (arg3 == PR_MCE_KILL_LATE) 2582 current->flags &= ~PF_MCE_EARLY; 2583 else if (arg3 == PR_MCE_KILL_DEFAULT) 2584 current->flags &= 2585 ~(PF_MCE_EARLY|PF_MCE_PROCESS); 2586 else 2587 return -EINVAL; 2588 break; 2589 default: 2590 return -EINVAL; 2591 } 2592 break; 2593 case PR_MCE_KILL_GET: 2594 if (arg2 | arg3 | arg4 | arg5) 2595 return -EINVAL; 2596 if (current->flags & PF_MCE_PROCESS) 2597 error = (current->flags & PF_MCE_EARLY) ? 2598 PR_MCE_KILL_EARLY : PR_MCE_KILL_LATE; 2599 else 2600 error = PR_MCE_KILL_DEFAULT; 2601 break; 2602 case PR_SET_MM: 2603 error = prctl_set_mm(arg2, arg3, arg4, arg5); 2604 break; 2605 case PR_GET_TID_ADDRESS: 2606 error = prctl_get_tid_address(me, (int __user * __user *)arg2); 2607 break; 2608 case PR_SET_CHILD_SUBREAPER: 2609 me->signal->is_child_subreaper = !!arg2; 2610 if (!arg2) 2611 break; 2612 2613 walk_process_tree(me, propagate_has_child_subreaper, NULL); 2614 break; 2615 case PR_GET_CHILD_SUBREAPER: 2616 error = put_user(me->signal->is_child_subreaper, 2617 (int __user *)arg2); 2618 break; 2619 case PR_SET_NO_NEW_PRIVS: 2620 if (arg2 != 1 || arg3 || arg4 || arg5) 2621 return -EINVAL; 2622 2623 task_set_no_new_privs(current); 2624 break; 2625 case PR_GET_NO_NEW_PRIVS: 2626 if (arg2 || arg3 || arg4 || arg5) 2627 return -EINVAL; 2628 return task_no_new_privs(current) ? 1 : 0; 2629 case PR_GET_THP_DISABLE: 2630 if (arg2 || arg3 || arg4 || arg5) 2631 return -EINVAL; 2632 error = !!test_bit(MMF_DISABLE_THP, &me->mm->flags); 2633 break; 2634 case PR_SET_THP_DISABLE: 2635 if (arg3 || arg4 || arg5) 2636 return -EINVAL; 2637 if (mmap_write_lock_killable(me->mm)) 2638 return -EINTR; 2639 if (arg2) 2640 set_bit(MMF_DISABLE_THP, &me->mm->flags); 2641 else 2642 clear_bit(MMF_DISABLE_THP, &me->mm->flags); 2643 mmap_write_unlock(me->mm); 2644 break; 2645 case PR_MPX_ENABLE_MANAGEMENT: 2646 case PR_MPX_DISABLE_MANAGEMENT: 2647 /* No longer implemented: */ 2648 return -EINVAL; 2649 case PR_SET_FP_MODE: 2650 error = SET_FP_MODE(me, arg2); 2651 break; 2652 case PR_GET_FP_MODE: 2653 error = GET_FP_MODE(me); 2654 break; 2655 case PR_SVE_SET_VL: 2656 error = SVE_SET_VL(arg2); 2657 break; 2658 case PR_SVE_GET_VL: 2659 error = SVE_GET_VL(); 2660 break; 2661 case PR_SME_SET_VL: 2662 error = SME_SET_VL(arg2); 2663 break; 2664 case PR_SME_GET_VL: 2665 error = SME_GET_VL(); 2666 break; 2667 case PR_GET_SPECULATION_CTRL: 2668 if (arg3 || arg4 || arg5) 2669 return -EINVAL; 2670 error = arch_prctl_spec_ctrl_get(me, arg2); 2671 break; 2672 case PR_SET_SPECULATION_CTRL: 2673 if (arg4 || arg5) 2674 return -EINVAL; 2675 error = arch_prctl_spec_ctrl_set(me, arg2, arg3); 2676 break; 2677 case PR_PAC_RESET_KEYS: 2678 if (arg3 || arg4 || arg5) 2679 return -EINVAL; 2680 error = PAC_RESET_KEYS(me, arg2); 2681 break; 2682 case PR_PAC_SET_ENABLED_KEYS: 2683 if (arg4 || arg5) 2684 return -EINVAL; 2685 error = PAC_SET_ENABLED_KEYS(me, arg2, arg3); 2686 break; 2687 case PR_PAC_GET_ENABLED_KEYS: 2688 if (arg2 || arg3 || arg4 || arg5) 2689 return -EINVAL; 2690 error = PAC_GET_ENABLED_KEYS(me); 2691 break; 2692 case PR_SET_TAGGED_ADDR_CTRL: 2693 if (arg3 || arg4 || arg5) 2694 return -EINVAL; 2695 error = SET_TAGGED_ADDR_CTRL(arg2); 2696 break; 2697 case PR_GET_TAGGED_ADDR_CTRL: 2698 if (arg2 || arg3 || arg4 || arg5) 2699 return -EINVAL; 2700 error = GET_TAGGED_ADDR_CTRL(); 2701 break; 2702 case PR_SET_IO_FLUSHER: 2703 if (!capable(CAP_SYS_RESOURCE)) 2704 return -EPERM; 2705 2706 if (arg3 || arg4 || arg5) 2707 return -EINVAL; 2708 2709 if (arg2 == 1) 2710 current->flags |= PR_IO_FLUSHER; 2711 else if (!arg2) 2712 current->flags &= ~PR_IO_FLUSHER; 2713 else 2714 return -EINVAL; 2715 break; 2716 case PR_GET_IO_FLUSHER: 2717 if (!capable(CAP_SYS_RESOURCE)) 2718 return -EPERM; 2719 2720 if (arg2 || arg3 || arg4 || arg5) 2721 return -EINVAL; 2722 2723 error = (current->flags & PR_IO_FLUSHER) == PR_IO_FLUSHER; 2724 break; 2725 case PR_SET_SYSCALL_USER_DISPATCH: 2726 error = set_syscall_user_dispatch(arg2, arg3, arg4, 2727 (char __user *) arg5); 2728 break; 2729 #ifdef CONFIG_SCHED_CORE 2730 case PR_SCHED_CORE: 2731 error = sched_core_share_pid(arg2, arg3, arg4, arg5); 2732 break; 2733 #endif 2734 case PR_SET_MDWE: 2735 error = prctl_set_mdwe(arg2, arg3, arg4, arg5); 2736 break; 2737 case PR_GET_MDWE: 2738 error = prctl_get_mdwe(arg2, arg3, arg4, arg5); 2739 break; 2740 case PR_PPC_GET_DEXCR: 2741 if (arg3 || arg4 || arg5) 2742 return -EINVAL; 2743 error = PPC_GET_DEXCR_ASPECT(me, arg2); 2744 break; 2745 case PR_PPC_SET_DEXCR: 2746 if (arg4 || arg5) 2747 return -EINVAL; 2748 error = PPC_SET_DEXCR_ASPECT(me, arg2, arg3); 2749 break; 2750 case PR_SET_VMA: 2751 error = prctl_set_vma(arg2, arg3, arg4, arg5); 2752 break; 2753 case PR_GET_AUXV: 2754 if (arg4 || arg5) 2755 return -EINVAL; 2756 error = prctl_get_auxv((void __user *)arg2, arg3); 2757 break; 2758 #ifdef CONFIG_KSM 2759 case PR_SET_MEMORY_MERGE: 2760 if (arg3 || arg4 || arg5) 2761 return -EINVAL; 2762 if (mmap_write_lock_killable(me->mm)) 2763 return -EINTR; 2764 2765 if (arg2) 2766 error = ksm_enable_merge_any(me->mm); 2767 else 2768 error = ksm_disable_merge_any(me->mm); 2769 mmap_write_unlock(me->mm); 2770 break; 2771 case PR_GET_MEMORY_MERGE: 2772 if (arg2 || arg3 || arg4 || arg5) 2773 return -EINVAL; 2774 2775 error = !!test_bit(MMF_VM_MERGE_ANY, &me->mm->flags); 2776 break; 2777 #endif 2778 case PR_RISCV_V_SET_CONTROL: 2779 error = RISCV_V_SET_CONTROL(arg2); 2780 break; 2781 case PR_RISCV_V_GET_CONTROL: 2782 error = RISCV_V_GET_CONTROL(); 2783 break; 2784 case PR_RISCV_SET_ICACHE_FLUSH_CTX: 2785 error = RISCV_SET_ICACHE_FLUSH_CTX(arg2, arg3); 2786 break; 2787 default: 2788 error = -EINVAL; 2789 break; 2790 } 2791 return error; 2792 } 2793 2794 SYSCALL_DEFINE3(getcpu, unsigned __user *, cpup, unsigned __user *, nodep, 2795 struct getcpu_cache __user *, unused) 2796 { 2797 int err = 0; 2798 int cpu = raw_smp_processor_id(); 2799 2800 if (cpup) 2801 err |= put_user(cpu, cpup); 2802 if (nodep) 2803 err |= put_user(cpu_to_node(cpu), nodep); 2804 return err ? -EFAULT : 0; 2805 } 2806 2807 /** 2808 * do_sysinfo - fill in sysinfo struct 2809 * @info: pointer to buffer to fill 2810 */ 2811 static int do_sysinfo(struct sysinfo *info) 2812 { 2813 unsigned long mem_total, sav_total; 2814 unsigned int mem_unit, bitcount; 2815 struct timespec64 tp; 2816 2817 memset(info, 0, sizeof(struct sysinfo)); 2818 2819 ktime_get_boottime_ts64(&tp); 2820 timens_add_boottime(&tp); 2821 info->uptime = tp.tv_sec + (tp.tv_nsec ? 1 : 0); 2822 2823 get_avenrun(info->loads, 0, SI_LOAD_SHIFT - FSHIFT); 2824 2825 info->procs = nr_threads; 2826 2827 si_meminfo(info); 2828 si_swapinfo(info); 2829 2830 /* 2831 * If the sum of all the available memory (i.e. ram + swap) 2832 * is less than can be stored in a 32 bit unsigned long then 2833 * we can be binary compatible with 2.2.x kernels. If not, 2834 * well, in that case 2.2.x was broken anyways... 2835 * 2836 * -Erik Andersen <andersee@debian.org> 2837 */ 2838 2839 mem_total = info->totalram + info->totalswap; 2840 if (mem_total < info->totalram || mem_total < info->totalswap) 2841 goto out; 2842 bitcount = 0; 2843 mem_unit = info->mem_unit; 2844 while (mem_unit > 1) { 2845 bitcount++; 2846 mem_unit >>= 1; 2847 sav_total = mem_total; 2848 mem_total <<= 1; 2849 if (mem_total < sav_total) 2850 goto out; 2851 } 2852 2853 /* 2854 * If mem_total did not overflow, multiply all memory values by 2855 * info->mem_unit and set it to 1. This leaves things compatible 2856 * with 2.2.x, and also retains compatibility with earlier 2.4.x 2857 * kernels... 2858 */ 2859 2860 info->mem_unit = 1; 2861 info->totalram <<= bitcount; 2862 info->freeram <<= bitcount; 2863 info->sharedram <<= bitcount; 2864 info->bufferram <<= bitcount; 2865 info->totalswap <<= bitcount; 2866 info->freeswap <<= bitcount; 2867 info->totalhigh <<= bitcount; 2868 info->freehigh <<= bitcount; 2869 2870 out: 2871 return 0; 2872 } 2873 2874 SYSCALL_DEFINE1(sysinfo, struct sysinfo __user *, info) 2875 { 2876 struct sysinfo val; 2877 2878 do_sysinfo(&val); 2879 2880 if (copy_to_user(info, &val, sizeof(struct sysinfo))) 2881 return -EFAULT; 2882 2883 return 0; 2884 } 2885 2886 #ifdef CONFIG_COMPAT 2887 struct compat_sysinfo { 2888 s32 uptime; 2889 u32 loads[3]; 2890 u32 totalram; 2891 u32 freeram; 2892 u32 sharedram; 2893 u32 bufferram; 2894 u32 totalswap; 2895 u32 freeswap; 2896 u16 procs; 2897 u16 pad; 2898 u32 totalhigh; 2899 u32 freehigh; 2900 u32 mem_unit; 2901 char _f[20-2*sizeof(u32)-sizeof(int)]; 2902 }; 2903 2904 COMPAT_SYSCALL_DEFINE1(sysinfo, struct compat_sysinfo __user *, info) 2905 { 2906 struct sysinfo s; 2907 struct compat_sysinfo s_32; 2908 2909 do_sysinfo(&s); 2910 2911 /* Check to see if any memory value is too large for 32-bit and scale 2912 * down if needed 2913 */ 2914 if (upper_32_bits(s.totalram) || upper_32_bits(s.totalswap)) { 2915 int bitcount = 0; 2916 2917 while (s.mem_unit < PAGE_SIZE) { 2918 s.mem_unit <<= 1; 2919 bitcount++; 2920 } 2921 2922 s.totalram >>= bitcount; 2923 s.freeram >>= bitcount; 2924 s.sharedram >>= bitcount; 2925 s.bufferram >>= bitcount; 2926 s.totalswap >>= bitcount; 2927 s.freeswap >>= bitcount; 2928 s.totalhigh >>= bitcount; 2929 s.freehigh >>= bitcount; 2930 } 2931 2932 memset(&s_32, 0, sizeof(s_32)); 2933 s_32.uptime = s.uptime; 2934 s_32.loads[0] = s.loads[0]; 2935 s_32.loads[1] = s.loads[1]; 2936 s_32.loads[2] = s.loads[2]; 2937 s_32.totalram = s.totalram; 2938 s_32.freeram = s.freeram; 2939 s_32.sharedram = s.sharedram; 2940 s_32.bufferram = s.bufferram; 2941 s_32.totalswap = s.totalswap; 2942 s_32.freeswap = s.freeswap; 2943 s_32.procs = s.procs; 2944 s_32.totalhigh = s.totalhigh; 2945 s_32.freehigh = s.freehigh; 2946 s_32.mem_unit = s.mem_unit; 2947 if (copy_to_user(info, &s_32, sizeof(s_32))) 2948 return -EFAULT; 2949 return 0; 2950 } 2951 #endif /* CONFIG_COMPAT */ 2952