freebsd9.2-线程切换阶段01-入口-mini_switch函数

71v5

[当一个线程需要睡眠或者被抢占，或者需要重新调度时，内核代码调用函数mi_switch完成线程切换与硬件上下文无关的的处理]:

mi_switch函数用到的相关标志：

1.    662        /* Types and flags for mi_switch(). */
   
2.    663        #define        SW_TYPE_MASK                0xff        /* First 8 bits are switch type */
   
3.    664        #define        SWT_NONE                0        /* Unspecified switch. */
   
4.         /* 665：因为抢占 8/
   
5.    665        #define        SWT_PREEMPT                1        /* Switching due to preemption. */
   
6.         /* 666：从临界区退出时，但是此时还有其他thread访问临界区时，就会以SWT_OWEPREEMPT标志调用mini_switch函数 */
   
7.    666        #define        SWT_OWEPREEMPT                2        /* Switching due to opepreempt. */
   
8.         /* 667:当thread要互斥的访问某个变量，而该变量此刻忙，就会以SWT_TURNSTILE标志调用mini_switch函数 */
   
9.    667        #define        SWT_TURNSTILE                3        /* Turnstile contention. */
   
10.         /**************************************************************************
    
11.          * 668-669:如果thread睡眠，就会以SWT_SLEEPQ或者SWT_SLEEPQTIMO标志调用
    
12.                    mini_switch函数。
    
13.          *************/
    
14.    668        #define        SWT_SLEEPQ                4        /* Sleepq wait. */
    
15.    669        #define        SWT_SLEEPQTIMO                5        /* Sleepq timeout wait. */
    
16.         /**************************************************************************
    
17.          * 670： 当发出一个yield系统调用时，该系统调用的内部实现会以SWT_RELINQUISH
    
18.                  标志调用mini_switch函数，即主动放弃cpu。
    
19.          *************/
    
20.    670        #define        SWT_RELINQUISH                6        /* yield call. */
    
21.         /****************************************************************
    
22.          * 671:时钟中断发生时，会递减当前正在运行thread的时间片，如果
    
23.                为零，先重新计算其时间片，然后设置其TDF_NEEDRESCHED标志，
    
24.                在中断返回时，会检查thread是否设置了TDF_NEEDRESCHED标志，
    
25.                如果设置了，就会以SWT_NEEDRESCHED标志调用mini_switch函数。
    
26.          *************/
    
27.    671        #define        SWT_NEEDRESCHED                7        /* NEEDRESCHED was set. */
    
28.         /****************************************************************
    
29.          * 672：中断线程在等待一个中断的到来的时候会以标志SWT_IDLE调用
    
30.                 mini_switch函数。
    
31.          *****/
    
32.    672        #define        SWT_IDLE                8        /* Switching from the idle thread. */
    
33.         /*********************
    
34.    673        #define        SWT_IWAIT                9        /* Waiting for interrupts. */
    
35.         /*******************************************************************
    
36.          * 674：当thread接收到一个默认操作是top的信号时，并且相应的信号
    
37.                 处理程序没有被捕获时，此时thread就会以SWT_SUSPEND标志
    
38.                 调用mini_switch函数。
    
39.          ************/
    
40.    674        #define        SWT_SUSPEND                10        /* Thread suspended. */
    
41.         /*******************************************************************
    
42.          * 675-676：
    
43.            在smp系统中，cpu0向cpu1发出了一个抢占的IPI中断，如果此时cpu1上
    
44.            运行的是idle线程，就以SWT_REMOTEWAKEIDLE标志调用mini_switch函数。
    
45.            如果此时cpu1上运行的是普通线程，就以SWT_REMOTEPREEMPT标志调用
    
46.            mini_switch函数。
    
47.          ********/
    
48.    675        #define        SWT_REMOTEPREEMPT        11        /* Remote processor preempted. */
    
49.    676        #define        SWT_REMOTEWAKEIDLE        12        /* Remote processor preempted idle. */
    
50.         /*******************************************************************
    
51.          * 677：sched_switch_stats数组的大小。
    
52.          *********/
    
53.    677        #define        SWT_COUNT                13        /* Number of switch types. */
    
54.    678        /*******************************************************************
    
55.          * 679： 当发出一个yield系统调用时，该系统调用的内部实现会以SW_VOL
    
56.                  标志调用mini_switch函数，即主动放弃cpu。
    
57.          **************/
    
