sys_nice源码分析

sys_nice系统调用用于改变进程的优先级，下面来看。

sys_nice
kernel/sched/core.c

SYSCALL_DEFINE1(nice, int, increment){    long nice, retval;    increment = clamp(increment, -NICE_WIDTH, NICE_WIDTH);    nice = task_nice(current) + increment;    nice = clamp_val(nice, MIN_NICE, MAX_NICE);    if (increment < 0 && !can_nice(current, nice))        return -EPERM;    set_user_nice(current, nice);    return 0;}

clamp宏让increment变量限制在(-NICE_WIDTH, NICE_WIDTH)范围内。NICE_WIDTH的默认值为40。即nice系统调用用户提供的进程优先级只能限制在-40到40的范围内。

#define clamp(val, lo, hi) min((typeof(val))max(val, lo), hi)

接下来通过task_nice函数获取进程当前优先级对应的nice值，并与increment相加获得新的nice值。
clamp_val宏和clamp类似，将nice值限制在(MIN_NICE, MAX_NICE)范围内。MIN_NICE为-19，MAX_NICE为20。
再往下调用can_nice函数检查新的nice值是否会超过系统的限制值。
最后通过set_user_nice函数将新的nice值设置到task_struct中。

sys_nice->task_nice
include/linux/sched.h

static inline int task_nice(const struct task_struct *p){    return PRIO_TO_NICE((p)->static_prio);}#define PRIO_TO_NICE(prio)  ((prio) - DEFAULT_PRIO)#define DEFAULT_PRIO (MAX_RT_PRIO + NICE_WIDTH / 2)#define MAX_USER_RT_PRIO    100#define MAX_RT_PRIO     MAX_USER_RT_PRIO

task_nice首先从进程task_struct结构中获得静态优先级static_prio，然后通过PRIO_TO_NICE宏将其转化成nice值。PRIO_TO_NICE宏其实就是(prio - 120)。相反，NICE_TO_PRIO宏其实就是(nice + 120)。

sys_nice->can_nice
kernel/sched/core.c

int can_nice(const struct task_struct *p, const int nice){    int nice_rlim = nice_to_rlimit(nice);    return (nice_rlim <= task_rlimit(p, RLIMIT_NICE));}static inline long nice_to_rlimit(long nice){    return (MAX_NICE - nice + 1);}

nice_to_rlimit将nice值从-20到19反向对应到2到41，即-20对应41，19对应2。
转化后检查该值是否小于系统的限制值。task_rlimit内部通过系统调用获得该限制值，该限制值在内核启动时就已经确定下来。

sys_nice->set_user_nice
kernel/sched/core.c

void set_user_nice(struct task_struct *p, long nice){    int old_prio, delta, queued;    unsigned long flags;    struct rq *rq;    rq = task_rq_lock(p, &flags);    if (task_has_dl_policy(p) || task_has_rt_policy(p)) {        p->static_prio = NICE_TO_PRIO(nice);        goto out_unlock;    }    queued = task_on_rq_queued(p);    if (queued)        dequeue_task(rq, p, 0);    p->static_prio = NICE_TO_PRIO(nice);    set_load_weight(p);    old_prio = p->prio;    p->prio = effective_prio(p);    delta = p->prio - old_prio;    if (queued) {        enqueue_task(rq, p, 0);        if (delta < 0 || (delta > 0 && task_running(rq, p)))            resched_curr(rq);    }out_unlock:    task_rq_unlock(rq, p, &flags);}

task_rq_lock获得进程p所属的运行队列rq。

如果当前进程的调度策略是SCHED_DEADLINE、SCHED_FIFO和SCHED_RR的一种，则直接通过NICE_TO_PRIO宏将nice值转化为优先级值并设置到static_prio中即可。
SCHED_DEADLINE采用了EDF调度算法，主要针对运行时间比较敏感的进程，SCHED_FIFO和SCHED_RR调度策略主要是针对实时进程。

如果是其他的调度策略，最典型的是SCHED_NORMAL，此时首先通过task_on_rq_queued检查当前进程是否在运行队列上，如果是则返回1，否则返回0。如果当前进程在运行队列上，就要通过dequeue_task函数将其移除当前运行队列，等待重新设置进程权重后再放回运行队列。dequeue_task函数和后面的enqueue_task函数在《enqueue_task和dequeue_task源码分析》文章中分析了。

接下来也要设置static_prio。根据前面的分析，该值的范围在101到140之间。

set_load_weight函数根据当前进程的静态优先级设置其对应的调度实体sched_entity的权重，内核在调度进程时，最终会通过计算该权重将进程对应的调度实体插入到一个红黑树中，然后再从该树中找到一个最合适的进程运行。

下面以CFS调度策略为例，effective_prio对于CFS调度的普通进程而言其实就是获得static_prio。再计算delta表示新旧两个static_prio的差。然后如果前面将进程从运行队列中出队，这里就要通过enqueue_task函数将其重新入队。如果delta小于0，则表示进程的优先级提高，如果delta大于0，表示进程的优先级降低，并且此时进程正在运行，这两种情况都要通过resched_curr函数设置运行队列当前正在运行的进程的TIF_NEED_RESCHED标志位，让其重新调度一次。task_running宏检查进程是否在运行中。

