8825 /*
8826  * Nice levels are multiplicative, with a gentle 10% change for every
8827  * nice level changed. I.e. when a CPU-bound task goes from nice 0 to
8828  * nice 1, it will get ~10% less CPU time than another CPU-bound task
8829  * that remained on nice 0.
8830  *
8831  * The "10% effect" is relative and cumulative: from _any_ nice level,
8832  * if you go up 1 level, it's -10% CPU usage, if you go down 1 level
8833  * it's +10% CPU usage. (to achieve that we use a multiplier of 1.25.
8834  * If a task goes up by ~10% and another task goes down by ~10% then
8835  * the relative distance between them is ~25%.)
8836  */
8837 const int sched_prio_to_weight[40] = {
8838  /* -20 */     88761,     71755,     56483,     46273,     36291,
8839  /* -15 */     29154,     23254,     18705,     14949,     11916,
8840  /* -10 */      9548,      7620,      6100,      4904,      3906,
8841  /*  -5 */      3121,      2501,      1991,      1586,      1277,
8842  /*   0 */      1024,       820,       655,       526,       423,
8843  /*   5 */       335,       272,       215,       172,       137,
8844  /*  10 */       110,        87,        70,        56,        45,
8845  /*  15 */        36,        29,        23,        18,        15,
8846 };
8847 
8848 /*
8849  * Inverse (2^32/x) values of the sched_prio_to_weight[] array, precalculated.
8850  *
8851  * In cases where the weight does not change often, we can use the
8852  * precalculated inverse to speed up arithmetics by turning divisions
8853  * into multiplications:
8854  */
8855 const u32 sched_prio_to_wmult[40] = {
8856  /* -20 */     48388,     59856,     76040,     92818,    118348,
8857  /* -15 */    147320,    184698,    229616,    287308,    360437,
8858  /* -10 */    449829,    563644,    704093,    875809,   1099582,
8859  /*  -5 */   1376151,   1717300,   2157191,   2708050,   3363326,
8860  /*   0 */   4194304,   5237765,   6557202,   8165337,  10153587,
8861  /*   5 */  12820798,  15790321,  19976592,  24970740,  31350126,
8862  /*  10 */  39045157,  49367440,  61356676,  76695844,  95443717,
8863  /*  15 */ 119304647, 148102320, 186737708, 238609294, 286331153,
8864 };

1306 extern const struct sched_class stop_sched_class;
1307 extern const struct sched_class dl_sched_class;
1308 extern const struct sched_class rt_sched_class;
1309 extern const struct sched_class fair_sched_class;
1310 extern const struct sched_class idle_sched_class;

  3 /*
  4  * idle-task scheduling class.
  5  *
  6  * (NOTE: these are not related to SCHED_IDLE tasks which are
  7  *  handled in sched/fair.c)
  8  */

  4 #define MAX_NICE        19
  5 #define MIN_NICE        -20
  6 #define NICE_WIDTH      (MAX_NICE - MIN_NICE + 1)
  7 
  8 /*
  9  * Priority of a process goes from 0..MAX_PRIO-1, valid RT
 10  * priority is 0..MAX_RT_PRIO-1, and SCHED_NORMAL/SCHED_BATCH
 11  * tasks are in the range MAX_RT_PRIO..MAX_PRIO-1. Priority
 12  * values are inverted: lower p->prio value means higher priority.
 13  *
 14  * The MAX_USER_RT_PRIO value allows the actual maximum
 15  * RT priority to be separate from the value exported to
 16  * user-space.  This allows kernel threads to set their
 17  * priority to a value higher than any user task. Note:
 18  * MAX_RT_PRIO must not be smaller than MAX_USER_RT_PRIO.
 19  */
 20 
 21 #define MAX_USER_RT_PRIO        100
 22 #define MAX_RT_PRIO             MAX_USER_RT_PRIO
 23 
 24 #define MAX_PRIO                (MAX_RT_PRIO + NICE_WIDTH)
 25 #define DEFAULT_PRIO            (MAX_RT_PRIO + NICE_WIDTH / 2)
 26 
 27 /*
 28  * Convert user-nice values [ -20 ... 0 ... 19 ]
 29  * to static priority [ MAX_RT_PRIO..MAX_PRIO-1 ],
 30  * and back.
 31  */
 32 #define NICE_TO_PRIO(nice)      ((nice) + DEFAULT_PRIO)
 33 #define PRIO_TO_NICE(prio)      ((prio) - DEFAULT_PRIO)
 34 
 35 /*
 36  * 'User priority' is the nice value converted to something we
 37  * can work with better when scaling various scheduler parameters,
 38  * it's a [ 0 ... 39 ] range.
 39  */
 40 #define USER_PRIO(p)            ((p)-MAX_RT_PRIO)
 41 #define TASK_USER_PRIO(p)       USER_PRIO((p)->static_prio)
 42 #define MAX_USER_PRIO           (USER_PRIO(MAX_PRIO))
 43 
 44 /*
 45  * Convert nice value [19,-20] to rlimit style value [1,40].
 46  */
 47 static inline long nice_to_rlimit(long nice)
 48 {
 49         return (MAX_NICE - nice + 1);
 50 }
 51 
 52 /*
 53  * Convert rlimit style value [1,40] to nice value [-20, 19].
 54  */
 55 static inline long rlimit_to_nice(long prio)
 56 {
 57         return (MAX_NICE - prio + 1);
 58 }

