《深入理解Linux内核3rd》学习笔记——进程切换（下）：switch_to宏、__switch_to函数

switch_to宏

　　switch_to宏代码如下，其中，prev是即将要被换出CPU的进程的描述符，next是即将得到CPU的进程的描述符。

 1 #define switch_to(prev,next,last) do {                    \
 2     unsigned long esi,edi;                        \
 3     asm volatile("pushfl\n\t"                    \
 4              "pushl %%ebp\n\t"                    \
 5              "movl %%esp,%0\n\t"    /* save ESP */        \
 6              "movl %5,%%esp\n\t"    /* restore ESP */    \
 7              "movl $1f,%1\n\t"        /* save EIP */        \
 8              "pushl %6\n\t"        /* restore EIP */    \
 9              "jmp __switch_to\n"                \
10              "1:\t"                        \
11              "popl %%ebp\n\t"                    \
12              "popfl"                        \
13              :"=m" (prev->thread.esp),"=m" (prev->thread.eip),    \
14               "=a" (last),"=S" (esi),"=D" (edi)            \
15              :"m" (next->thread.esp),"m" (next->thread.eip),    \
16               "2" (prev), "d" (next));                \
17 } while (0)

 

　　该宏的工作步骤大致如下：

1. prev的值送入eax，next的值送入edx（这里我从代码中没有看出来，原著上如是写，可能是从调用switch_to宏的switch_context或schedule函数中处理的）。
2. 保护prev进程的eflags和ebp寄存器内容，这些内容保存在prev进程的内核堆栈中。
3. 将prev的esp寄存器中的数据保存在prev->thread.esp中，即将prev进程的内核堆栈保存起来。
4. 将next->thread.esp中的数据存入esp寄存器中，这是加载next进程的内核堆栈。
5. 将数值1保存到prev->thread.eip中，该数值1其实就是代码中"1:\t"这行中的1。为了恢复prev进程执行时用。
6. 将next->thread.eip压入next进程的内核堆栈中。这个值往往是数值1。
7. 跳转到__switch_to函数处执行。
8. 执行到这里，prev进程重新获得CPU，恢复prev进程的ebp和eflags内容。
9. 将eax的内容存入last参数（这里我也没看出来，原著上如是写，只是在__switch_to函数中返回prev，该值是放在eax中的）。

 

__switch_to函数

　　__switch_to函数采用FASTCALL调用模式，利用eax和edx传入两个参数的值。由于__switch_to中用了很多其他函数，这里首先介绍相关函数和宏，然后再讨论__switch_to函数。

 

　　smp_process_id宏展开如下。该宏得到当前代码运行在哪个CPU上，返回CPU编号。current_thread_info函数返回当前运行着的进程的thread_info结构地址，该函数中让esp的值与上（THREAD_SIZE - 1）的逆，实际上，THREAD_SIZE - 1 = 8192 - 1 = 8191 = 0x1FFF，取反就是0xE000，就是让esp低13位清零，这样就通过内核堆栈得到thread_info结构地址。然后从该结构中得到cpu编号。

/* smp_processor_id宏 */
#define smp_processor_id() __smp_processor_id()

/* __smp_processor_id宏 */
#define __smp_processor_id() (current_thread_info()->cpu)

/* current_thread_info函数 */
static inline struct thread_info *current_thread_info(void)
{
    struct thread_info *ti;
    __asm__("andl %%esp,%0; ":"=r" (ti) : "0" (~(THREAD_SIZE - 1)));
    return ti;
}

 

 

　　per_cup宏展开如下。__switch_to函数中传入init_tss参数和CPU编号cpu给per_cpu宏，然后得到该CPU上的TSS指针。

/* per_cpu宏 */
#define per_cpu(var, cpu) (*RELOC_HIDE(&per_cpu__##var, __per_cpu_offset[cpu]))

/* RELOC_HIDE宏 */
# define RELOC_HIDE(ptr, off)            \
  ({ unsigned long __ptr;                \
     __ptr = (unsigned long) (ptr);        \
    (typeof(ptr)) (__ptr + (off)); })