static inline int task_running(struct rq *rq, struct task_struct *p){    return p->on_cpu;}

sys_nice->set_user_nice->task_has_dl_policy
kernel/sched/sched.h

static inline int task_has_dl_policy(struct task_struct *p){    return dl_policy(p->policy);}static inline int dl_policy(int policy){    return policy == SCHED_DEADLINE;}static inline int task_has_rt_policy(struct task_struct *p){    return rt_policy(p->policy);}static inline int rt_policy(int policy){    return policy == SCHED_FIFO || policy == SCHED_RR;}

task_has_dl_policy函数通过dl_policy函数检查进程的调度策略是否是SCHED_DEADLINE；task_has_rt_policy函数通过rt_policy函数检查进程的调度策略是否是SCHED_FIFO或SCHED_RR。

sys_nice->set_user_nice->set_load_weight
kernel/sched/core.c

static void set_load_weight(struct task_struct *p){    int prio = p->static_prio - MAX_RT_PRIO;    struct load_weight *load = &p->se.load;    if (p->policy == SCHED_IDLE) {        ...        return;    }    load->weight = prio_to_weight[prio];    load->inv_weight = prio_to_wmult[prio];}

根据前面的分析可知这里的静态优先级static_prio的范围在101到140之间，减去MAX_RT_PRIO即100后，prio的范围限制在1到40之间。
接下来获得进程对应的调度实体sched_entity的权重load_weight，这里只考虑使用CFS策略调度的普通进程，最后将刚刚计算的prio值作为数组下表，在prio_to_weight和prio_to_wmult数组中查找对应的权重值及它的倒数，并设置到load_weight的weight和inv_weight变量中。

static const int prio_to_weight[40] = { /* -20 */     88761,     71755,     56483,     46273,     36291, /* -15 */     29154,     23254,     18705,     14949,     11916, /* -10 */      9548,      7620,      6100,      4904,      3906, /*  -5 */      3121,      2501,      1991,      1586,      1277, /*   0 */      1024,       820,       655,       526,       423, /*   5 */       335,       272,       215,       172,       137, /*  10 */       110,        87,        70,        56,        45, /*  15 */        36,        29,        23,        18,        15,};static const u32 prio_to_wmult[40] = { /* -20 */     48388,     59856,     76040,     92818,    118348, /* -15 */    147320,    184698,    229616,    287308,    360437, /* -10 */    449829,    563644,    704093,    875809,   1099582, /*  -5 */   1376151,   1717300,   2157191,   2708050,   3363326, /*   0 */   4194304,   5237765,   6557202,   8165337,  10153587, /*   5 */  12820798,  15790321,  19976592,  24970740,  31350126, /*  10 */  39045157,  49367440,  61356676,  76695844,  95443717, /*  15 */ 119304647, 148102320, 186737708, 238609294, 286331153,};

设置prio_to_wmult数组是为了提升算法速度，例如在CFS调度策略中，会选择一个进程并计算其运行的虚拟时间，这个计算过程就会使用进程权重的倒数，因此在这里提前计算。

sys_nice->set_user_nice->effective_prio
kernel/sched/core.c

static int effective_prio(struct task_struct *p){    p->normal_prio = normal_prio(p);    if (!rt_prio(p->prio))        return p->normal_prio;    return p->prio;}static inline int normal_prio(struct task_struct *p){    int prio;    if (task_has_dl_policy(p))        prio = MAX_DL_PRIO-1;    else if (task_has_rt_policy(p))        prio = MAX_RT_PRIO-1 - p->rt_priority;    else        prio = __normal_prio(p);    return prio;}static inline int __normal_prio(struct task_struct *p){    return p->static_prio;}

effective_prio对于采用CFS调度策略的普通进程而言，最终返回的就是进程的static_prio。

sys_nice->set_user_nice->resched_curr
kernel/sched/core.c

void resched_curr(struct rq *rq){    struct task_struct *curr = rq->curr;    int cpu;    if (test_tsk_need_resched(curr))        return;    cpu = cpu_of(rq);    if (cpu == smp_processor_id()) {        set_tsk_need_resched(curr);        set_preempt_need_resched();        return;    }    ...}static inline int test_tsk_need_resched(struct task_struct *tsk){    return unlikely(test_tsk_thread_flag(tsk,TIF_NEED_RESCHED));}static inline void set_tsk_need_resched(struct task_struct *tsk){    set_tsk_thread_flag(tsk,TIF_NEED_RESCHED);}static __always_inline void set_preempt_need_resched(void){    raw_cpu_and_4(__preempt_count, ~PREEMPT_NEED_RESCHED);}

test_tsk_need_resched检查thread_info结构的标志位中是否已经设置了TIF_NEED_RESCHED。
cpu_of宏获得运行队列rq对应的cpu，smp_processor_id宏则获得当前进程对应的cpu的id。下面只考虑两者相等的情况，此时，通过set_tsk_need_resched增加TIF_NEED_RESCHED到进程thread_info结构的标志位，再通过set_preempt_need_resched函数设置per-cpu变量__preempt_count。