freebsd9.2-处理器间中断-发送

71v5

有了前面"内核如何实现IA32中断处理"中的内容作为准备，依然将处理器间中断简称为IPI，下面结合ULE线程调度来看一下IPI的发送过程。

先来看一下需要用到的数据结构:

[数组cpu_ipi_pending]-用来处理IPI_AST，IPI_PREEMPT，IPI_HARDCLOCK三个特殊的IPI：

1. /*****************************************************************************
   
2. * Holds pending bitmap based IPIs per CPU 。
   
3.    
   
4.    数组cpu_ipi_pending和下面的IPI中断向量号结合起来理解会更清楚：
   
5. 
   
6.    #define        IPI_BITMAP_VECTOR        249
   
7. 
   
8.    对于下面三个IPI的描述为"IPIs handled by IPI_BITMAPED_VECTOR"：
   
9.    #define IPI_AST                0        
   
10.    #define IPI_PREEMPT          1
    
11.    #define IPI_HARDCLOCK        2
    
12. 
    
13.    IPI_AST：忽略，内核中的描述"Nothing to do for AST"。
    
14. 
    
15.    IPI_PREEMPT：需要抢占时发送。
    
16.    
    
17.    IPI_HARDCLOCK：
    
18.    在SMP系统中，只有BSP上的APIC TIMER启用，而其余AP上的APIC TIMER没有启用
    
19.    时，当BSP上的APIC TIMER超时后，就会向其余AP发送一个IPI_HARDCLOCK
    
20.    类型的IPI。
    
21.   
    
22.    由此看见，当发送类型为IPI_AST，IPI_PREEMPT，IPI_HARDCLOCK的IPI时，
    
23.    其实是通过中断向量号为IPI_BITMAP_VECTOR对应的中断处理程序来处理的，
    
24.    那么就需要通过一种方法，该方法能够设置一个标志，中断向量号为
    
25.    IPI_BITMAP_VECTOR对应的中断处理程序通过检查相应的标志来确定发送的
    
26.    是IPI_AST，IPI_PREEMPT，IPI_HARDCLOCK三个IPI的哪一个，这个这个方法
    
27.    就是使用数组cpu_ipi_pending。
    
28. 
    
29.    系统中每个cpu在数组cpu_ipi_pending中都有相应的元素，logical cpu id
    
30.    作为数组cpu_ipi_pending的索引。
    
31. 
    
32.    假设系统中某个cpu的logical cpu id为1，那么当该cpu接收到一个
    
33.    中断向量号为IPI_BITMAP_VECTOR的中断时，相应的中断处理程序就会检查
    
34.    数组元素cpu_ipi_pending[1]中IPI_AST，IPI_PREEMPT，IPI_HARDCLOCK对应
    
35.    的bit位是否被设置为1，如果是，就进行相应的处理。设置为1的任务由
    
36.    发送IPI的cpu来完成。
    
37. 
    
38.    通过上面的描述，可以看出，数组cpu_ipi_pending用来描述系统中某个cpu
    
39.    是否有挂起的IPI_AST，IPI_PREEMPT，IPI_HARDCLOCK的IPI。
    
40. ********************************************/
    
41.    198  static volatile u_int cpu_ipi_pending[MAXCPU];

复制代码

[和IPI计数器相关的数组]-对cpu上接收到的IPI进行计数：

1. /*******************************************************************************
   
2. * 只有在编译内核时选择了COUNT_IPIS选项，下面的描述才有效。
   
3. 
   
4.    161-169：
   
5.    下面的数组对IPI进行计数，每个数组都对应一个IPI类型。
   
6.    对于某一个特定数组，这里假设为数组数组ipi_invltlb_counts，系统中每个cpu
   
7.    都在ipi_invltlb_counts数组中有相应的元素，数组的索引为logical cpu id。
   
8. 
   
9.    对于cpu0，当cpu0接收到一个类型为IPI_INVLTLB的IPI时，相应的中断处理程序
   
10.    就会递增*ipi_invltlb_counts[0].
    
11. 
    
12. 
    
13.    u_long intrcnt[INTRCNT_COUNT];
    
14.    char intrnames[INTRCNT_COUNT * (MAXCOMLEN + 1)];
    
15.    
    
16.    初始化函数mp_ipi_intrcnt完成两个主要任务：
    
17.    1：用intrcnt数组元素的地址初始化下面的指针数组。
    
18.    2：使用类似"cpu%d:invltlb"这样的字符串初始化上面的intrname数组，这里的%d
    
19.       为cpu的logical cpu id。
    
20. *********************************************/
    