/* __switch_to函数中使用per_cup的语句 */
struct tss_struct *tss = &per_cpu(init_tss, cpu);

 

　　load_esp0函数定义如下。这里从thread_struct结构中加载esp0到tss中，即即将执行进程的esp0。当SEP打开时，还用wrmsr写入新的CS段选择子——即sysenter指令执行后的代码段。

/* load_esp0 函数定义*/
static inline void load_esp0(struct tss_struct *tss, struct thread_struct *thread)
{
    tss->esp0 = thread->esp0;
    /* This can only happen when SEP is enabled, no need to test "SEP"arately */
    if (unlikely(tss->ss1 != thread->sysenter_cs)) {
        tss->ss1 = thread->sysenter_cs;
        wrmsr(MSR_IA32_SYSENTER_CS, thread->sysenter_cs, 0);
    }
}

/* wrmsr宏 */
#define wrmsr(msr,val1,val2) \
    __asm__ __volatile__("wrmsr" \
              : /* no outputs */ \
              : "c" (msr), "a" (val1), "d" (val2))

 

　　Load_TLS函数定义如下。该函数中使用宏C(i)和per_cpu，先通过per_cpu得到CPU的GDT所在内存的地址，然后将3个thread_struct结构中的tls_array加载到GDT的TLS段中。其中GDT_ENTRY_TLS_MIN=6，这正是3个TLS在GDT中的索引，因此Load_TLS就加载了GDT中3个线程局部段（TLS）。

static inline void load_TLS(struct thread_struct *t, unsigned int cpu)
{
#define C(i) per_cpu(cpu_gdt_table, cpu)[GDT_ENTRY_TLS_MIN + i] = t->tls_array[i]
    C(0); C(1); C(2);
#undef C
}

 

　　现在来看__switch_to函数，其定义和注释如下。

struct task_struct fastcall * __switch_to(struct task_struct *prev_p, struct task_struct *next_p)
{
    struct thread_struct *prev = &prev_p->thread,
                 *next = &next_p->thread;
    int cpu = smp_processor_id(); /* 得到当前代码运行的CPU编号 */
    struct tss_struct *tss = &per_cpu(init_tss, cpu);  /* 得到当前CPU的TSS */

    /* never put a printk in __switch_to... printk() calls wake_up*() indirectly */

    __unlazy_fpu(prev_p); /* 加载FPU、MMX、XMM的寄存器组 */

    /*
     * Reload esp0, LDT and the page table pointer:
     */
    load_esp0(tss, next); /* 加载next的esp0到tss的esp0中 */

    /*
     * Load the per-thread Thread-Local Storage descriptor.
     */
    load_TLS(next, cpu);  /* 加载next的TLS到CPU的GDT的TLS中 */

    /*
     * Save away %fs and %gs. No need to save %es and %ds, as
     * those are always kernel segments while inside the kernel.
     */
    asm volatile("movl %%fs,%0":"=m" (*(int *)&prev->fs)); /* 保存prev的fs寄存器 */
    asm volatile("movl %%gs,%0":"=m" (*(int *)&prev->gs)); /* 保存prev的gs寄存器 */

    /*
     * Restore %fs and %gs if needed.
     */
    if (unlikely(prev->fs | prev->gs | next->fs | next->gs)) {
        loadsegment(fs, next->fs); /* 加载fs寄存器 */
        loadsegment(gs, next->gs); /* 加载gs寄存器 */
    }

    /*
     * Now maybe reload the debug registers
     */
    if (unlikely(next->debugreg[7])) {
        loaddebug(next, 0); /* 从next的thread_struct结构中加载调试信息到dr0-dr7寄存器 */
        loaddebug(next, 1);
        loaddebug(next, 2);
        loaddebug(next, 3);
        /* no 4 and 5 */
        loaddebug(next, 6);
        loaddebug(next, 7);
    }

    if (unlikely(prev->io_bitmap_ptr || next->io_bitmap_ptr))
        handle_io_bitmap(next, tss); /* 从next得到IO允许位，并跟新tss->io_bitmap_base字段 */

    return prev_p;
}