谁能解释一下，自旋锁spinlock

帅绝人寰

原帖由 Alligator27 于 2005-11-4 11:38 发表

我没说有问提啊. 写这个程序是想说. 用户可以有spinlock. 能达到内核一样的互斥, 而且不会锁死系统.

我详细说一下吧，别烦哦

还是说起，什么 叫“自旋”。 自旋的意思就是，当加锁不能成功时，死活都在占据着CPU一直尝试，直到成功才肯返回。
它跟信号量有什么区别？ 信号量down不成功的话，好，谁执行down的？你睡觉去！ -于是，调用down而不能成功的线程睡觉去了。
再看自旋锁。为什么要引入自旋锁？有人问道，“用信号量不行吗？信号量不会一直占据cpu尝试，还能节省资源。” ──很有道理，但是忘记了一点：有些情况不允许睡眠。 比方说中断ISR。ISR中，谁要是调用了sechudle()这种函数让出了cpu，整个系统直接崩溃。为什么？因为中断没有自己的“做为任务的状态”，没有TSS，没有栈，一贫如洗。一旦你把中断切走了，永远都别想再能切回来了。       看到了吗？这时候，我们就需要死活都不能放弃CPU，不管对系统性能有多大消耗，所以要用自旋锁。

用户空间的进程间同步/互斥必需依附于某种独力于进程的东西，比方信号量，pthread_mutex等。 自旋锁，我依然觉得在用户态不可能。 没有哪个OS会允许用户进程轻易地独占CPU。

帅绝人寰

我说的特权是说那种只允许RING0级别的代码调用该指令的。 比方说，用户态执行hlt就不行，不可能做到停机效果。

yjqyml

讨论的好精彩哦。。。不过没大看懂~~
既然程序都通过了。那么帅帅怎么还说不能在用户状态。。。

帅绝人寰

原帖由 yjqyml 于 2005-11-4 12:02 发表
讨论的好精彩哦。。。不过没大看懂~~
既然程序都通过了。那么帅帅怎么还说不能在用户状态。。。

用户态执行“lock；……”虽然没有出现General Protection Exception(或者其他异常)，但是并没有达到自旋效果。
真正的自旋，除了中断谁都不响应，而且即使是中断，中断返回时也还是必然返回到自旋的那段代码，继续自旋。

然而鳄鱼兄这段程序用普通的SIGTERM都能杀掉，说明没有自旋。

帅绝人寰

谁要是感兴趣，试试写个内核模块，自旋一下看看是什么效果。两次调用spin_lock就可以了。

gvim

1. 
   
2. LOCK - Lock Bus
   
3.         Usage:  LOCK
   
4.                 LOCK: (386+ prefix)
   
5.         Modifies flags: None
   
6.         This instruction is a prefix that causes the CPU assert bus lock
   
7.         signal during the execution of the next instruction.  Used to
   
8.         avoid two processors from updating the same data location.  The
   
9.         286 always asserts lock during an XCHG with memory operands.  This
   
10.         should only be used to lock the bus prior to XCHG, MOV, IN and
    
11. 
    
12.         OUT instructions.
    
13.                                  Clocks                 Size
    
14.         Operands         808x  286   386   486          Bytes
    
15.         none              2     0     0     1             1
    
16. 
    
17.         F0 LOCK Asserts LOCK# signal
    

复制代码

gvim

也就是

1. 
   
2. for(;;)
   
3. {
   
4.     if (lock success)
   
5.      lock & out;
   
6.    else
   
7.        test & continue;
   
8. }
   

复制代码

bleem1998

原帖由 帅绝人寰 于 2005-11-4 12:08 发表
谁要是感兴趣，试试写个内核模块，自旋一下看看是什么效果。两次调用spin_lock就可以了。

写了两个模块来验证好像不对阿
其中一个定义并初始化变量ll并且EXPORT它
另一个模块直接使用ll变量进行spin_lock(&ll)
可并没有死锁阿。。。
是不是我写的不对

hello.c

1. 
   
2. #include <linux/module.h>
   
3. #include <linux/kernel.h>
   
4. #include <linux/spinlock.h>
   
5. 
   
6. spinlock_t       ll;
   
7. EXPORT_SYMBOL(ll);
   
8. int init_module(void)
   
9. {
   
10.     printk("hello1\n");
    
11.         spin_lock_init(&ll);
    
12.     printk("hello2\n");
    
13.         spin_lock(&ll);
    
14.     printk("hello3\n");
    
15.         spin_lock(&ll);
    
16.     printk("hello4\n");
    
17.         return 0;
    
18. }
    
19. 
    
20. void cleanup_module(void)
    
21. {
    
22.         printk("hello over\n");
    
23.         return;
    
24. }
    

复制代码

Makefile

1. 
   
2. # cat Makefile
   
3. obj-m := hello.o
   
4. KDIR=/lib/modules/2.6.11.4-20a-default/build
   
5. PWD=/root/code/ldd/hello
   
6. default:
   
7.         $(MAKE) -C $(KDIR) SUBDIRS=$(PWD) modules
   
8. l:
   
9.         insmod hello.ko
   
10. u:
    
11.         rmmod hello
    
12. clean:
    
13.         rm hello.o hello.ko hello.mod.c hello.mod.o 2>/dev/null
    

复制代码

[ 本帖最后由 bleem1998 于 2005-11-4 13:57 编辑 ]

帅绝人寰

>>    printk("hello2\n");
>>        spin_lock(&ll);
>>    printk("hello3\n");
>>        spin_lock(&ll);

这4句代码执行了，还不死锁？？？ 除非你机器有SMP Watchdog之类的检查死锁的东西，否则就神了。

bleem1998

执行了
大家都跑的很欢畅
两个模块都直接打印hello1到hello4
啥反应都么有
so 奇怪