21.    161  static u_long *ipi_preempt_counts[MAXCPU];
    
22.    162  static u_long *ipi_ast_counts[MAXCPU];
    
23.    163  u_long *ipi_invltlb_counts[MAXCPU];
    
24.    164  u_long *ipi_invlrng_counts[MAXCPU];
    
25.    165  u_long *ipi_invlpg_counts[MAXCPU];
    
26.    166  u_long *ipi_invlcache_counts[MAXCPU];
    
27.    167  u_long *ipi_rendezvous_counts[MAXCPU];
    
28.    168  u_long *ipi_lazypmap_counts[MAXCPU];
    
29.    169  static u_long *ipi_hardclock_counts[MAXCPU];

复制代码

[数组cpu_apic_ids和apic_cpuids]：

1. /******************************************************************************************
   
2. * #define        MAX_APIC_ID        0xfe
   
3.    #define MAXCPU                32
   
4. 
   
5.    下面两个数组都是由函数assign_cpu_ids初始化的，该函数在初始化函数cpu_mp_start中被调用。
   
6. 
   
7.    数组cpu_apic_ids的索引为logical cpu id，相应数组元素的值为cpu的local APIC ID。
   
8.    数组apic_cpuids的索引为cpu的local APIC ID，相应数组元素的值为cpu的logical cpu id。  
   
9. ********************************************/
   
10.    194        int cpu_apic_ids[MAXCPU];
    
11.    195        int apic_cpuids[MAX_APIC_ID + 1];

复制代码

[struct tdq对象中的tdq_ipipending成员]：

1. /******************************************************************************
   
2. * tdq - per processor runqs and statistics.  All fields are protected by the
   
3. * tdq_lock.  The load and lowpri may be accessed without to avoid excess
   
4. * locking in sched_pickcpu();
   
5.    对于SMP系统：
   
6.    每个cpu对应的一个struct tdq数据对象，数组tdq_cpu以cpu的logical id为索引。
   
7.    static struct tdq       tdq_cpu[MAXCPU];
   
8. 
   
9.    对于非SMP系统：
   
10.    系统中只定义了一个struct tdq数据对象。
    
11.    static struct tdq       tdq_cpu;
    
12. 
    
13.    tdq_ipipending:表示是否有挂起的IPI。
    
14. *****************************************************/
    
15.    225  struct tdq {
    
16. 。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
    
17.    236          u_char          tdq_ipipending;         /* IPI pending. */
    
18. 。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
    
19.    246  } __aligned(64);

复制代码

根据之前sched_add函数的描述，当把一个线程td添加到系统中某个cpu(假设为cpu5)的运行队列时，就会检查td是否能够抢占当前
正在cpu5上运行的线程，如果可以抢占，就要给cpu5发送一个IPI。
[摘取sched_add函数的部分代码]：

1. /**************************************************************************************
   
2. * Select the target thread queue and add a thread to it.  Request
   
3. * preemption or IPI a remote processor if required.
   
4. 
   
5.    参数描述：
   
6. 
   
7.    td：标识将要被添加到cpu运行队列中的线程。
   
8. 
   
9.    flags：传递给函数sched_add的标志，相关标志需要结合上下文分析，这里暂且略过。
   
10. **************************************/
    
11.   2342        
    
12.   2343        void
    
13.   2344        sched_add(struct thread *td, int flags)
    
