kernel/sched/syscalls.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  *  kernel/sched/syscalls.c
   4  *
   5  *  Core kernel scheduler syscalls related code
   6  *
   7  *  Copyright (C) 1991-2002  Linus Torvalds
   8  *  Copyright (C) 1998-2024  Ingo Molnar, Red Hat
   9  */
  10 #include <linux/sched.h>
  11 #include <linux/cpuset.h>
  12 #include <linux/sched/debug.h>
  13
  14 #include <uapi/linux/sched/types.h>
  15
  16 #include "sched.h"
  17 #include "autogroup.h"
  18
  19 static inline int __normal_prio(int policy, int rt_prio, int nice)
  20 {
  21         int prio;
  22
  23         if (dl_policy(policy))
  24                 prio = MAX_DL_PRIO - 1;
  25         else if (rt_policy(policy))
  26                 prio = MAX_RT_PRIO - 1 - rt_prio;
  27         else
  28                 prio = NICE_TO_PRIO(nice);
  29
  30         return prio;
  31 }
  32
  33 /*
  34  * Calculate the expected normal priority: i.e. priority
  35  * without taking RT-inheritance into account. Might be
  36  * boosted by interactivity modifiers. Changes upon fork,
  37  * setprio syscalls, and whenever the interactivity
  38  * estimator recalculates.
  39  */
  40 static inline int normal_prio(struct task_struct *p)
  41 {
  42         return __normal_prio(p->policy, p->rt_priority, PRIO_TO_NICE(p->static_prio));
  43 }
  44
  45 /*
  46  * Calculate the current priority, i.e. the priority
  47  * taken into account by the scheduler. This value might
  48  * be boosted by RT tasks, or might be boosted by
  49  * interactivity modifiers. Will be RT if the task got
  50  * RT-boosted. If not then it returns p->normal_prio.
  51  */
  52 static int effective_prio(struct task_struct *p)
  53 {
  54         p->normal_prio = normal_prio(p);
  55         /*
  56          * If we are RT tasks or we were boosted to RT priority,
  57          * keep the priority unchanged. Otherwise, update priority
  58          * to the normal priority:
  59          */
  60         if (!rt_or_dl_prio(p->prio))
  61                 return p->normal_prio;
  62         return p->prio;
  63 }
  64
  65 void set_user_nice(struct task_struct *p, long nice)
  66 {
  67         bool queued, running;
  68         struct rq *rq;
  69         int old_prio;
  70
  71         if (task_nice(p) == nice || nice < MIN_NICE || nice > MAX_NICE)
  72                 return;
  73         /*
  74          * We have to be careful, if called from sys_setpriority(),
  75          * the task might be in the middle of scheduling on another CPU.
  76          */
  77         CLASS(task_rq_lock, rq_guard)(p);
  78         rq = rq_guard.rq;
  79
  80         update_rq_clock(rq);
  81
  82         /*
  83          * The RT priorities are set via sched_setscheduler(), but we still
  84          * allow the 'normal' nice value to be set - but as expected
  85          * it won't have any effect on scheduling until the task is
  86          * SCHED_DEADLINE, SCHED_FIFO or SCHED_RR:
  87          */
  88         if (task_has_dl_policy(p) || task_has_rt_policy(p)) {
  89                 p->static_prio = NICE_TO_PRIO(nice);
  90                 return;
  91         }
  92
  93         queued = task_on_rq_queued(p);
  94         running = task_current_donor(rq, p);
  95         if (queued)
  96                 dequeue_task(rq, p, DEQUEUE_SAVE | DEQUEUE_NOCLOCK);
  97         if (running)
  98                 put_prev_task(rq, p);
  99
 100         p->static_prio = NICE_TO_PRIO(nice);
 101         set_load_weight(p, true);
 102         old_prio = p->prio;
 103         p->prio = effective_prio(p);
 104
 105         if (queued)
 106                 enqueue_task(rq, p, ENQUEUE_RESTORE | ENQUEUE_NOCLOCK);
 107         if (running)
 108                 set_next_task(rq, p);
 109
 110         /*
 111          * If the task increased its priority or is running and
 112          * lowered its priority, then reschedule its CPU:
 113          */
 114         p->sched_class->prio_changed(rq, p, old_prio);
 115 }
 116 EXPORT_SYMBOL(set_user_nice);
 117
 118 /*
 119  * is_nice_reduction - check if nice value is an actual reduction
 120  *
 121  * Similar to can_nice() but does not perform a capability check.
 122  *
 123  * @p: task
 124  * @nice: nice value
 125  */
 126 static bool is_nice_reduction(const struct task_struct *p, const int nice)
 127 {
 128         /* Convert nice value [19,-20] to rlimit style value [1,40]: */
 129         int nice_rlim = nice_to_rlimit(nice);
 130
 131         return (nice_rlim <= task_rlimit(p, RLIMIT_NICE));
 132 }
 133
 134 /*
 135  * can_nice - check if a task can reduce its nice value
 136  * @p: task
 137  * @nice: nice value
 138  */
 139 int can_nice(const struct task_struct *p, const int nice)
 140 {
 141         return is_nice_reduction(p, nice) || capable(CAP_SYS_NICE);
 142 }
 143
 144 #ifdef __ARCH_WANT_SYS_NICE
 145
 146 /*
 147  * sys_nice - change the priority of the current process.
 148  * @increment: priority increment
 149  *
 150  * sys_setpriority is a more generic, but much slower function that
 151  * does similar things.
 152  */
 153 SYSCALL_DEFINE1(nice, int, increment)
 154 {
 155         long nice, retval;
 156
 157         /*
 158          * Setpriority might change our priority at the same moment.
 159          * We don't have to worry. Conceptually one call occurs first
 160          * and we have a single winner.
 161          */
 162         increment = clamp(increment, -NICE_WIDTH, NICE_WIDTH);
 163         nice = task_nice(current) + increment;
 164
 165         nice = clamp_val(nice, MIN_NICE, MAX_NICE);
 166         if (increment < 0 && !can_nice(current, nice))
 167                 return -EPERM;
 168
 169         retval = security_task_setnice(current, nice);
 170         if (retval)
 171                 return retval;
 172
 173         set_user_nice(current, nice);
 174         return 0;
 175 }
 176
 177 #endif
 178
 179 /**
 180  * task_prio - return the priority value of a given task.
 181  * @p: the task in question.
 182  *
 183  * Return: The priority value as seen by users in /proc.
 184  *
 185  * sched policy         return value   kernel prio    user prio/nice
 186  *
 187  * normal, batch, idle     [0 ... 39]  [100 ... 139]          0/[-20 ... 19]
 188  * fifo, rr             [-2 ... -100]     [98 ... 0]  [1 ... 99]
 189  * deadline                     -101             -1           0
 190  */
 191 int task_prio(const struct task_struct *p)
 192 {
 193         return p->prio - MAX_RT_PRIO;
 194 }
 195
 196 /**
 197  * idle_cpu - is a given CPU idle currently?
 198  * @cpu: the processor in question.
 199  *
 200  * Return: 1 if the CPU is currently idle. 0 otherwise.
 201  */
 202 int idle_cpu(int cpu)
 203 {
 204         struct rq *rq = cpu_rq(cpu);
 205
 206         if (rq->curr != rq->idle)
 207                 return 0;
 208
 209         if (rq->nr_running)
 210                 return 0;
 211
 212 #ifdef CONFIG_SMP
 213         if (rq->ttwu_pending)
 214                 return 0;
 215 #endif
 216
 217         return 1;
 218 }
 219
 220 /**
 221  * available_idle_cpu - is a given CPU idle for enqueuing work.
 222  * @cpu: the CPU in question.
 223  *
 224  * Return: 1 if the CPU is currently idle. 0 otherwise.
 225  */
 226 int available_idle_cpu(int cpu)
 227 {
 228         if (!idle_cpu(cpu))
 229                 return 0;
 230
 231         if (vcpu_is_preempted(cpu))
 232                 return 0;
 233
 234         return 1;
 235 }
 236
 237 /**
 238  * idle_task - return the idle task for a given CPU.
 239  * @cpu: the processor in question.
 240  *
 241  * Return: The idle task for the CPU @cpu.
 242  */
 243 struct task_struct *idle_task(int cpu)
 244 {
 245         return cpu_rq(cpu)->idle;
 246 }
 247
 248 #ifdef CONFIG_SCHED_CORE
 249 int sched_core_idle_cpu(int cpu)
 250 {
 251         struct rq *rq = cpu_rq(cpu);
 252
 253         if (sched_core_enabled(rq) && rq->curr == rq->idle)
 254                 return 1;
 255
 256         return idle_cpu(cpu);
 257 }
 258
 259 #endif
 260
 261 /**
 262  * find_process_by_pid - find a process with a matching PID value.
 263  * @pid: the pid in question.
 264  *
 265  * The task of @pid, if found. %NULL otherwise.
 266  */
 267 static struct task_struct *find_process_by_pid(pid_t pid)
 268 {
 269         return pid ? find_task_by_vpid(pid) : current;
 270 }
 271
 272 static struct task_struct *find_get_task(pid_t pid)
 273 {
 274         struct task_struct *p;
 275         guard(rcu)();
 276
 277         p = find_process_by_pid(pid);
 278         if (likely(p))
 279                 get_task_struct(p);
 280
 281         return p;
 282 }
 283
 284 DEFINE_CLASS(find_get_task, struct task_struct *, if (_T) put_task_struct(_T),
 285              find_get_task(pid), pid_t pid)
 286
 287 /*
 288  * sched_setparam() passes in -1 for its policy, to let the functions
 289  * it calls know not to change it.
 290  */
 291 #define SETPARAM_POLICY -1
 292
 293 static void __setscheduler_params(struct task_struct *p,
 294                 const struct sched_attr *attr)
 295 {
 296         int policy = attr->sched_policy;
 297
 298         if (policy == SETPARAM_POLICY)
 299                 policy = p->policy;
 300
 301         p->policy = policy;
 302
 303         if (dl_policy(policy))
 304                 __setparam_dl(p, attr);
 305         else if (fair_policy(policy))
 306                 __setparam_fair(p, attr);
 307
 308         /* rt-policy tasks do not have a timerslack */
 309         if (rt_or_dl_task_policy(p)) {
 310                 p->timer_slack_ns = 0;
 311         } else if (p->timer_slack_ns == 0) {
 312                 /* when switching back to non-rt policy, restore timerslack */
 313                 p->timer_slack_ns = p->default_timer_slack_ns;
 314         }
 315
 316         /*
 317          * __sched_setscheduler() ensures attr->sched_priority == 0 when
 318          * !rt_policy. Always setting this ensures that things like
 319          * getparam()/getattr() don't report silly values for !rt tasks.
 320          */
 321         p->rt_priority = attr->sched_priority;
 322         p->normal_prio = normal_prio(p);
 323         set_load_weight(p, true);
 324 }
 325
 326 /*
 327  * Check the target process has a UID that matches the current process's:
 328  */
 329 static bool check_same_owner(struct task_struct *p)
 330 {
 331         const struct cred *cred = current_cred(), *pcred;
 332         guard(rcu)();
 333
 334         pcred = __task_cred(p);
 335         return (uid_eq(cred->euid, pcred->euid) ||
 336                 uid_eq(cred->euid, pcred->uid));
 337 }
 338
 339 #ifdef CONFIG_UCLAMP_TASK
 340
 341 static int uclamp_validate(struct task_struct *p,
 342                            const struct sched_attr *attr)
 343 {
 344         int util_min = p->uclamp_req[UCLAMP_MIN].value;
 345         int util_max = p->uclamp_req[UCLAMP_MAX].value;
 346
 347         if (attr->sched_flags & SCHED_FLAG_UTIL_CLAMP_MIN) {
 348                 util_min = attr->sched_util_min;
 349
 350                 if (util_min + 1 > SCHED_CAPACITY_SCALE + 1)
 351                         return -EINVAL;
 352         }
 353
 354         if (attr->sched_flags & SCHED_FLAG_UTIL_CLAMP_MAX) {
 355                 util_max = attr->sched_util_max;
 356
 357                 if (util_max + 1 > SCHED_CAPACITY_SCALE + 1)
 358                         return -EINVAL;
 359         }
 360
 361         if (util_min != -1 && util_max != -1 && util_min > util_max)
 362                 return -EINVAL;
 363
 364         /*
 365          * We have valid uclamp attributes; make sure uclamp is enabled.
 366          *
 367          * We need to do that here, because enabling static branches is a
 368          * blocking operation which obviously cannot be done while holding
 369          * scheduler locks.
 370          */
 371         static_branch_enable(&sched_uclamp_used);
 372
 373         return 0;
 374 }
 375
 376 static bool uclamp_reset(const struct sched_attr *attr,
 377                          enum uclamp_id clamp_id,
 378                          struct uclamp_se *uc_se)
 379 {
 380         /* Reset on sched class change for a non user-defined clamp value. */
 381         if (likely(!(attr->sched_flags & SCHED_FLAG_UTIL_CLAMP)) &&
 382             !uc_se->user_defined)
 383                 return true;
 384
 385         /* Reset on sched_util_{min,max} == -1. */
 386         if (clamp_id == UCLAMP_MIN &&
 387             attr->sched_flags & SCHED_FLAG_UTIL_CLAMP_MIN &&
 388             attr->sched_util_min == -1) {
 389                 return true;
 390         }
 391
 392         if (clamp_id == UCLAMP_MAX &&
 393             attr->sched_flags & SCHED_FLAG_UTIL_CLAMP_MAX &&
 394             attr->sched_util_max == -1) {
 395                 return true;
 396         }
 397
 398         return false;
 399 }
 400
 401 static void __setscheduler_uclamp(struct task_struct *p,
 402                                   const struct sched_attr *attr)
 403 {
 404         enum uclamp_id clamp_id;
 405
 406         for_each_clamp_id(clamp_id) {
 407                 struct uclamp_se *uc_se = &p->uclamp_req[clamp_id];
 408                 unsigned int value;
 409
 410                 if (!uclamp_reset(attr, clamp_id, uc_se))
 411                         continue;
 412
 413                 /*
 414                  * RT by default have a 100% boost value that could be modified
 415                  * at runtime.
 416                  */
 417                 if (unlikely(rt_task(p) && clamp_id == UCLAMP_MIN))
 418                         value = sysctl_sched_uclamp_util_min_rt_default;
 419                 else
 420                         value = uclamp_none(clamp_id);
 421
 422                 uclamp_se_set(uc_se, value, false);
 423
 424         }
 425
 426         if (likely(!(attr->sched_flags & SCHED_FLAG_UTIL_CLAMP)))
 427                 return;
 428
 429         if (attr->sched_flags & SCHED_FLAG_UTIL_CLAMP_MIN &&
 430             attr->sched_util_min != -1) {
 431                 uclamp_se_set(&p->uclamp_req[UCLAMP_MIN],
 432                               attr->sched_util_min, true);
 433         }
 434
 435         if (attr->sched_flags & SCHED_FLAG_UTIL_CLAMP_MAX &&
 436             attr->sched_util_max != -1) {
 437                 uclamp_se_set(&p->uclamp_req[UCLAMP_MAX],
 438                               attr->sched_util_max, true);
 439         }
 440 }
 441
 442 #else /* !CONFIG_UCLAMP_TASK: */
 443
 444 static inline int uclamp_validate(struct task_struct *p,
 445                                   const struct sched_attr *attr)
 446 {
 447         return -EOPNOTSUPP;
 448 }
 449 static void __setscheduler_uclamp(struct task_struct *p,
 450                                   const struct sched_attr *attr) { }
 451 #endif
 452
 453 /*
 454  * Allow unprivileged RT tasks to decrease priority.
 455  * Only issue a capable test if needed and only once to avoid an audit
 456  * event on permitted non-privileged operations:
 457  */
 458 static int user_check_sched_setscheduler(struct task_struct *p,
 459                                          const struct sched_attr *attr,
 460                                          int policy, int reset_on_fork)
 461 {
 462         if (fair_policy(policy)) {
 463                 if (attr->sched_nice < task_nice(p) &&
 464                     !is_nice_reduction(p, attr->sched_nice))
 465                         goto req_priv;
 466         }
 467
 468         if (rt_policy(policy)) {
 469                 unsigned long rlim_rtprio = task_rlimit(p, RLIMIT_RTPRIO);
 470
 471                 /* Can't set/change the rt policy: */
 472                 if (policy != p->policy && !rlim_rtprio)
 473                         goto req_priv;
 474
 475                 /* Can't increase priority: */
 476                 if (attr->sched_priority > p->rt_priority &&
 477                     attr->sched_priority > rlim_rtprio)
 478                         goto req_priv;
 479         }
 480
 481         /*
 482          * Can't set/change SCHED_DEADLINE policy at all for now
 483          * (safest behavior); in the future we would like to allow
 484          * unprivileged DL tasks to increase their relative deadline
 485          * or reduce their runtime (both ways reducing utilization)
 486          */
 487         if (dl_policy(policy))
 488                 goto req_priv;
 489
 490         /*
 491          * Treat SCHED_IDLE as nice 20. Only allow a switch to
 492          * SCHED_NORMAL if the RLIMIT_NICE would normally permit it.
 493          */
 494         if (task_has_idle_policy(p) && !idle_policy(policy)) {
 495                 if (!is_nice_reduction(p, task_nice(p)))
 496                         goto req_priv;
 497         }
 498
 499         /* Can't change other user's priorities: */
 500         if (!check_same_owner(p))
 501                 goto req_priv;
 502
 503         /* Normal users shall not reset the sched_reset_on_fork flag: */
 504         if (p->sched_reset_on_fork && !reset_on_fork)
 505                 goto req_priv;
 506
 507         return 0;
 508
 509 req_priv:
 510         if (!capable(CAP_SYS_NICE))
 511                 return -EPERM;
 512
 513         return 0;
 514 }
 515
 516 int __sched_setscheduler(struct task_struct *p,
 517                          const struct sched_attr *attr,
 518                          bool user, bool pi)
 519 {
 520         int oldpolicy = -1, policy = attr->sched_policy;
 521         int retval, oldprio, newprio, queued, running;
 522         const struct sched_class *prev_class, *next_class;
 523         struct balance_callback *head;
 524         struct rq_flags rf;
 525         int reset_on_fork;
 526         int queue_flags = DEQUEUE_SAVE | DEQUEUE_MOVE | DEQUEUE_NOCLOCK;
 527         struct rq *rq;
 528         bool cpuset_locked = false;
 529
 530         /* The pi code expects interrupts enabled */
 531         BUG_ON(pi && in_interrupt());
 532 recheck:
 533         /* Double check policy once rq lock held: */
 534         if (policy < 0) {
 535                 reset_on_fork = p->sched_reset_on_fork;
 536                 policy = oldpolicy = p->policy;
 537         } else {
 538                 reset_on_fork = !!(attr->sched_flags & SCHED_FLAG_RESET_ON_FORK);
 539
 540                 if (!valid_policy(policy))
 541                         return -EINVAL;
 542         }
 543
 544         if (attr->sched_flags & ~(SCHED_FLAG_ALL | SCHED_FLAG_SUGOV))
 545                 return -EINVAL;
 546
 547         /*
 548          * Valid priorities for SCHED_FIFO and SCHED_RR are
 549          * 1..MAX_RT_PRIO-1, valid priority for SCHED_NORMAL,
 550          * SCHED_BATCH and SCHED_IDLE is 0.
 551          */
 552         if (attr->sched_priority > MAX_RT_PRIO-1)
 553                 return -EINVAL;
 554         if ((dl_policy(policy) && !__checkparam_dl(attr)) ||
 555             (rt_policy(policy) != (attr->sched_priority != 0)))
 556                 return -EINVAL;
 557
 558         if (user) {
 559                 retval = user_check_sched_setscheduler(p, attr, policy, reset_on_fork);
 560                 if (retval)
 561                         return retval;
 562
 563                 if (attr->sched_flags & SCHED_FLAG_SUGOV)
 564                         return -EINVAL;
 565
 566                 retval = security_task_setscheduler(p);
 567                 if (retval)
 568                         return retval;
 569         }
 570
 571         /* Update task specific "requested" clamps */
 572         if (attr->sched_flags & SCHED_FLAG_UTIL_CLAMP) {
 573                 retval = uclamp_validate(p, attr);
 574                 if (retval)
 575                         return retval;
 576         }
 577
 578         /*
 579          * SCHED_DEADLINE bandwidth accounting relies on stable cpusets
 580          * information.
 581          */
 582         if (dl_policy(policy) || dl_policy(p->policy)) {
 583                 cpuset_locked = true;
 584                 cpuset_lock();
 585         }
 586
 587         /*
 588          * Make sure no PI-waiters arrive (or leave) while we are
 589          * changing the priority of the task:
 590          *
 591          * To be able to change p->policy safely, the appropriate
 592          * runqueue lock must be held.
 593          */
 594         rq = task_rq_lock(p, &rf);
 595         update_rq_clock(rq);
 596
 597         /*
 598          * Changing the policy of the stop threads its a very bad idea:
 599          */
 600         if (p == rq->stop) {
 601                 retval = -EINVAL;
 602                 goto unlock;
 603         }
 604
 605         retval = scx_check_setscheduler(p, policy);
 606         if (retval)
 607                 goto unlock;
 608
 609         /*
 610          * If not changing anything there's no need to proceed further,
 611          * but store a possible modification of reset_on_fork.
 612          */
 613         if (unlikely(policy == p->policy)) {
 614                 if (fair_policy(policy) &&
 615                     (attr->sched_nice != task_nice(p) ||
 616                      (attr->sched_runtime != p->se.slice)))
 617                         goto change;
 618                 if (rt_policy(policy) && attr->sched_priority != p->rt_priority)
 619                         goto change;
 620                 if (dl_policy(policy) && dl_param_changed(p, attr))
 621                         goto change;
 622                 if (attr->sched_flags & SCHED_FLAG_UTIL_CLAMP)
 623                         goto change;
 624
 625                 p->sched_reset_on_fork = reset_on_fork;
 626                 retval = 0;
 627                 goto unlock;
 628         }
 629 change:
 630
 631         if (user) {
 632 #ifdef CONFIG_RT_GROUP_SCHED
 633                 /*
 634                  * Do not allow real-time tasks into groups that have no runtime
 635                  * assigned.
 636                  */
 637                 if (rt_bandwidth_enabled() && rt_policy(policy) &&
 638                                 task_group(p)->rt_bandwidth.rt_runtime == 0 &&
 639                                 !task_group_is_autogroup(task_group(p))) {
 640                         retval = -EPERM;
 641                         goto unlock;
 642                 }
 643 #endif
 644 #ifdef CONFIG_SMP
 645                 if (dl_bandwidth_enabled() && dl_policy(policy) &&
 646                                 !(attr->sched_flags & SCHED_FLAG_SUGOV)) {
 647                         cpumask_t *span = rq->rd->span;
 648
 649                         /*
 650                          * Don't allow tasks with an affinity mask smaller than
 651                          * the entire root_domain to become SCHED_DEADLINE. We
 652                          * will also fail if there's no bandwidth available.
 653                          */
 654                         if (!cpumask_subset(span, p->cpus_ptr) ||
 655                             rq->rd->dl_bw.bw == 0) {
 656                                 retval = -EPERM;
 657                                 goto unlock;
 658                         }
 659                 }
 660 #endif
 661         }
 662
 663         /* Re-check policy now with rq lock held: */
 664         if (unlikely(oldpolicy != -1 && oldpolicy != p->policy)) {
 665                 policy = oldpolicy = -1;
 666                 task_rq_unlock(rq, p, &rf);
 667                 if (cpuset_locked)
 668                         cpuset_unlock();
 669                 goto recheck;
 670         }
 671
 672         /*
 673          * If setscheduling to SCHED_DEADLINE (or changing the parameters
 674          * of a SCHED_DEADLINE task) we need to check if enough bandwidth
 675          * is available.
 676          */
 677         if ((dl_policy(policy) || dl_task(p)) && sched_dl_overflow(p, policy, attr)) {
 678                 retval = -EBUSY;
 679                 goto unlock;
 680         }
 681
 682         p->sched_reset_on_fork = reset_on_fork;
 683         oldprio = p->prio;
 684
 685         newprio = __normal_prio(policy, attr->sched_priority, attr->sched_nice);
 686         if (pi) {
 687                 /*
 688                  * Take priority boosted tasks into account. If the new
 689                  * effective priority is unchanged, we just store the new
 690                  * normal parameters and do not touch the scheduler class and
 691                  * the runqueue. This will be done when the task deboost
 692                  * itself.
 693                  */
 694                 newprio = rt_effective_prio(p, newprio);
 695                 if (newprio == oldprio)
 696                         queue_flags &= ~DEQUEUE_MOVE;
 697         }
 698
 699         prev_class = p->sched_class;
 700         next_class = __setscheduler_class(policy, newprio);
 701
 702         if (prev_class != next_class && p->se.sched_delayed)
 703                 dequeue_task(rq, p, DEQUEUE_SLEEP | DEQUEUE_DELAYED | DEQUEUE_NOCLOCK);
 704
 705         queued = task_on_rq_queued(p);
 706         running = task_current_donor(rq, p);
 707         if (queued)
 708                 dequeue_task(rq, p, queue_flags);
 709         if (running)
 710                 put_prev_task(rq, p);
 711
 712         if (!(attr->sched_flags & SCHED_FLAG_KEEP_PARAMS)) {
 713                 __setscheduler_params(p, attr);
 714                 p->sched_class = next_class;
 715                 p->prio = newprio;
 716         }
 717         __setscheduler_uclamp(p, attr);
 718         check_class_changing(rq, p, prev_class);
 719
 720         if (queued) {
 721                 /*
 722                  * We enqueue to tail when the priority of a task is
 723                  * increased (user space view).
 724                  */
 725                 if (oldprio < p->prio)
 726                         queue_flags |= ENQUEUE_HEAD;
 727
 728                 enqueue_task(rq, p, queue_flags);
 729         }
 730         if (running)
 731                 set_next_task(rq, p);
 732
 733         check_class_changed(rq, p, prev_class, oldprio);
 734
 735         /* Avoid rq from going away on us: */
 736         preempt_disable();
 737         head = splice_balance_callbacks(rq);
 738         task_rq_unlock(rq, p, &rf);
 739
 740         if (pi) {
 741                 if (cpuset_locked)
 742                         cpuset_unlock();
 743                 rt_mutex_adjust_pi(p);
 744         }
 745
 746         /* Run balance callbacks after we've adjusted the PI chain: */
 747         balance_callbacks(rq, head);
 748         preempt_enable();
 749
 750         return 0;
 751
 752 unlock:
 753         task_rq_unlock(rq, p, &rf);
 754         if (cpuset_locked)
 755                 cpuset_unlock();
 756         return retval;
 757 }
 758
 759 static int _sched_setscheduler(struct task_struct *p, int policy,
 760                                const struct sched_param *param, bool check)
 761 {
 762         struct sched_attr attr = {
 763                 .sched_policy   = policy,
 764                 .sched_priority = param->sched_priority,
 765                 .sched_nice     = PRIO_TO_NICE(p->static_prio),
 766         };
 767
 768         if (p->se.custom_slice)
 769                 attr.sched_runtime = p->se.slice;
 770
 771         /* Fixup the legacy SCHED_RESET_ON_FORK hack. */
 772         if ((policy != SETPARAM_POLICY) && (policy & SCHED_RESET_ON_FORK)) {
 773                 attr.sched_flags |= SCHED_FLAG_RESET_ON_FORK;
 774                 policy &= ~SCHED_RESET_ON_FORK;
 775                 attr.sched_policy = policy;
 776         }
 777
 778         return __sched_setscheduler(p, &attr, check, true);
 779 }
 780 /**
 781  * sched_setscheduler - change the scheduling policy and/or RT priority of a thread.
 782  * @p: the task in question.
 783  * @policy: new policy.
 784  * @param: structure containing the new RT priority.
 785  *
 786  * Use sched_set_fifo(), read its comment.
 787  *
 788  * Return: 0 on success. An error code otherwise.
 789  *
 790  * NOTE that the task may be already dead.
 791  */
 792 int sched_setscheduler(struct task_struct *p, int policy,
 793                        const struct sched_param *param)
 794 {
 795         return _sched_setscheduler(p, policy, param, true);
 796 }
 797
 798 int sched_setattr(struct task_struct *p, const struct sched_attr *attr)
 799 {
 800         return __sched_setscheduler(p, attr, true, true);
 801 }
 802
 803 int sched_setattr_nocheck(struct task_struct *p, const struct sched_attr *attr)
 804 {
 805         return __sched_setscheduler(p, attr, false, true);
 806 }
 807 EXPORT_SYMBOL_GPL(sched_setattr_nocheck);
 808
 809 /**
 810  * sched_setscheduler_nocheck - change the scheduling policy and/or RT priority of a thread from kernel-space.
 811  * @p: the task in question.
 812  * @policy: new policy.
 813  * @param: structure containing the new RT priority.
 814  *
 815  * Just like sched_setscheduler, only don't bother checking if the
 816  * current context has permission.  For example, this is needed in
 817  * stop_machine(): we create temporary high priority worker threads,
 818  * but our caller might not have that capability.
 819  *
 820  * Return: 0 on success. An error code otherwise.
 821  */
 822 int sched_setscheduler_nocheck(struct task_struct *p, int policy,
 823                                const struct sched_param *param)
 824 {
 825         return _sched_setscheduler(p, policy, param, false);
 826 }
 827
 828 /*
 829  * SCHED_FIFO is a broken scheduler model; that is, it is fundamentally
 830  * incapable of resource management, which is the one thing an OS really should
 831  * be doing.
 832  *
 833  * This is of course the reason it is limited to privileged users only.
 834  *
 835  * Worse still; it is fundamentally impossible to compose static priority
 836  * workloads. You cannot take two correctly working static prio workloads
 837  * and smash them together and still expect them to work.
 838  *
 839  * For this reason 'all' FIFO tasks the kernel creates are basically at:
 840  *
 841  *   MAX_RT_PRIO / 2
 842  *
 843  * The administrator _MUST_ configure the system, the kernel simply doesn't
 844  * know enough information to make a sensible choice.
 845  */
 846 void sched_set_fifo(struct task_struct *p)
 847 {
 848         struct sched_param sp = { .sched_priority = MAX_RT_PRIO / 2 };
 849         WARN_ON_ONCE(sched_setscheduler_nocheck(p, SCHED_FIFO, &sp) != 0);
 850 }
 851 EXPORT_SYMBOL_GPL(sched_set_fifo);
 852
 853 /*
 854  * For when you don't much care about FIFO, but want to be above SCHED_NORMAL.
 855  */
 856 void sched_set_fifo_low(struct task_struct *p)
 857 {
 858         struct sched_param sp = { .sched_priority = 1 };
 859         WARN_ON_ONCE(sched_setscheduler_nocheck(p, SCHED_FIFO, &sp) != 0);
 860 }
 861 EXPORT_SYMBOL_GPL(sched_set_fifo_low);
 862
 863 void sched_set_normal(struct task_struct *p, int nice)
 864 {
 865         struct sched_attr attr = {
 866                 .sched_policy = SCHED_NORMAL,
 867                 .sched_nice = nice,
 868         };
 869         WARN_ON_ONCE(sched_setattr_nocheck(p, &attr) != 0);
 870 }
 871 EXPORT_SYMBOL_GPL(sched_set_normal);
 872
 873 static int
 874 do_sched_setscheduler(pid_t pid, int policy, struct sched_param __user *param)
 875 {
 876         struct sched_param lparam;
 877
 878         if (!param || pid < 0)
 879                 return -EINVAL;
 880         if (copy_from_user(&lparam, param, sizeof(struct sched_param)))
 881                 return -EFAULT;
 882
 883         CLASS(find_get_task, p)(pid);
 884         if (!p)
 885                 return -ESRCH;
 886
 887         return sched_setscheduler(p, policy, &lparam);
 888 }
 889
 890 /*
 891  * Mimics kernel/events/core.c perf_copy_attr().
 892  */
 893 static int sched_copy_attr(struct sched_attr __user *uattr, struct sched_attr *attr)
 894 {
 895         u32 size;
 896         int ret;
 897
 898         /* Zero the full structure, so that a short copy will be nice: */
 899         memset(attr, 0, sizeof(*attr));
 900
 901         ret = get_user(size, &uattr->size);
 902         if (ret)
 903                 return ret;
 904
 905         /* ABI compatibility quirk: */
 906         if (!size)
 907                 size = SCHED_ATTR_SIZE_VER0;
 908         if (size < SCHED_ATTR_SIZE_VER0 || size > PAGE_SIZE)
 909                 goto err_size;
 910
 911         ret = copy_struct_from_user(attr, sizeof(*attr), uattr, size);
 912         if (ret) {
 913                 if (ret == -E2BIG)
 914                         goto err_size;
 915                 return ret;
 916         }
 917
 918         if ((attr->sched_flags & SCHED_FLAG_UTIL_CLAMP) &&
 919             size < SCHED_ATTR_SIZE_VER1)
 920                 return -EINVAL;
 921
 922         /*
 923          * XXX: Do we want to be lenient like existing syscalls; or do we want
 924          * to be strict and return an error on out-of-bounds values?
 925          */
 926         attr->sched_nice = clamp(attr->sched_nice, MIN_NICE, MAX_NICE);
 927
 928         return 0;
 929
 930 err_size:
 931         put_user(sizeof(*attr), &uattr->size);
 932         return -E2BIG;
 933 }
 934
 935 static void get_params(struct task_struct *p, struct sched_attr *attr)
 936 {
 937         if (task_has_dl_policy(p)) {
 938                 __getparam_dl(p, attr);
 939         } else if (task_has_rt_policy(p)) {
 940                 attr->sched_priority = p->rt_priority;
 941         } else {
 942                 attr->sched_nice = task_nice(p);
 943                 attr->sched_runtime = p->se.slice;
 944         }
 945 }
 946
 947 /**
 948  * sys_sched_setscheduler - set/change the scheduler policy and RT priority
 949  * @pid: the pid in question.
 950  * @policy: new policy.
 951  * @param: structure containing the new RT priority.
 952  *
 953  * Return: 0 on success. An error code otherwise.
 954  */
 955 SYSCALL_DEFINE3(sched_setscheduler, pid_t, pid, int, policy, struct sched_param __user *, param)
 956 {
 957         if (policy < 0)
 958                 return -EINVAL;
 959
 960         return do_sched_setscheduler(pid, policy, param);
 961 }
 962
 963 /**
 964  * sys_sched_setparam - set/change the RT priority of a thread
 965  * @pid: the pid in question.
 966  * @param: structure containing the new RT priority.
 967  *
 968  * Return: 0 on success. An error code otherwise.
 969  */
 970 SYSCALL_DEFINE2(sched_setparam, pid_t, pid, struct sched_param __user *, param)
 971 {
 972         return do_sched_setscheduler(pid, SETPARAM_POLICY, param);
 973 }
 974
 975 /**
 976  * sys_sched_setattr - same as above, but with extended sched_attr
 977  * @pid: the pid in question.
 978  * @uattr: structure containing the extended parameters.
 979  * @flags: for future extension.
 980  */
 981 SYSCALL_DEFINE3(sched_setattr, pid_t, pid, struct sched_attr __user *, uattr,
 982                                unsigned int, flags)
 983 {
 984         struct sched_attr attr;
 985         int retval;
 986
 987         if (!uattr || pid < 0 || flags)
 988                 return -EINVAL;
 989
 990         retval = sched_copy_attr(uattr, &attr);
 991         if (retval)
 992                 return retval;
 993
 994         if ((int)attr.sched_policy < 0)
 995                 return -EINVAL;
 996         if (attr.sched_flags & SCHED_FLAG_KEEP_POLICY)
 997                 attr.sched_policy = SETPARAM_POLICY;
 998
 999         CLASS(find_get_task, p)(pid);
1000         if (!p)
1001                 return -ESRCH;
1002
1003         if (attr.sched_flags & SCHED_FLAG_KEEP_PARAMS)
1004                 get_params(p, &attr);
1005
1006         return sched_setattr(p, &attr);
1007 }
1008
1009 /**
1010  * sys_sched_getscheduler - get the policy (scheduling class) of a thread
1011  * @pid: the pid in question.
1012  *
1013  * Return: On success, the policy of the thread. Otherwise, a negative error
1014  * code.
1015  */
1016 SYSCALL_DEFINE1(sched_getscheduler, pid_t, pid)
1017 {
1018         struct task_struct *p;
1019         int retval;
1020
1021         if (pid < 0)
1022                 return -EINVAL;
1023
1024         guard(rcu)();
1025         p = find_process_by_pid(pid);
1026         if (!p)
1027                 return -ESRCH;
1028
1029         retval = security_task_getscheduler(p);
1030         if (!retval) {
1031                 retval = p->policy;
1032                 if (p->sched_reset_on_fork)
1033                         retval |= SCHED_RESET_ON_FORK;
1034         }
1035         return retval;
1036 }
1037
1038 /**
1039  * sys_sched_getparam - get the RT priority of a thread
1040  * @pid: the pid in question.
1041  * @param: structure containing the RT priority.
1042  *
1043  * Return: On success, 0 and the RT priority is in @param. Otherwise, an error
1044  * code.
1045  */
1046 SYSCALL_DEFINE2(sched_getparam, pid_t, pid, struct sched_param __user *, param)
1047 {
1048         struct sched_param lp = { .sched_priority = 0 };
1049         struct task_struct *p;
1050         int retval;
1051
1052         if (!param || pid < 0)
1053                 return -EINVAL;
1054
1055         scoped_guard (rcu) {
1056                 p = find_process_by_pid(pid);
1057                 if (!p)
1058                         return -ESRCH;
1059
1060                 retval = security_task_getscheduler(p);
1061                 if (retval)
1062                         return retval;
1063
1064                 if (task_has_rt_policy(p))
1065                         lp.sched_priority = p->rt_priority;
1066         }
1067
1068         /*
1069          * This one might sleep, we cannot do it with a spinlock held ...
1070          */
1071         return copy_to_user(param, &lp, sizeof(*param)) ? -EFAULT : 0;
1072 }
1073
1074 /**
1075  * sys_sched_getattr - similar to sched_getparam, but with sched_attr
1076  * @pid: the pid in question.
1077  * @uattr: structure containing the extended parameters.
1078  * @usize: sizeof(attr) for fwd/bwd comp.
1079  * @flags: for future extension.
1080  */
1081 SYSCALL_DEFINE4(sched_getattr, pid_t, pid, struct sched_attr __user *, uattr,
1082                 unsigned int, usize, unsigned int, flags)
1083 {
1084         struct sched_attr kattr = { };
1085         struct task_struct *p;
1086         int retval;
1087
1088         if (!uattr || pid < 0 || usize > PAGE_SIZE ||
1089             usize < SCHED_ATTR_SIZE_VER0 || flags)
1090                 return -EINVAL;
1091
1092         scoped_guard (rcu) {
1093                 p = find_process_by_pid(pid);
1094                 if (!p)
1095                         return -ESRCH;
1096
1097                 retval = security_task_getscheduler(p);
1098                 if (retval)
1099                         return retval;
1100
1101                 kattr.sched_policy = p->policy;
1102                 if (p->sched_reset_on_fork)
1103                         kattr.sched_flags |= SCHED_FLAG_RESET_ON_FORK;
1104                 get_params(p, &kattr);
1105                 kattr.sched_flags &= SCHED_FLAG_ALL;
1106
1107 #ifdef CONFIG_UCLAMP_TASK
1108                 /*
1109                  * This could race with another potential updater, but this is fine
1110                  * because it'll correctly read the old or the new value. We don't need
1111                  * to guarantee who wins the race as long as it doesn't return garbage.
1112                  */
1113                 kattr.sched_util_min = p->uclamp_req[UCLAMP_MIN].value;
1114                 kattr.sched_util_max = p->uclamp_req[UCLAMP_MAX].value;
1115 #endif
1116         }
1117
1118         kattr.size = min(usize, sizeof(kattr));
1119         return copy_struct_to_user(uattr, usize, &kattr, sizeof(kattr), NULL);
1120 }
1121
1122 #ifdef CONFIG_SMP
1123 int dl_task_check_affinity(struct task_struct *p, const struct cpumask *mask)
1124 {
1125         /*
1126          * If the task isn't a deadline task or admission control is
1127          * disabled then we don't care about affinity changes.
1128          */
1129         if (!task_has_dl_policy(p) || !dl_bandwidth_enabled())
1130                 return 0;
1131
1132         /*
1133          * The special/sugov task isn't part of regular bandwidth/admission
1134          * control so let userspace change affinities.
1135          */
1136         if (dl_entity_is_special(&p->dl))
1137                 return 0;
1138
1139         /*
1140          * Since bandwidth control happens on root_domain basis,
1141          * if admission test is enabled, we only admit -deadline
1142          * tasks allowed to run on all the CPUs in the task's
1143          * root_domain.
1144          */
1145         guard(rcu)();
1146         if (!cpumask_subset(task_rq(p)->rd->span, mask))
1147                 return -EBUSY;
1148
1149         return 0;
1150 }
1151 #endif /* CONFIG_SMP */
1152
1153 int __sched_setaffinity(struct task_struct *p, struct affinity_context *ctx)
1154 {
1155         int retval;
1156         cpumask_var_t cpus_allowed, new_mask;
1157
1158         if (!alloc_cpumask_var(&cpus_allowed, GFP_KERNEL))
1159                 return -ENOMEM;
1160
1161         if (!alloc_cpumask_var(&new_mask, GFP_KERNEL)) {
1162                 retval = -ENOMEM;
1163                 goto out_free_cpus_allowed;
1164         }
1165
1166         cpuset_cpus_allowed(p, cpus_allowed);
1167         cpumask_and(new_mask, ctx->new_mask, cpus_allowed);
1168
1169         ctx->new_mask = new_mask;
1170         ctx->flags |= SCA_CHECK;
1171
1172         retval = dl_task_check_affinity(p, new_mask);
1173         if (retval)
1174                 goto out_free_new_mask;
1175
1176         retval = __set_cpus_allowed_ptr(p, ctx);
1177         if (retval)
1178                 goto out_free_new_mask;
1179
1180         cpuset_cpus_allowed(p, cpus_allowed);
1181         if (!cpumask_subset(new_mask, cpus_allowed)) {
1182                 /*
1183                  * We must have raced with a concurrent cpuset update.
1184                  * Just reset the cpumask to the cpuset's cpus_allowed.
1185                  */
1186                 cpumask_copy(new_mask, cpus_allowed);
1187
1188                 /*
1189                  * If SCA_USER is set, a 2nd call to __set_cpus_allowed_ptr()
1190                  * will restore the previous user_cpus_ptr value.
1191                  *
1192                  * In the unlikely event a previous user_cpus_ptr exists,
1193                  * we need to further restrict the mask to what is allowed
1194                  * by that old user_cpus_ptr.
1195                  */
1196                 if (unlikely((ctx->flags & SCA_USER) && ctx->user_mask)) {
1197                         bool empty = !cpumask_and(new_mask, new_mask,
1198                                                   ctx->user_mask);
1199
1200                         if (empty)
1201                                 cpumask_copy(new_mask, cpus_allowed);
1202                 }
1203                 __set_cpus_allowed_ptr(p, ctx);
1204                 retval = -EINVAL;
1205         }
1206
1207 out_free_new_mask:
1208         free_cpumask_var(new_mask);
1209 out_free_cpus_allowed:
1210         free_cpumask_var(cpus_allowed);
1211         return retval;
1212 }
1213
1214 long sched_setaffinity(pid_t pid, const struct cpumask *in_mask)
1215 {
1216         struct affinity_context ac;
1217         struct cpumask *user_mask;
1218         int retval;
1219
1220         CLASS(find_get_task, p)(pid);
1221         if (!p)
1222                 return -ESRCH;
1223
1224         if (p->flags & PF_NO_SETAFFINITY)
1225                 return -EINVAL;
1226
1227         if (!check_same_owner(p)) {
1228                 guard(rcu)();
1229                 if (!ns_capable(__task_cred(p)->user_ns, CAP_SYS_NICE))
1230                         return -EPERM;
1231         }
1232
1233         retval = security_task_setscheduler(p);
1234         if (retval)
1235                 return retval;
1236
1237         /*
1238          * With non-SMP configs, user_cpus_ptr/user_mask isn't used and
1239          * alloc_user_cpus_ptr() returns NULL.
1240          */
1241         user_mask = alloc_user_cpus_ptr(NUMA_NO_NODE);
1242         if (user_mask) {
1243                 cpumask_copy(user_mask, in_mask);
1244         } else if (IS_ENABLED(CONFIG_SMP)) {
1245                 return -ENOMEM;
1246         }
1247
1248         ac = (struct affinity_context){
1249                 .new_mask  = in_mask,
1250                 .user_mask = user_mask,
1251                 .flags     = SCA_USER,
1252         };
1253
1254         retval = __sched_setaffinity(p, &ac);
1255         kfree(ac.user_mask);
1256
1257         return retval;
1258 }
1259
1260 static int get_user_cpu_mask(unsigned long __user *user_mask_ptr, unsigned len,
1261                              struct cpumask *new_mask)
1262 {
1263         if (len < cpumask_size())
1264                 cpumask_clear(new_mask);
1265         else if (len > cpumask_size())
1266                 len = cpumask_size();
1267
1268         return copy_from_user(new_mask, user_mask_ptr, len) ? -EFAULT : 0;
1269 }
1270
1271 /**
1272  * sys_sched_setaffinity - set the CPU affinity of a process
1273  * @pid: pid of the process
1274  * @len: length in bytes of the bitmask pointed to by user_mask_ptr
1275  * @user_mask_ptr: user-space pointer to the new CPU mask
1276  *
1277  * Return: 0 on success. An error code otherwise.
1278  */
1279 SYSCALL_DEFINE3(sched_setaffinity, pid_t, pid, unsigned int, len,
1280                 unsigned long __user *, user_mask_ptr)
1281 {
1282         cpumask_var_t new_mask;
1283         int retval;
1284
1285         if (!alloc_cpumask_var(&new_mask, GFP_KERNEL))
1286                 return -ENOMEM;
1287
1288         retval = get_user_cpu_mask(user_mask_ptr, len, new_mask);
1289         if (retval == 0)
1290                 retval = sched_setaffinity(pid, new_mask);
1291         free_cpumask_var(new_mask);
1292         return retval;
1293 }
1294
1295 long sched_getaffinity(pid_t pid, struct cpumask *mask)
1296 {
1297         struct task_struct *p;
1298         int retval;
1299
1300         guard(rcu)();
1301         p = find_process_by_pid(pid);
1302         if (!p)
1303                 return -ESRCH;
1304
1305         retval = security_task_getscheduler(p);
1306         if (retval)
1307                 return retval;
1308
1309         guard(raw_spinlock_irqsave)(&p->pi_lock);
1310         cpumask_and(mask, &p->cpus_mask, cpu_active_mask);
1311
1312         return 0;
1313 }
1314
1315 /**
1316  * sys_sched_getaffinity - get the CPU affinity of a process
1317  * @pid: pid of the process
1318  * @len: length in bytes of the bitmask pointed to by user_mask_ptr
1319  * @user_mask_ptr: user-space pointer to hold the current CPU mask
1320  *
1321  * Return: size of CPU mask copied to user_mask_ptr on success. An
1322  * error code otherwise.
1323  */
1324 SYSCALL_DEFINE3(sched_getaffinity, pid_t, pid, unsigned int, len,
1325                 unsigned long __user *, user_mask_ptr)
1326 {
1327         int ret;
1328         cpumask_var_t mask;
1329
1330         if ((len * BITS_PER_BYTE) < nr_cpu_ids)
1331                 return -EINVAL;
1332         if (len & (sizeof(unsigned long)-1))
1333                 return -EINVAL;
1334
1335         if (!zalloc_cpumask_var(&mask, GFP_KERNEL))
1336                 return -ENOMEM;
1337
1338         ret = sched_getaffinity(pid, mask);
1339         if (ret == 0) {
1340                 unsigned int retlen = min(len, cpumask_size());
1341
1342                 if (copy_to_user(user_mask_ptr, cpumask_bits(mask), retlen))
1343                         ret = -EFAULT;
1344                 else
1345                         ret = retlen;
1346         }
1347         free_cpumask_var(mask);
1348
1349         return ret;
1350 }
1351
1352 static void do_sched_yield(void)
1353 {
1354         struct rq_flags rf;
1355         struct rq *rq;
1356
1357         rq = this_rq_lock_irq(&rf);
1358
1359         schedstat_inc(rq->yld_count);
1360         current->sched_class->yield_task(rq);
1361
1362         preempt_disable();
1363         rq_unlock_irq(rq, &rf);
1364         sched_preempt_enable_no_resched();
1365
1366         schedule();
1367 }
1368
1369 /**
1370  * sys_sched_yield - yield the current processor to other threads.
1371  *
1372  * This function yields the current CPU to other tasks. If there are no
1373  * other threads running on this CPU then this function will return.
1374  *
1375  * Return: 0.
1376  */
1377 SYSCALL_DEFINE0(sched_yield)
1378 {
1379         do_sched_yield();
1380         return 0;
1381 }
1382
1383 /**
1384  * yield - yield the current processor to other threads.
1385  *
1386  * Do not ever use this function, there's a 99% chance you're doing it wrong.
1387  *
1388  * The scheduler is at all times free to pick the calling task as the most
1389  * eligible task to run, if removing the yield() call from your code breaks
1390  * it, it's already broken.
1391  *
1392  * Typical broken usage is:
1393  *
1394  * while (!event)
1395  *      yield();
1396  *
1397  * where one assumes that yield() will let 'the other' process run that will
1398  * make event true. If the current task is a SCHED_FIFO task that will never
1399  * happen. Never use yield() as a progress guarantee!!
1400  *
1401  * If you want to use yield() to wait for something, use wait_event().
1402  * If you want to use yield() to be 'nice' for others, use cond_resched().
1403  * If you still want to use yield(), do not!
1404  */
1405 void __sched yield(void)
1406 {
1407         set_current_state(TASK_RUNNING);
1408         do_sched_yield();
1409 }
1410 EXPORT_SYMBOL(yield);
1411
1412 /**
1413  * yield_to - yield the current processor to another thread in
1414  * your thread group, or accelerate that thread toward the
1415  * processor it's on.
1416  * @p: target task
1417  * @preempt: whether task preemption is allowed or not
1418  *
1419  * It's the caller's job to ensure that the target task struct
1420  * can't go away on us before we can do any checks.
1421  *
1422  * Return:
1423  *      true (>0) if we indeed boosted the target task.
1424  *      false (0) if we failed to boost the target.
1425  *      -ESRCH if there's no task to yield to.
1426  */
1427 int __sched yield_to(struct task_struct *p, bool preempt)
1428 {
1429         struct task_struct *curr = current;
1430         struct rq *rq, *p_rq;
1431         int yielded = 0;
1432
1433         scoped_guard (raw_spinlock_irqsave, &p->pi_lock) {
1434                 rq = this_rq();
1435
1436 again:
1437                 p_rq = task_rq(p);
1438                 /*
1439                  * If we're the only runnable task on the rq and target rq also
1440                  * has only one task, there's absolutely no point in yielding.
1441                  */
1442                 if (rq->nr_running == 1 && p_rq->nr_running == 1)
1443                         return -ESRCH;
1444
1445                 guard(double_rq_lock)(rq, p_rq);
1446                 if (task_rq(p) != p_rq)
1447                         goto again;
1448
1449                 if (!curr->sched_class->yield_to_task)
1450                         return 0;
1451
1452                 if (curr->sched_class != p->sched_class)
1453                         return 0;
1454
1455                 if (task_on_cpu(p_rq, p) || !task_is_running(p))
1456                         return 0;
1457
1458                 yielded = curr->sched_class->yield_to_task(rq, p);
1459                 if (yielded) {
1460                         schedstat_inc(rq->yld_count);
1461                         /*
1462                          * Make p's CPU reschedule; pick_next_entity
1463                          * takes care of fairness.
1464                          */
1465                         if (preempt && rq != p_rq)
1466                                 resched_curr(p_rq);
1467                 }
1468         }
1469
1470         if (yielded)
1471                 schedule();
1472
1473         return yielded;
1474 }
1475 EXPORT_SYMBOL_GPL(yield_to);
1476
1477 /**
1478  * sys_sched_get_priority_max - return maximum RT priority.
1479  * @policy: scheduling class.
1480  *
1481  * Return: On success, this syscall returns the maximum
1482  * rt_priority that can be used by a given scheduling class.
1483  * On failure, a negative error code is returned.
1484  */
1485 SYSCALL_DEFINE1(sched_get_priority_max, int, policy)
1486 {
1487         int ret = -EINVAL;
1488
1489         switch (policy) {
1490         case SCHED_FIFO:
1491         case SCHED_RR:
1492                 ret = MAX_RT_PRIO-1;
1493                 break;
1494         case SCHED_DEADLINE:
1495         case SCHED_NORMAL:
1496         case SCHED_BATCH:
1497         case SCHED_IDLE:
1498         case SCHED_EXT:
1499                 ret = 0;
1500                 break;
1501         }
1502         return ret;
1503 }
1504
1505 /**
1506  * sys_sched_get_priority_min - return minimum RT priority.
1507  * @policy: scheduling class.
1508  *
1509  * Return: On success, this syscall returns the minimum
1510  * rt_priority that can be used by a given scheduling class.
1511  * On failure, a negative error code is returned.
1512  */
1513 SYSCALL_DEFINE1(sched_get_priority_min, int, policy)
1514 {
1515         int ret = -EINVAL;
1516
1517         switch (policy) {
1518         case SCHED_FIFO:
1519         case SCHED_RR:
1520                 ret = 1;
1521                 break;
1522         case SCHED_DEADLINE:
1523         case SCHED_NORMAL:
1524         case SCHED_BATCH:
1525         case SCHED_IDLE:
1526         case SCHED_EXT:
1527                 ret = 0;
1528         }
1529         return ret;
1530 }
1531
1532 static int sched_rr_get_interval(pid_t pid, struct timespec64 *t)
1533 {
1534         unsigned int time_slice = 0;
1535         int retval;
1536
1537         if (pid < 0)
1538                 return -EINVAL;
1539
1540         scoped_guard (rcu) {
1541                 struct task_struct *p = find_process_by_pid(pid);
1542                 if (!p)
1543                         return -ESRCH;
1544
1545                 retval = security_task_getscheduler(p);
1546                 if (retval)
1547                         return retval;
1548
1549                 scoped_guard (task_rq_lock, p) {
1550                         struct rq *rq = scope.rq;
1551                         if (p->sched_class->get_rr_interval)
1552                                 time_slice = p->sched_class->get_rr_interval(rq, p);
1553                 }
1554         }
1555
1556         jiffies_to_timespec64(time_slice, t);
1557         return 0;
1558 }
1559
1560 /**
1561  * sys_sched_rr_get_interval - return the default time-slice of a process.
1562  * @pid: pid of the process.
1563  * @interval: userspace pointer to the time-slice value.
1564  *
1565  * this syscall writes the default time-slice value of a given process
1566  * into the user-space timespec buffer. A value of '0' means infinity.
1567  *
1568  * Return: On success, 0 and the time-slice is in @interval. Otherwise,
1569  * an error code.
1570  */
1571 SYSCALL_DEFINE2(sched_rr_get_interval, pid_t, pid,
1572                 struct __kernel_timespec __user *, interval)
1573 {
1574         struct timespec64 t;
1575         int retval = sched_rr_get_interval(pid, &t);
1576
1577         if (retval == 0)
1578                 retval = put_timespec64(&t, interval);
1579
1580         return retval;
1581 }
1582
1583 #ifdef CONFIG_COMPAT_32BIT_TIME
1584 SYSCALL_DEFINE2(sched_rr_get_interval_time32, pid_t, pid,
1585                 struct old_timespec32 __user *, interval)
1586 {
1587         struct timespec64 t;
1588         int retval = sched_rr_get_interval(pid, &t);
1589
1590         if (retval == 0)
1591                 retval = put_old_timespec32(&t, interval);
1592         return retval;
1593 }
1594 #endif