58.    679        #define        SW_VOL                0x0100                /* Voluntary switch. 主动进行线程切换 */
    
59.         /*******************************************************************
    
60.          * 680-681：
    
61.            如果一个thread被抢占，从sched_preempt函数中会以SW_INVOL和
    
62.            SW_PREEMPT标志调用mi_switch函数时。
    
63.          **************/
    
64.    680        #define        SW_INVOL        0x0200                /* Involuntary switch. 被动进行线程切换 */
    
65.    681        #define SW_PREEMPT        0x0400                /* The invol switch is a preemption 因为抢占? */
    

复制代码

1.    
   
2.    419       
   
3.    420
   
4. /**********************************************************
   
5.   * The machine independent parts of context switching.
   
6.            参数描述：
   
7.            flags：传递给mi_switch函数的一些标志，如上所示。
   
8.            newtd：将要被调度运行的新线程对应的struct thread对象。
   
9. 
   
10.            volatile int        ticks; 系统启动以来经过的节拍数，
    
11.                                由函数hardclock_cnt维护
    
12. **************************/
    
13.    421         
    
14.    422        void
    
15.    423        mi_switch(int flags, struct thread *newtd)
    
16.    424        {     
    
17. /*******************************************************************
    
18.   * runtime：线程的运行时间，使用intel cpu中的TIME-STAMP COUNTER
    
19.                             来描述。
    
20. 
    
21.                    new_switchtime：执行线程切换时的时间戳，使用intel cpu中的
    
22.                                    TIME-STAMP COUNTER来描述。
    
23. 
    
24.                    td：将要被替换的thread对应的struct thread对象，这里为curthread。
    
25. 
    
26.                    p：和td相关联的struct proc对象。
    
27. 
    
28.                    为了描述方便，这里将td，p简单记为old_td，old_p。
    
29.   *********************************/
    
30.    425                uint64_t runtime, new_switchtime;
    
31.    426                struct thread *td;
    
32.    427                struct proc *p;
    
33.    428       
    
34.    429                td = curthread;                        /* XXX */
    
35.    430                THREAD_LOCK_ASSERT(td, MA_OWNED | MA_NOTRECURSED);
    
36.    431                p = td->td_proc;                /* XXX */
    
37.    432                KASSERT(!TD_ON_RUNQ(td), ("mi_switch: called by old code"));
    
38.    433        #ifdef INVARIANTS
    
39.    434                if (!TD_ON_LOCK(td) && !TD_IS_RUNNING(td))
    
40.    435                        mtx_assert(&Giant, MA_NOTOWNED);
    
41.    436        #endif
    
42.    437                KASSERT(td->td_critnest == 1 || panicstr,
    
43.    438                    ("mi_switch: switch in a critical section"));
    
44.    439                KASSERT((flags & (SW_INVOL | SW_VOL)) != 0,
    
45.    440                    ("mi_switch: switch must be voluntary or involuntary"));
    
46.    441                KASSERT(newtd != curthread, ("mi_switch: preempting back to ourself"));
    
47.    442       
    
48.    443                /*
    
49.    444                 * Don't perform context switches from the debugger.
    
50.                    446-447：debugger被激活?
    
51.    445                 */
    
52.    446                if (kdb_active)
    
53.    447                        kdb_switch();
    
54. /**************************************************************************
    
55.   * td_stopsched：如果非零，就表示调度程序被暂停，此时将不会发生线程切换，
    
56.                                  函数panic会将该成员设置为1.
    
57.   * #define  SCHEDULER_STOPPED() __predict_false(curthread->td_stopsched)
    
58.   ****************/
    
59.    448                if (SCHEDULER_STOPPED())
    
60.    449                        return;
    
61. /****************************************************************
    
62.   * 450-454：
    
63.                    递增相应的计数器。
    
64. 
    
65.                    #define  SW_VOL 0x0100 Voluntary switch. 主动进行线程切换
    
66.                   
    
67.                    td_swvoltick：当以标志SW_VOL调用函数mi_switch时，该成员被设置为
    
68.                                  当时的ticks。
    
69. 
    
70.                    long        ru_nvcsw;    voluntary context switches
    
71.                    long        ru_nivcsw;   involuntary
    
72.   **********************************/
    
73.    450                if (flags & SW_VOL) {
    
74.    451                        td->td_ru.ru_nvcsw++;
    
75.    452                        td->td_swvoltick = ticks;
    
76.    453                } else
    
77.    454                        td->td_ru.ru_nivcsw++;
    
78.    455        #ifdef SCHED_STATS
    
79.    456                SCHED_STAT_INC(sched_switch_stats[flags & SW_TYPE_MASK]);
    
80.    457        #endif
    
81.    458               
    
82.    459
    
83.    460
    
84. /*****************************************************************
    
85.    * Compute the amount of time during which the current
    
86.    * thread was running, and add that to its total so far.
    
87. 
    
88.                    462：函数cpu_ticks读取intel cpu的TIME-STAMP COUNTER，用该
    
89.                         计数器的值初始化new_switchtime。
    
90. 
    
91.                    463：runtime记录了线程的运行时间，cpu_ticks描述。
    
92. 
    
93.                    464-465：将runtime累积到td_runtime和td_incruntime上。
    
94. 
    
95.                    466：更新struct pcpu对象的pc_switchtime成员。
    
96. *****************************/
    
97.    461                 
    
98.    462                new_switchtime = cpu_ticks();
    
99.    463                runtime = new_switchtime - PCPU_GET(switchtime);
    
100.    464                td->td_runtime += runtime;
     
101.    465                td->td_incruntime += runtime;
     
102.    466                PCPU_SET(switchtime, new_switchtime);
     
103.    467                td->td_generation++;        /* bump preempt-detect counter */
     
104. /******************************************************
     
105. * 468：递增struct vmmeter对象的v_swtch成员，该成员
     
106.                         记录了系统中执行线程切换的次数。
     
107. 
     
108.                    469：更新struct pcpu对象的pc_switchticks成员，以
     
109.                         全局的ticks来描述。
     
110. *************************/
     
111.    468                PCPU_INC(cnt.v_swtch);
     
112.    469                PCPU_SET(switchticks, ticks);
     
113.    470                CTR4(KTR_PROC, "mi_switch: old thread %ld (td_sched %p, pid %ld, %s)",
     
114.    471                    td->td_tid, td->td_sched, p->p_pid, td->td_name);
     
115.    472        #if (KTR_COMPILE & KTR_SCHED) != 0
     
116.    473                if (TD_IS_IDLETHREAD(td))
     
117.    474                        KTR_STATE1(KTR_SCHED, "thread", sched_tdname(td), "idle",
     
118.    475                            "prio:%d", td->td_priority);
     
119.    476                else
     
120.    477                        KTR_STATE3(KTR_SCHED, "thread", sched_tdname(td), KTDSTATE(td),
     
121.    478                            "prio:%d", td->td_priority, "wmesg:\"%s\"", td->td_wmesg,
     
122.    479                            "lockname:\"%s\"", td->td_lockname);
     
123.    480        #endif
     
124.    481                SDT_PROBE0(sched, , , preempt);
     
125.    482        #ifdef XEN
     
126.    483                PT_UPDATES_FLUSH();
     
127.    484        #endif
     
128. /* 485：调用调度程序相关的sched_switch函数 */
     
129.    485                sched_switch(td, newtd, flags);
     
130.    486                KTR_STATE1(KTR_SCHED, "thread", sched_tdname(td), "running",
     
131.    487                    "prio:%d", td->td_priority);
     
132.    488       
     
133.    489                CTR4(KTR_PROC, "mi_switch: new thread %ld (td_sched %p, pid %ld, %s)",
     
134.    490                    td->td_tid, td->td_sched, p->p_pid, td->td_name);
     
135.    491       
     
136.    492                /*
     
137.    493                 * If the last thread was exiting, finish cleaning it up.
     
138.    494                 */
     
139.    495                if ((td = PCPU_GET(deadthread))) {
     
140.    496                        PCPU_SET(deadthread, NULL);
     
141.    497                        thread_stash(td);
     
142.    498                }
     
143.    499        }
     