14.   2345        {
    
15. 。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
    
16. /***************************************************************************************
    
17. * 2365-2377：SMP系统
    
18. *
    
19. * Pick the destination cpu and if it isn't ours transfer to the
    
20. * target cpu.
    
21. 
    
22.    2370：函数sched_pickcpu为线程td挑选一个合适的cpu，局部变量smp_cpu保存了该
    
23.          cpu的logical cpu id，这里假设为5。
    
24. 
    
25.    2371：函数sched_setcpu主要完成下面的工作：
    
26.          将和线程td相关联的struct td_sched数据对象的ts_cpu成员设置为smp_cpu。
    
27.          并返回logical cpu id为smp_cpu的运行队列，这里假设为&tdq_cpu[5]。
    
28. ***********************************/
    
29.   2365        #ifdef SMP
    
30. 。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
    
31.   2370                smp_cpu = sched_pickcpu(td, flags);
    
32.   2371                tdq = sched_setcpu(td, smp_cpu, flags);
    
33. /************************************************************************
    
34. * 2373-2376：
    
35.    如果smp_cpu和当前cpu的logical cpu id不相等，那么就调用函数
    
36.    tdq_notify检查线程td是否能够抢占当前正在cpu logical id为smp_cpu
    
37.    上运行的线程，如果可以，就发送一个IPI。
    
38. *********************************************************/
    
39.   2373                if (smp_cpu != PCPU_GET(cpuid)) {
    
40.   2374                        tdq_notify(tdq, td);
    
41.   2375                        return;
    
42.   2376                }
    
43. 。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
    
44.   2389        }

复制代码

[摘取函数tdq_notify的部分代码]:

1. /*******************************************************************************
   
2. * Notify a remote cpu of new work.  Sends an IPI if criteria are met.
   
3.    对于logical cpu id为5的cpu，此时参数描述及相应成员的取值如下：
   
4. 
   
5.    参数描述：
   
6. 
   
7.    tdq：为&tdq_cpu[5]。
   
8. 
   
9.    td：已经被添加到运行队列tdq_cpu[5]的tdq_realtime队列，tdq_timeshare队列，
   
10. 
    
11.        tdq_idle队列三个队列之一中的线程。
    
12. 
    
13.    成员取值描述：
    
14.    td->td_sched->ts_cpu的值为5。
    
15. ***************************************************************************/           
    
16.   1011        static void
    
17.   1012        tdq_notify(struct tdq *tdq, struct thread *td)
    
18.   1013        {
    
19. 。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
    
20. /************************************************************
    
21. * 1018-1019：
    
22.    如果struct tdq对象的tdq_ipipending成员非零，表示此时正在
    
23.    发送IPI，此时直接返回。
    
24. *****************************************/
    
25.   1018                if (tdq->tdq_ipipending)
    
26.   1019                        return;
    
27. 。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
    
28. /***************************************************************
    
29. * 如果执行到这里，就表示线程td将抢占线程ctd。
    
30. * 1033：将struct tdq对象的tdq_ipipending成员设置为1。
    
31. 
    
32.    1034：发送类型为IPI_PREEMPT的IPI。
    
33. 
    
34.    变量cpu的值为5。
    
35. ********************************************************/
    
36.   1033                tdq->tdq_ipipending = 1;
    
37.   1034                ipi_cpu(cpu, IPI_PREEMPT)
    
38.   1035        }

复制代码

从上面的描述中可以看出，调用函数ipi_cpu来发送一个IPI，函数ipi_cpu是内核提供的用来发送IPI的接口。

[函数ipi_cpu]：

1. /************************************************************************
   
2. * send an IPI to a specific CPU.
   
3.    参数描述:
   
4. 
   
5.    cpu：接收IPI的cpu的logical cpu id，这里假设为5。
   
6. 
   
7.    ipi：
   
8.    一般情况下为中断向量号。
   
9.    当发送IPI_AST，IPI_PREEMPT，IPI_HARDCLOCK三个特殊的IPI时，对应
   
10.    的不是中断向量号。
    
11. 
    
12.    这里ipi的值为IPI_PREEMPT。
    
13. 
    
14.    该函数实际上是函数ipi_send_cpu的一个简单封装。
    
15. ********************************************/
    
16.   1419        void
    
17.   1420        ipi_cpu(int cpu, u_int ipi)
    
