内核：进程与调度机制(笔记）

void scheduler_tick(void)
{
    // 获取当前CPU上的全局就绪队列rq和当前运行的进程curr
    // 在SMP(多核)的情况下，获得当前CPU的ID、如果不是SMP，那么返回0
  int cpu = smp_processor_id();
    // 获取CPU的全局就绪队列rq，每个CPU都有一个就绪队列rq
  struct rq *rq = cpu_rq(cpu);
    // 获取就绪队列上面正在运行的进程curr
  struct task_struct *curr = rq->curr;
  struct rq_flags rf;
  sched_clock_tick();
  rq_lock(rq, &rf);
    // 更新rq当前时间戳，即相当于rq->clock变为当前时间戳
    // 处理就绪队列时钟的更新，本质上就是增加struct rq当前实例的时钟时间戳
  update_rq_clock(rq);
    // 由于调度器的模块化结构,主要工作可以完全由特定调度器类方法，task_tick实现模式取决底层的调度器类
    // 执行当前运行进程所在调度类的task_tick函数进行周期性调整
  curr->sched_class->task_tick(rq, curr, 0);
    // 将当前负荷加入数组的第一个位置
  cpu_load_update_active(rq);
    // 更新全局CPU就绪队列的calc_load_update
    // 更新CPU的活动计数，主要是更新全局CPU就绪队列calc_load_uodate
  calc_global_load_tick(rq);
    // 解锁
  rq_unlock(rq, &rf);
    // 与perf计数事件有关
  perf_event_task_tick();
#ifdef CONFIG_SMP
    // 判断当前CPU是否为空闲状态
  rq->idle_balance = idle_cpu(cpu);
    // 如果进程周期性负载平衡则触发CCHED_SOFTIRQ终端
  trigger_load_balance(rq);
#endif
  rq_last_tick_reset(rq);
}

void update_rq_clock(struct rq *rq)
{
  s64 delta;
  lockdep_assert_held(&rq->lock);
  if (rq->clock_update_flags & RQCF_ACT_SKIP)
    return;
#ifdef CONFIG_SCHED_DEBUG
  if (sched_feat(WARN_DOUBLE_CLOCK))
    SCHED_WARN_ON(rq->clock_update_flags & RQCF_UPDATED);
  rq->clock_update_flags |= RQCF_UPDATED;
#endif
  delta = sched_clock_cpu(cpu_of(rq)) - rq->clock;
  if (delta < 0)
    return;
  rq->clock += delta;
  update_rq_clock_task(rq, delta);
}

/*
 * Called from scheduler_tick() to periodically update this CPU's
 * active count.
 */
void calc_global_load_tick(struct rq *this_rq)
{
  long delta;
  if (time_before(jiffies, this_rq->calc_load_update))
    return;
  delta  = calc_load_fold_active(this_rq, 0);
  if (delta)
    atomic_long_add(delta, &calc_load_tasks);
  this_rq->calc_load_update += LOAD_FREQ;
}

asmlinkage __visible void __sched schedule(void)
{
  struct task_struct *tsk = current;
  sched_submit_work(tsk);
  do {
    preempt_disable();
    __schedule(false);
    sched_preempt_enable_no_resched();
  } while (need_resched());
}
EXPORT_SYMBOL(schedule);

static __always_inline struct rq *
context_switch(struct rq *rq, struct task_struct *prev,
         struct task_struct *next, struct rq_flags *rf)
{
  struct mm_struct *mm, *oldmm;
    // 执行进程切换的准备工作
  prepare_task_switch(rq, prev, next);
  mm = next->mm;
  oldmm = prev->active_mm;
  /*
   * For paravirt, this is coupled with an exit in switch_to to
   * combine the page table reload and the switch backend into
   * one hypercall.
   */
    // 开始上下文的切换，是每一种处理器架构必须定义的函数
  arch_start_context_switch(prev);
    // 如果下一个进程是内核线程(mm是空指针)，内核线程没有用户虚拟地址空间，
  if (!mm) {
    next->active_mm = oldmm;
    mmgrab(oldmm);
        // 此函数通知处理器架构不需要切换用户虚拟地址空间，这种加速进程切换的技术TLB
    enter_lazy_tlb(oldmm, next);
  } else
        // 如果下一个进程是用户进程，那么就调用此函数切换进程的用户虚拟地址空间。
    switch_mm_irqs_off(oldmm, mm, next);
    // 如果上一个进程是内核线程，把成员active_mm为空指针，断开它与借用的用户虚拟地址空间的联系，把它借用的用户虚拟地址空间保存在运行队列的成员prev_mm中。
  if (!prev->mm) {
    prev->active_mm = NULL;
    rq->prev_mm = oldmm;
  }
  rq->clock_update_flags &= ~(RQCF_ACT_SKIP|RQCF_REQ_SKIP);
  /*
   * Since the runqueue lock will be released by the next
   * task (which is an invalid locking op but in the case
   * of the scheduler it's an obvious special-case), so we
   * do an early lockdep release here:
   */
  rq_unpin_lock(rq, rf);
  spin_release(&rq->lock.dep_map, 1, _THIS_IP_);
  /* Here we just switch the register state and the stack. */
  switch_to(prev, next, prev);
  barrier();
  return finish_task_switch(prev);
}

static inline void __switch_mm(struct mm_struct *next)
{
  unsigned int cpu = smp_processor_id();
  /*
   * init_mm.pgd does not contain any user mappings and it is always
   * active for kernel addresses in TTBR1. Just set the reserved TTBR0.
   */
  if (next == &init_mm) {
    cpu_set_reserved_ttbr0();
    return;
  }
  check_and_switch_context(next, cpu);
}

/*
 * Thread switching.
 */
__notrace_funcgraph struct task_struct *__switch_to(struct task_struct *prev,
        struct task_struct *next)
{
  struct task_struct *last;
  fpsimd_thread_switch(next); // 切换浮点寄存器
  tls_thread_switch(next);    // 切换线程本地存储相关的寄存器
  hw_breakpoint_thread_switch(next); // 切换调试寄存器
  contextidr_thread_switch(next);    // 切换上下文标识符寄存器
  entry_task_switch(next);   // 使用当前处理器每处理器变量记录下一个进程的进程描述符地址
  uao_thread_switch(next);   //         
  /*
   * Complete any pending TLB or cache maintenance on this CPU in case
   * the thread migrates to a different CPU.
   */
  // 在这个处理器上执行完前面的所有页表缓存或缓存维护操作，防止线程迁移到其它处理器上
  dsb(ish);
  /* the actual thread switch */
    // 实际线程切换
  last = cpu_switch_to(prev, next);
  return last;
}