为什么我的spin_lock_irqsave()没有锁住时钟中断？

epegasus

原帖由 eexplorer 于 2009-4-21 22:58 发表
终于想到原因了

由于load module是通过系统调用实现的，当运行完mod->init()后，会从kernel space返回到user space。这时会将所有的寄存器恢复到系统调用前的状态，也就是insmod 进程调用sys_init_module之 ...

我有新的问题.
i386下cli指令是修改IF标志来达到屏蔽中断的目的.
在local_irq_save()和2.4的cli()中都是用的cli指令.
那为什么<lkd2>中断一章说,
"以前的内核中提供一种能够禁止系统中所有处理器的中断的方法,这个函数就是cli()".
那cli指令怎么能实现关所有处理器中断呢?

还有就是可能是新的处理器引入的VIF标志做什么用?

new_learner

原帖由 epegasus 于 2009-4-22 09:32 发表



我有新的问题.
i386下cli指令是修改IF标志来达到屏蔽中断的目的.
在local_irq_save()和2.4的cli()中都是用的cli指令.
那为什么中断一章说,
"以前的内核中提供一种能够禁止系统中所有处理器 ...

这个cli()函数是怎么实现的呢？有代码吗？

epegasus

原帖由 new_learner 于 2009-4-22 09:55 发表


这个cli()函数是怎么实现的呢？有代码吗？

2.4中,\include\asm-i386\system.h
#define __cli()                 __asm__ __volatile__("cli": : :"memory")
#define __sti()                        __asm__ __volatile__("sti": : :"memory")

intel 2a 卷

If protected-mode virtual interrupts are not enabled, CLI clears the IF flag in the
EFLAGS register. No other flags are affected. Clearing the IF flag causes the
processor to ignore maskable external interrupts. The IF flag and the CLI and STI
instruction have no affect on the generation of exceptions and NMI interrupts.
When protected-mode virtual interrupts are enabled, CPL is 3, and IOPL is less than
3; CLI clears the VIF flag in the EFLAGS register, leaving IF unaffected. Table 3-6 indi-
cates the action of the CLI instruction depending on the processor operating mode
and the CPL/IOPL of the running program or procedure.

mcemil

protected-mode virtual interrupts是个什么概念，做什么用的

eexplorer

> 2.4中,\include\asm-i386\system.h
> #define __cli()                 __asm__ __volatile__("cli": : :"memory")
> #define __sti()                        __asm__ __volatile__("sti": : :"memory")

这个是UP的定义，SMP的定义是＃define cli() __global_cli()

VIF，不太清楚，已经很久没看intel的手册了。是不是和virtualization相关？

new_learner

原帖由 new_learner 于 2009-4-21 23:24 发表

感觉有道理。。。。
多谢！
明天我再验证一下：）

写了一段kernel module和 userspace program来验证：

kernel module: my_spin_lock.c

1. 
   
2. #include <linux/kernel.h>
   
3. #include <linux/init.h>
   
4. #include <linux/module.h>
   
5. #include <linux/spinlock.h>
   
6. 
   
7. #define IF_MASK 0x00000200
   
8. 
   
9. static spinlock_t my_spinlock;
   
10. 
    
11. static unsigned int is_interrupt_enable()
    
12. {
    
13.         unsigned long my_eflags;
    
14.         asm volatile ("pushfl \n\t"
    
15.         "popl %0"
    
16.         :"=a"(my_eflags));
    
17. 
    
18.         return (((my_eflags & IF_MASK) == 0) ? 0 : 1);
    
19. }
    
20. 
    
21. static int __init init_test()
    
22. {
    
23.         unsigned long flags;
    
24.         spin_lock_init(&my_spinlock);
    
25. 
    
26.         spin_lock_irqsave(&my_spinlock, flags);
    
27.         printk("from kernelspace init: interrupt was enable : %d\n", is_interrupt_enable());
    
28.         return 0;
    
29. }
    
30. 
    
31. static void __exit init_exit()
    
32. {
    
33.         return;
    
34. }
    
35. 
    
36. MODULE_LICENSE("GPL");
    