18.   1421        {
    
19.   1422       
    
20. /***********************************************************************
    
21. * IPI_STOP_HARD maps to a NMI and the trap handler needs a bit
    
22. * of help in order to understand what is the source.
    
23. * Set the mask of receiving CPUs for this purpose.
    
24. 
    
25.    1428-1429：
    
26.    #define        IPI_STOP_HARD        252    Stop CPU with a NMI.
    
27.    忽略之间的处理。  
    
28. 
    
29.    1432：ipi_send_cpu函数见下面的描述。                 
    
30. *******************************/
    
31.   1428                if (ipi == IPI_STOP_HARD)
    
32.   1429                        CPU_SET_ATOMIC(cpu, &ipi_nmi_pending);
    
33.   1430       
    
34.   1431                CTR3(KTR_SMP, "%s: cpu: %d ipi: %x", __func__, cpu, ipi);
    
35.   1432                ipi_send_cpu(cpu, ipi);
    
36.   1433        }

复制代码

[函数ipi_send_cpu]：

1. /***************************************************************************************
   
2. * Send an IPI to specified CPU handling the bitmap logic.
   
3. * 参数描述：
   
4. 
   
5.    cpu：接收IPI的cpu的logical cpu id，这里假设为5。   
   
6. 
   
7.    ipi：
   
8.    一般情况下为中断向量号。
   
9.    当发送IPI_AST，IPI_PREEMPT，IPI_HARDCLOCK三个IPI时，对应
   
10.    的不是中断向量号。
    
11. 
    
12.    这里ipi的值为IPI_PREEMPT。
    
13. 
    
14.    函数ipi_send_cpu的任务就是针对IPI_AST，IPI_PREEMPT，IPI_HARDCLOCK三个特殊的IPI
    
15.    做相应的处理。
    
16. ***********************************
    
17.   1190        static void
    
18.   1191        ipi_send_cpu(int cpu, u_int ipi)
    
19.   1192        {
    
20.   1193                u_int bitmap, old_pending, new_pending;
    
21.   1194       
    
22.   1195                KASSERT(cpu_apic_ids[cpu] != -1, ("IPI to non-existent CPU %d", cpu));
    
23. /***********************************************************************************************************
    
24. * 1197-1207：
    
25.    如果发送的是IPI_AST，IPI_PREEMPT，IPI_HARDCLOCK三个特殊的IPI就进行相应的处理。
    
26.    
    
27.    #define        IPI_AST                0        
    
28.    #define      IPI_PREEMPT     1
    
29.    #define      IPI_HARDCLOCK   2
    
30.    #define IPI_BITMAP_LAST IPI_HARDCLOCK  2
    
31.    #define IPI_IS_BITMAPED(x) ((x) <= IPI_BITMAP_LAST)
    
32.    
    
33.    1197：
    
34.    宏IPI_IS_BITMAPED检查ipi是否为IPI_AST或者IPI_PREEMPT或者IPI_HARDCLOCK，如果是，宏的值就为真。
    
35.    这里为IPI_IS_BITMAPED(IPI_PREEMPT)   IPI_PREEMPT <= IPI_BITMAP_LAST，很明显为真。
    
36. 
    
37.    1198：变量bitmap为二进制10。
    
38. 
    
39.    1199：此时重新设置变量ipi，将其设置为IPI_BITMAP_VECTOR，即中断向量号249。
    
40. 
    
41.    由此可以看出，当发送IPI_AST，IPI_PREEMPT，IPI_HARDCLOCK三个特殊的IPI时，实际上发送的IPI的中断向量号
    
42.    都为IPI_BITMAP_VECTOR。
    
43. 
    
44.    1200-1203，do-while循环：
    
45.    1201：old_pending保存的是当前数组元素cpu_ipi_pending[5]的值。
    
46.    1202：new_pending为将要赋值给数组元素cpu_ipi_pending[5]的新值。
    
47. 
    
48.    do_while循环一直执行，直到old_pending和cpu_ipi_pending[cpu]的值相等时为止，此时函数atomic_cmpset_int
    
49.    返回1，数组元素cpu_ipi_pending[cpu]的值被更新为new_pending。
    
50.   
    
51.    因为APIC同时允许有两个挂起的相同中断，freebsd9.2貌似为了预防死锁，一次只允许有一个挂起的中断。
    
52. 
    
53.    1205：如果old_pending非空，表示已经发送了一个中断向量号为IPI_BITMAP_VECTOR的IPI，但是cpu5还没有处理。
    
54.          此时直接返回。
    
55. *************************************************/
    