144. 
     
145. 
     
146. 
     
147. 
     
148. [ULE调度程序-sched_switch函数]：
     
149. 
     
150. / ********************************************************************
     
151.   * Switch threads.  This function has to handle threads coming in while
     
152.   * blocked for some reason, running, or idle.  It also must deal with
     
153.   * migrating a thread from one queue to another as running threads may
     
154.   * be assigned elsewhere via binding.
     
155. 
     
156.            函数sched_switch完成线程切换，在SMP系统中，还要将线程在系统中cpu
     
157.            的运行队列来回迁移，以保持运行队列的平衡。
     
158.    
     
159.            参数描述：
     
160.            td：将要被替换的thread。
     
161.            newtd：将要被调度运行的thread。
     
162.            flags：一些标志。        
     
163. *********************************/
     
164.   1829        void
     
165.   1830        sched_switch(struct thread *td, struct thread *newtd, int flags)
     
166.   1831        {
     
167. /*********************************************************
     
168. * 局部变量描述:
     
169.                    tdq：指向当前cpu对应的struct tdq对象。
     
170.                    ts：指向和td相关联的struct td_sched数据对象。
     
171.                    mtx：指向防止并发访问的互斥数据结构。
     
172.                    cpuid：当前cpu的logical id。
     
173.                    preempted：如果preempted非零，就表示是由于被抢占而进行
     
174.                               的线程切换；如果preempted为零，就表示是因为
     
175.                               线程的时间片用完而进行的线程切换。
     
176. *************************************/  
     
177.   1832                struct tdq *tdq;
     
178.   1833                struct td_sched *ts;
     
179.   1834                struct mtx *mtx;
     
180.   1835                int srqflag;
     
181.   1836                int cpuid, preempted;
     
182.   1837                
     
183.   1838                THREAD_LOCK_ASSERT(td, MA_OWNED);
     
184.   1839                KASSERT(newtd == NULL, ("sched_switch: Unsupported newtd argument"));
     
185.   1840                
     
186. /*************************************************************
     
187. * 1841：获取当前cpu的logical id。
     
188.                    1842：tdq指向数组元素tdq_cpu[cpuid]。
     
189.                    1843：ts指向和td相关联的struct td_sched数据对象。
     
190.                    1845：函数sched_pctcpu_update更新struct td_sched对象的
     
191.                          相关成员。
     
192.                    1846：将struct td_sched对象的ts_rlick成员设置为ticks。
     
193. *************************************/
     
194.   1841                cpuid = PCPU_GET(cpuid);
     
195.   1842                tdq = TDQ_CPU(cpuid);
     
196.   1843                ts = td->td_sched;
     
197.   1844                mtx = td->td_lock;
     
198.   1845                sched_pctcpu_update(ts, 1);
     
199.   1846                ts->ts_rltick = ticks;
     
200. /****************************************************************
     
201. * 1847-1848：
     
202.                    #define        NOCPU        0xff        For when we aren't on a CPU.
     
203. 
     
204.                    u_char                td_lastcpu; Last cpu we were on.
     
205.                    u_char                td_oncpu;   Which cpu we are on.
     
206. 
     
207.                    td_oncpu：负责执行线程td的cpu的logical id，在线程切换时，
     
208.                              td_lastcpu成员会被更新为td_oncpu的值，当线程
     
209.                              td重新被调度运行时，td_oncpu会被更新。
     
210. **************************************/
     
211.   1847                td->td_lastcpu = td->td_oncpu;
     
212.   1848                td->td_oncpu = NOCPU;
     
213. /***********************************************************************
     
214. * #define TDF_SCHED2        0x04000000 Reserved for scheduler private use
     
215. * #define TDF_SLICEEND    TDF_SCHED2     Thread time slice is over.
     
216.                    #define TD_IS_IDLETHREAD(td)        ((td)->td_flags & TDF_IDLETD)
     
217.                    #define TDF_NEEDRESCHED        0x00010000  Thread needs to yield.
     
218. 
     
219.                    1849：线程切换是被抢占还是自身时间片用完?
     
220.                    1850：清TDF_NEEDRESCHED和TDF_SLICEEND标志。
     
221. 
     
222.                    1851：暂时还不清楚其作用。
     
223.                    volatile u_char td_owepreempt; (k*) Preempt on last critical_exit。
     
224. 
     
225.                    1852-1853：如果td不是idle线程，就递增相应的计数器。
     
226.                    short           tdq_switchcnt;           Switches this tick.
     
227.   ********************************/
     
228.   1849                preempted = !(td->td_flags & TDF_SLICEEND);
     
229.   1850                td->td_flags &= ~(TDF_NEEDRESCHED | TDF_SLICEEND);
     
230.   1851                td->td_owepreempt = 0;
     
231.   1852                if (!TD_IS_IDLETHREAD(td))
     
232.   1853                        tdq->tdq_switchcnt++;
     
233. /**********************************************************************
     
234.   * The lock pointer in an idle thread should never change.  Reset it
     
235.                    * to CAN_RUN as well.
     
236.                    1858-1883：如何处理td(将要被替换的线程thread)。
     
237.                   1858-1861：td为idle线程->
     
238. 
     
239.                    #define TD_SET_CAN_RUN(td) (td)->td_state = TDS_CAN_RUN
     
240.                    此时宏TD_SET_CAN_RUN将td的状态设置为TDS_CAN_RUN。
     
241. ********************************/
     
242.   1858                if (TD_IS_IDLETHREAD(td)) {
     
243.   1859                        MPASS(td->td_lock == TDQ_LOCKPTR(tdq));
     
244.   1860                        TD_SET_CAN_RUN(td);
     
245.   1861                } else if (TD_IS_RUNNING(td)) {
     
246. /***********************************************************************************
     
247. * 1861-1878：
     
248.                    线程td此时处于运行状态，或者被抢占，或者自身的时间片用完，进而执行
     
249.                    了线程切换。
     
250.                
     
251.                    1863-1865：确定srqflag，该变量包含了一些标志，这些标志标识了进行
     
252.                               线程切换的reason。
     
253. 
     
254.                    1866-1869：
     
255.                    SMP支持，判断是否将td迁移到系统中另一个cpu的运行队列上。函数sched_pickcpu的任务
     
256.                    如下：
     
257.                    选择一个负载最小，并且该cpu在线程td的CPU affinity sets(td_cpuset)集合中，并返回
     
258.                    该cpu 的logical id。
     
259.             
     
260.                    #define        THREAD_CAN_MIGRATE(td)        ((td)->td_pinned == 0)
     
261.                    #define THREAD_CAN_SCHED(td, cpu)  CPU_ISSET((cpu), &(td)->td_cpuset->cs_mask)
     
262.   ****************************************/  
     
263.   1862                        MPASS(td->td_lock == TDQ_LOCKPTR(tdq));
     
264.   1863                        srqflag = preempted ?
     
265.   1864                            SRQ_OURSELF|SRQ_YIELDING|SRQ_PREEMPTED :
     
266.   1865                            SRQ_OURSELF|SRQ_YIELDING;
     
267.   1866        #ifdef SMP
     
268.   1867                        if (THREAD_CAN_MIGRATE(td) && !THREAD_CAN_SCHED(td, ts->ts_cpu))
     
269.   1868                                ts->ts_cpu = sched_pickcpu(td, 0);
     
270.   1869        #endif
     
271. /************************************************************
     
272.   * 1870-1872：将在同一个cpu上运行?
     
273.                            根据srqflag参数中的标志，将td重新连接到cpu的运行队列中。
     
274. 
     
275.                            1872-1877：不在同一个cpu上运行。函数sched_switch_migrate
     
276.                                       将td迁移到相应cpu的运行队列中。
     
277. ******************************/
     
278.   1870                        if (ts->ts_cpu == cpuid)
     
279.   1871                                tdq_runq_add(tdq, td, srqflag);
     
280.   1872                        else {
     
281.   1873                                KASSERT(THREAD_CAN_MIGRATE(td) ||
     
282.   1874                                    (ts->ts_flags & TSF_BOUND) != 0,
     
283.   1875                                    ("Thread %p shouldn't migrate", td));
     
284.   1876                                mtx = sched_switch_migrate(tdq, td, srqflag);
     
285.   1877                        }
     
286.   1878                } else {
     
287.   1879                       
     
288. /********************************************************
     
289.   * This thread must be going to sleep.
     
290.                            1880-1882：线程将要睡眠。函数tdq_load_rem更新相应cpu
     
291.                                       的负载等。
     
292. 
     
293. *********************/
     
294.   1880                        TDQ_LOCK(tdq);
     
295.   1881                        mtx = thread_lock_block(td);
     
296.   1882                        tdq_load_rem(tdq, td);
     
297.   1883                }
     
298. /**********************************************************************
     
299.   * We enter here with the thread blocked and assigned to the
     
300.   * appropriate cpu run-queue or sleep-queue and with the current
     
301.   * thread-queue locked.
     
302.                    1890：函数choosethread从当前cpu的运行队列中选择一个优先级最高的
     
303.                          thread带来运行，并返回该thread对应的struct thread对象。
     
304. **********************************/
     
305.   1889                TDQ_LOCK_ASSERT(tdq, MA_OWNED | MA_NOTRECURSED);
     
306.   1890                newtd = choosethread();
     
307. /********************************************************
     
308. * Call the MD code to switch contexts if necessary.
     
309.                    1894-1930：只有当td和newtd不是同一个thread时，才调用
     
310.                               cpu_switch函数完成线程硬件上下文的切换。
     
311. **********************************/
     
312.   1894                if (td != newtd) {
     
313.   1895        #ifdef        HWPMC_HOOKS
     
314.   1896                        if (PMC_PROC_IS_USING_PMCS(td->td_proc))
     
315.   1897                                PMC_SWITCH_CONTEXT(td, PMC_FN_CSW_OUT);
     
316.   1898        #endif
     
317.   1899                        SDT_PROBE2(sched, , , off_cpu, newtd, newtd->td_proc);
     
318.   1900                        lock_profile_release_lock(&TDQ_LOCKPTR(tdq)->lock_object);
     
319.   1901                        TDQ_LOCKPTR(tdq)->mtx_lock = (uintptr_t)newtd;
     
320.   1902                        sched_pctcpu_update(newtd->td_sched, 0);
     
321.   1903       
     
322.   1904        #ifdef KDTRACE_HOOKS
     
323.   1905                        /*
     
324.   1906                         * If DTrace has set the active vtime enum to anything
     
325.   1907                         * other than INACTIVE (0), then it should have set the
     
326.   1908                         * function to call.
     
327.   1909                         */
     
328.   1910                        if (dtrace_vtime_active)
     
329.   1911                                (*dtrace_vtime_switch_func)(newtd);
     
330.   1912        #endif
     
331.   1913                        /* 1914：cpu_switch完成线程硬件上下文的切换 */
     
332.   1914                        cpu_switch(td, newtd, mtx);
     
333. /****************************************************************
     
334.   * We may return from cpu_switch on a different cpu.  However,
     
335.   * we always return with td_lock pointing to the current cpu's
     
336.   * run queue lock.
     
337. 
     
338.                            当线程(刚创建的线程，内核线程等除外)被重新调度运行时，会从
     
339.                            这里开始执行。
     
340. 
     
341.                            1920：cpuid为当前cpu的logical id。
     
342.                            1921：tdq为logical id为cpuid的cpu对应的运行队列。
     
343. *************************************/
     
344.   1920                        cpuid = PCPU_GET(cpuid);
     
345.   1921                        tdq = TDQ_CPU(cpuid);
     
346.   1922                        lock_profile_obtain_lock_success(
     
347.   1923                            &TDQ_LOCKPTR(tdq)->lock_object, 0, 0, __FILE__, __LINE__);
     
348.   1924       
     
349.   1925                        SDT_PROBE0(sched, , , on_cpu);
     
350.   1926        #ifdef        HWPMC_HOOKS
     
351.   1927                        if (PMC_PROC_IS_USING_PMCS(td->td_proc))
     
352.   1928                                PMC_SWITCH_CONTEXT(td, PMC_FN_CSW_IN);
     
353.   1929        #endif
     
354.   1930                } else {
     
355.   1931                        thread_unblock_switch(td, mtx);
     
356.   1932                        SDT_PROBE0(sched, , , remain_cpu);
     
357.   1933                }
     
358. /**************************************************
     
359. * Assert that all went well and return.
     
360.                    1939：更新struct thread对象的td_oncpu成员。
     
361. **************************/
     
362.   1937                TDQ_LOCK_ASSERT(tdq, MA_OWNED|MA_NOTRECURSED);
     
363.   1938                MPASS(td->td_lock == TDQ_LOCKPTR(tdq));
     
364.   1939                td->td_oncpu = cpuid;
     
365.   1940        }
     

复制代码