37. module_init(init_test);
    
38. module_exit(init_exit);
    

复制代码

编译以后生成my_spin_lock.ko

然后再写一段userspace program : test.c

1. 
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   
4. 
   
5. #define IF_MASK 0x00000200
   
6. #define CMD_LEN 100
   
7. 
   
8. unsigned int is_interrupt_enable()
   
9. {
   
10.         unsigned long my_eflags;
    
11. 
    
12.         asm volatile ("pushfl \n\t"
    
13.         "popl %0 \n\t"
    
14.         :"=a"(my_eflags));
    
15.        
    
16.         return (((my_eflags & IF_MASK) == 0) ? 0 : 1);
    
17. }
    
18. 
    
19. int main (int argc, char *argv[])
    
20. {
    
21.         if (argc != 2)
    
22.         {
    
23.                 printf("usersage: insmod your_kernel_module\n");
    
24.                 return 0;       
    
25.         }
    
26.         char cmd[CMD_LEN];
    
27. 
    
28.         memset(cmd, 0, sizeof(cmd));
    
29.         sprintf(cmd, "insmod %s", argv[1]);
    
30. 
    
31.         printf("from userspace, before insmod, inerrput is enable : %d\n", is_interrupt_enable());
    
32.         system(cmd); /*insmod kernel module*/
    
33.         printf("from userspace, after insmod, interrupt is enable : %d\n", is_interrupt_enable());       
    
34. 
    
35. 
    
36.         memset(cmd, 0, sizeof(cmd));
    
37.         sprintf(cmd, "rmmod %s", argv[1]);
    
38.         system(cmd); /*rmmod kernel module*/
    
39.        
    
40.        
    
41.         return 0;
    
42. }
    

复制代码

编译以后生成test二进制文件

然后下命令：

1. 
   
2. ./test my_spin_lock.ko
   

复制代码

运行结果:

from userspace, before insmod, interrupt is enable : 1
from kernelspace init: interrupt was enable : 0
from userspace, after insmod, interrupt is enable: 1

可见，运行了kernel module的init函数以后，interrupt确实被禁止了。然后返回到用户态，interrupt被打开了。

[ 本帖最后由 new_learner 于 2009-4-22 16:22 编辑 ]

peimichael

原帖由 eexplorer 于 2009-4-21 22:58 发表
终于想到原因了

由于load module是通过系统调用实现的，当运行完mod->init()后，会从kernel space返回到user space。这时会将所有的寄存器恢复到系统调用前的状态，也就是insmod 进程调用sys_init_module之 ...

恩，觉得这个有道理
在我之前有人用了loca_irq_save禁了中断，我又禁用了一次中断，
后来虽然我没有开中断，但是前面那个人开启了中断，
最后中断还是打开的

而“前面那个人”有可能是外层调用local_irq_save的函数
也有可能是通过陷阱门进出内核空间时保存恢复eflags这个动作。

是这么个意思么

new_learner

原帖由 peimichael 于 2009-4-22 16:29 发表


恩，觉得这个有道理
在我之前有人用了loca_irq_save禁了中断，我又禁用了一次中断，
后来虽然我没有开中断，但是前面那个人开启了中断，
最后中断还是打开的

而“前面那个人”有可能是外层调用local_ ...

1.关中断不会嵌套
不论前面连续关多少次，后面只要开一次就行了。

2.在我实验的例子里，就是这个意思。

eexplorer

原帖由 new_learner 于 2009-4-22 16:18 发表


写了一段kernel module和 userspace program来验证：

kernel module: my_spin_lock.c

#include
#include
#include
#include

#define IF_MASK 0x00000200

static spinlock_t my_spinlock ...

LZ的学习激情很高啊，觉得自己老了，很懒，学什么都提不起劲了。。。

new_learner

原帖由 eexplorer 于 2009-4-22 16:46 发表


LZ的学习激情很高啊，觉得自己老了，很懒，学什么都提不起劲了。。。

偶太菜了，啥都不懂，当然要多学学了。。。^_^
有问题请您多指教啊：）