56.   1197                if (IPI_IS_BITMAPED(ipi)) {
    
57.   1198                        bitmap = 1 << ipi;
    
58.   1199                        ipi = IPI_BITMAP_VECTOR;
    
59.   1200                        do {
    
60.   1201                                old_pending = cpu_ipi_pending[cpu];
    
61.   1202                                new_pending = old_pending | bitmap;
    
62.   1203                        } while  (!atomic_cmpset_int(&cpu_ipi_pending[cpu],
    
63.   1204                            old_pending, new_pending));       
    
64.   1205                        if (old_pending)
    
65.   1206                                return;
    
66.   1207                }
    
67. /**************************************************************
    
68. * 1208：
    
69.    logical cpu id是内核用来标识cpu的，但是发送IPI时，必须使用
    
70.    指定cpu的local APIC ID，这里就要用到数组cpu_apic_ids。
    
71. 
    
72.    数组元素cpu_apic_ids[5]的值为cpu5的local APIC ID。
    
73.    
    
74.    此时，变量ipi已经被正确设置，调用函数lapic_ipi_vectored
    
75.    发送IPI。
    
76. *************************************/
    
77.   1208                lapic_ipi_vectored(ipi, cpu_apic_ids[cpu]);
    
78.   1209        }

复制代码

[函数lapic_ipi_vectored]-该函数构造将要写入到ICR中的值，下面再看看ICR的格式，假设其为0，一般情况下，Reserved
字段的值先读出，然后保证写入原值即可，这里假设Reserved字段的值为0：

1. /***************************************************************************
   
2. * 参数描述：
   
3.    vector：中断向量号，这里为IPI_BITMAP_VECTOR，即中断向量号249。
   
4.    dest：cpu5的local APIC ID，这里假设为X,X为local APIC ID的二进制表示。
   
5. *****************************
   
6.   1441        void
   
7.   1442        lapic_ipi_vectored(u_int vector, int dest)
   
8.   1443        {
   
9. /**********************************************************************
   
10. * icrlo：将要写入ICR低32位的值。
    
11.    destfield：将要写入ICR高32位中Destination Field字段的值。
    
12. 
    
13.    1449-1459：执行完后，icrlo的值为0x000000F9。
    
14. *******************************/
    
15.   1444                register_t icrlo, destfield;
    
16.   1445       
    
17.   1446                KASSERT((vector & ~APIC_VECTOR_MASK) == 0,
    
18.   1447                    ("%s: invalid vector %d", __func__, vector));
    
19.   1448       
    
20.   1449                icrlo = APIC_DESTMODE_PHY | APIC_TRIGMOD_EDGE;
    
21.   1450       
    
22.   1451                /*
    
23.   1452                 * IPI_STOP_HARD is just a "fake" vector used to send a NMI.
    
24.   1453                 * Use special rules regard NMI if passed, otherwise specify
    
25.   1454                 * the vector.
    
26.   1455                 */
    
27.   1456                if (vector == IPI_STOP_HARD)
    
28.   1457                        icrlo |= APIC_DELMODE_NMI | APIC_LEVEL_ASSERT;
    
29.   1458                else
    
30.   1459                        icrlo |= vector | APIC_DELMODE_FIXED | APIC_LEVEL_DEASSERT;
    
31. /******************************************************************************************
    
32. * 因为这里是发送给指定cpu的IPI，所以dest为目的cpu的local APIC ID。
    
33. 
    
34.    1462-1464：IPI的目的地为仅包括发送此IPI的cpu，此时icrlo的值为0x000400F9。
    
35.    1465-1467：IPI的目的地为系统中全部cpu，包括发送此IPI的cpu，此时icrlo的值为0x000800F9。
    
36.    1468-1470：IPI的目的地为系统中除发送此IPI的cpu以外的cpu，此时icrlo的值为0x000C00F9。
    
37.      
    
38.    如果switch语句从上面任意三个case中的一个跳出，destfield的值不变，即为0。
    
39. 
    
40.    针对这里讨论的情况，destfield的值为X，icrlo的值为0x000000F9。   
    
41. ************************************/
    