5085 /**
5086  * sys_sched_get_priority_max - return maximum RT priority.
5087  * @policy: scheduling class.
5088  *
5089  * Return: On success, this syscall returns the maximum
5090  * rt_priority that can be used by a given scheduling class.
5091  * On failure, a negative error code is returned.
5092  */
5093 SYSCALL_DEFINE1(sched_get_priority_max, int, policy)
5094 {
5095         int ret = -EINVAL;
5096 
5097         switch (policy) {
5098         case SCHED_FIFO:
5099         case SCHED_RR:
5100                 ret = MAX_USER_RT_PRIO-1;
5101                 break;
5102         case SCHED_DEADLINE:
5103         case SCHED_NORMAL:
5104         case SCHED_BATCH:
5105         case SCHED_IDLE:
5106                 ret = 0;
5107                 break;
5108         }
5109         return ret;
5110 }

5112 /**
5113  * sys_sched_get_priority_min - return minimum RT priority.
5114  * @policy: scheduling class.
5115  *
5116  * Return: On success, this syscall returns the minimum
5117  * rt_priority that can be used by a given scheduling class.
5118  * On failure, a negative error code is returned.
5119  */
5120 SYSCALL_DEFINE1(sched_get_priority_min, int, policy)
5121 {
5122         int ret = -EINVAL;
5123 
5124         switch (policy) {
5125         case SCHED_FIFO:
5126         case SCHED_RR:
5127                 ret = 1;
5128                 break;
5129         case SCHED_DEADLINE:
5130         case SCHED_NORMAL:
5131         case SCHED_BATCH:
5132         case SCHED_IDLE:
5133                 ret = 0;
5134         }
5135         return ret;
5136 }

        if (sched_getparam(pid, &sp) != 0)
            err(EXIT_FAILURE, _("failed to get pid %d's attributes"), pid);
        else
            prio = sp.sched_priority;

4584         if (task_has_rt_policy(p))
4585                 lp.sched_priority = p->rt_priority;

         case EU_PRI:
            if (-99 > p->priority || 999 < p->priority) {
               cp = make_str("rt", W, Jn, AUTOX_NO);
            } else
               cp = make_num(p->priority, W, Jn, AUTOX_NO, 0);
            break;

// Based on "type", FreeBSD would do:
//    REALTIME  "real:%u", prio
//    NORMAL    "normal"
//    IDLE      "idle:%u", prio
//    default   "%u:%u", type, prio
// We just print the priority, and have other keywords for type.
static int pr_rtprio(char *restrict const outbuf, const proc_t *restrict const pp){
  if(pp->sched==0 || pp->sched==(unsigned long)-1) return snprintf(outbuf, COLWID, "-");
  return snprintf(outbuf, COLWID, "%ld", pp->rtprio);
}

// not legal as UNIX "PRI"
// "pri"               (was 20..60, now    0..139)
static int pr_pri(char *restrict const outbuf, const proc_t *restrict const pp){         /* 20..60 */
    return snprintf(outbuf, COLWID, "%ld", 39 - pp->priority);
}

// legal as UNIX "PRI"
// "priority"         (was -20..20, now -100..39)
static int pr_priority(char *restrict const outbuf, const proc_t *restrict const pp){    /* -20..20 */
    return snprintf(outbuf, COLWID, "%ld", pp->priority);
}

481         /* scale priority and nice values from timeslices to -20..20 */
482         /* to make it look like a "normal" Unix priority/nice value  */
483         priority = task_prio(task);
(----------snip----------)
504         seq_put_decimal_ll(m, " ", priority);
(----------snip----------)
542         seq_put_decimal_ull(m, " ", task->rt_priority);

3838 /**
3839  * task_prio - return the priority value of a given task.
3840  * @p: the task in question.
3841  *
3842  * Return: The priority value as seen by users in /proc.
3843  * RT tasks are offset by -200. Normal tasks are centered
3844  * around 0, value goes from -16 to +15.
3845  */
3846 int task_prio(const struct task_struct *p)
3847 {
3848         return p->prio - MAX_RT_PRIO;
3849 }

871 /*
872  * __normal_prio - return the priority that is based on the static prio
873  */
874 static inline int __normal_prio(struct task_struct *p)
875 {
876         return p->static_prio;
877 }
878 
879 /*
880  * Calculate the expected normal priority: i.e. priority
881  * without taking RT-inheritance into account. Might be
882  * boosted by interactivity modifiers. Changes upon fork,
883  * setprio syscalls, and whenever the interactivity
884  * estimator recalculates.
885  */
886 static inline int normal_prio(struct task_struct *p)
887 {
888         int prio;
889 
890         if (task_has_dl_policy(p))
891                 prio = MAX_DL_PRIO-1;
892         else if (task_has_rt_policy(p))
893                 prio = MAX_RT_PRIO-1 - p->rt_priority;
894         else
895                 prio = __normal_prio(p);
896         return prio;
897 }