42.   1460                destfield = 0;
    
43.   1461                switch (dest) {
    
44.   1462                case APIC_IPI_DEST_SELF:
    
45.   1463                        icrlo |= APIC_DEST_SELF;
    
46.   1464                        break;
    
47.   1465                case APIC_IPI_DEST_ALL:
    
48.   1466                        icrlo |= APIC_DEST_ALLISELF;
    
49.   1467                        break;
    
50.   1468                case APIC_IPI_DEST_OTHERS:
    
51.   1469                        icrlo |= APIC_DEST_ALLESELF;
    
52.   1470                        break;
    
53.   1471                default:
    
54.   1472                        KASSERT((dest & ~(APIC_ID_MASK >> APIC_ID_SHIFT)) == 0,
    
55.   1473                            ("%s: invalid destination 0x%x", __func__, dest));
    
56.   1474                        destfield = dest;
    
57.   1475                }
    
58.   1476       
    
59. /*****************************************************************************************************
    
60. * Wait for an earlier IPI to finish，检查是否有更早的IPI没有完成发送。
    
61.    #define        BEFORE_SPIN        1000000
    
62.    
    
63.    ICR的字段Delivery Status：指示IPI的发送状态。0：IPI已经成功发送出去；1：还没有完成IPI的发送。
    
64. 
    
65.    函数lapic_ipi_wait执行一个for循环，不停的测试Delivery Status字段的值，如果在指定的时间内，该
    
66.    字段的值变为0，就返回1；否则返回0，表示出现了某种问题。
    
67. 
    
68.    这个指定的时间为BEFORE_SPIN * (指令pause的时钟周期数)。
    
69. *******************************************/
    
70.   1478                if (!lapic_ipi_wait(BEFORE_SPIN)) {
    
71.   1479                        if (panicstr != NULL)
    
72.   1480                                return;
    
73.   1481                        else
    
74.   1482                                panic("APIC: Previous IPI is stuck");
    
75.   1483                }
    
76. /*****************************************************************************************************
    
77. * 1485：
    
78.    函数lapic_ipi_raw完成IPI的发送，见下面的描述。
    
79. ***********************/
    
80.   1485                lapic_ipi_raw(icrlo, destfield);
    
81. /*************************************************************************
    
82. * 执行到这里的话，IPI的发送已经完成。
    
83. *
    
84. * 1487-1512之间的代码只有在定义了DETECT_DEADLOCK才有意义，在有意义的
    
85.    情况下，就是检查一下此次发送的IPI是否完成发送。
    
86. ***************************************/
    
87.   1487        #ifdef DETECT_DEADLOCK
    
88.   1488                /* Wait for IPI to be delivered. */ #define        AFTER_SPIN        1000
    
89.   1489                if (!lapic_ipi_wait(AFTER_SPIN)) {
    
90.   1490        #ifdef needsattention
    
91.   1491                        /*
    
92.   1492                         * XXX FIXME:
    
93.   1493                         *
    
94.   1494                         * The above function waits for the message to actually be
    
95.   1495                         * delivered.  It breaks out after an arbitrary timeout
    
96.   1496                         * since the message should eventually be delivered (at
    
97.   1497                         * least in theory) and that if it wasn't we would catch
    
98.   1498                         * the failure with the check above when the next IPI is
    
99.   1499                         * sent.
    
100.   1500                         *
     
101.   1501                         * We could skip this wait entirely, EXCEPT it probably
     
102.   1502                         * protects us from other routines that assume that the
     
103.   1503                         * message was delivered and acted upon when this function
     
104.   1504                         * returns.
     
105.   1505                         */
     
106.   1506                        printf("APIC: IPI might be stuck\n");
     
107.   1507        #else /* !needsattention */
     
108.   1508                        /* Wait until mesage is sent without a timeout. */
     
109.   1509                        while (lapic->icr_lo & APIC_DELSTAT_PEND)
     
110.   1510                                ia32_pause();
     
111.   1511        #endif /* needsattention */
     
112.   1512                }
     
113.   1513        #endif /* DETECT_DEADLOCK */
     
114.   1514        }

复制代码

[函数lapic_ipi_raw]：

1. /************************************************************************************
   
2. * 参数描述：
   
3.   
   
4.    icrlo：将要写到ICR低32位的值，针对这里讨论的情况，值为0x000000F9。
   
5.    
   
6.    dest：目的cpu的local APIC ID或者为0，针对这里讨论的情况，值为X。
   
7. *************************/
   
8.   1407        void
   
9.   1408        lapic_ipi_raw(register_t icrlo, u_int dest)
   
10.   1409        {
    
11.   1410                register_t value, saveintr;
    
12.   1411       
    
13.   1412                /* XXX: Need more sanity checking of icrlo? */
    
14.   1413                KASSERT(lapic != NULL, ("%s called too early", __func__));
    
15.   1414                KASSERT((dest & ~(APIC_ID_MASK >> APIC_ID_SHIFT)) == 0,
    
16.   1415                    ("%s: invalid dest field", __func__));
    
17.   1416                KASSERT((icrlo & APIC_ICRLO_RESV_MASK) == 0,
    
18.   1417                    ("%s: reserved bits set in ICR LO register", __func__));
    
19.   1418       
    
20. /***********************************************************************************
    
21. * Set destination in ICR HI register if it is being used.
    
22. 
    
23.    1420：函数intr_disable将当前EFLAGS寄存器的值保存到变量中saveintr，之后清
    
24.          EFLAGS寄存器的IF标志，表示此时禁止中断。
    
25.    
    
26.    针对这里讨论的情况，将执行1421-1426之间的语句。
    
27. 
    
28.    变量lapic请参考"内核如何实现IA32中断处理"中的描述。
    
29. 
    
30.    通过变量lapic访问cpu5的local APIC寄存器组：
    
31.    lapic->icr_hi：访问ICR高32位。
    
32.    
    
33.    1422-1425：ICR高32位中的bit24-31被设置为X，bit0-23保持原来的值。
    
34.      
    
35.    执行完后ICR中Destination Field字段的值为X，即这个IPI将发送给cpu5。
    
36. ******************************************/
    
37.   1420                saveintr = intr_disable();
    
38.   1421                if ((icrlo & APIC_DEST_MASK) == APIC_DEST_DESTFLD) {
    
39.   1422                        value = lapic->icr_hi;
    
40.   1423                        value &= ~APIC_ID_MASK;
    
41.   1424                        value |= dest << APIC_ID_SHIFT;
    
42.   1425                        lapic->icr_hi = value;
    
43.   1426                }
    
44. /******************************************************************************************
    
45. * 通过变量lapic访问cpu5的local APIC寄存器组：
    
46.    lapic->icr_lo：访问ICR低32位。
    
47. 
    
48.    1429-1431：执行完后，value的值为0x000000F9。
    
49. 
    
50.    1432：这个赋值操作就相当于对ICR低32位执行了一个写操作，ICR的Vector字段的值为0xF9。
    
51.          
    
52.    此时，已经向cpu5发出了一个IPI，该IPI的中断向量号为IPI_BITMAP_VECTOR，当cpu5
    
53.    接收到这个中断时，就按照"内核如何实现IA32中断处理"中最后描述的中断处理机制进行处理。     
    
54. 
    
55.    1432：用saveintr恢复EFLAGS寄存器。
    
56. ****************************************/          
    
57.   1428                /* Program the contents of the IPI and dispatch it. */
    
58.   1429                value = lapic->icr_lo;
    
59.   1430                value &= APIC_ICRLO_RESV_MASK;
    
60.   1431                value |= icrlo;
    
61.   1432                lapic->icr_lo = value;
    
62.   1433                intr_restore(saveintr);
    
63.   1434        }

复制代码