[Understanding] Why does my spin_lock_irqsave () Fail to lock the clock?

LZ:

 

I tried to use spin_lock_irqsave () and found that no clock interruption was disabled. I don't know where I got it wrong?
Kernel version:

1. Uname-a result:
3. Linux localhost. localdomain 2.6.18 #1 sat Jul 19 13:06:00 EDT 2008 i686 i686 i386 GNU/Linux

Copy code

My code:

1. # Include <Linux/kernel. h>
2. # Include <Linux/init. h>
3. # Include <Linux/module. h>
4. # Include <Linux/spinlock. h>
6. Static spinlock_t my_spinlock;
8. Static int _ init init_test ()
9. {
10. Unsigned long flags;
12. Spin_lock_init (& my_spinlock );
14. Spin_lock_irqsave (& my_spinlock, flags );
15. Return 0;
16. }
18. Static void _ exit init_exit ()
19. {
20. Return;
21. }
23. Module_init (init_test );
24. Module_exit (init_exit );

Copy code

After the module is loaded, run the following command to view the Wall Clock:

1. # Date; sleep 2; Date
3. Output result:
4. Sun Apr 19 12:59:42 EDT 2009
5. Sun Apr 19 12:59:44 EDT 2009

Copy code

The clock on the wall is still changing, indicating that the clock interruption is not disabled.
But I understand that spin_lock_irqsave () will turn off all IRQ through CLI, and I do not have the spin_unlock_irqrestore () in the module, so after loading this module, the system will not respond to any external blocked interruptions. However, this is not the actual result.

Where did I get it wrong? Thank you for your advice!

 

 

Answer:

Write a section of the kernel module and userspace program to verify:

Kernel module: my_spin_lock.c

1. # Include <Linux/kernel. h>
2. # Include <Linux/init. h>
3. # Include <Linux/module. h>
4. # Include <Linux/spinlock. h>
6. # Define if_mask 0x00000200
8. Static spinlock_t my_spinlock;
10. Static unsigned int is_interrupt_enable ()
11. {
12. Unsigned long my_eflags;
13. ASM volatile ("pushfl/n/t"
14. "Popl % 0"
15. : "= A" (my_eflags ));
17. Return (my_eflags & if_mask) = 0 )? 0: 1 );
18. }
20. Static int _ init init_test ()
21. {
22. Unsigned long flags;
23. Spin_lock_init (& my_spinlock );
25. Spin_lock_irqsave (& my_spinlock, flags );
26. Printk ("from kernelspace init: interrupt was enable: % d/N", is_interrupt_enable ());
27. Return 0;
28. }
30. Static void _ exit init_exit ()
31. {
32. Return;
33. }
35. Module_license ("GPL ");
36. Module_init (init_test );
37. Module_exit (init_exit );

Copy code

Generate my_spin_lock.ko after compilation

Then write a userspace program: Test. C.

1. # Include <stdio. h>
2. # Include <stdlib. h>
4. # Define if_mask 0x00000200
5. # Define pai_len 100
7. Unsigned int is_interrupt_enable ()
8. {
9. Unsigned long my_eflags;
11. ASM volatile ("pushfl/n/t"
12. "Popl % 0/n/t"
13. : "= A" (my_eflags ));
15. Return (my_eflags & if_mask) = 0 )? 0: 1 );
16. }
18. Int main (INT argc, char * argv [])
19. {
20. If (argc! = 2)
21. {
22. Printf ("usersage: insmod your_kernel_module/N ");
23. Return 0;
24. }
25. Char cmd [cmd_len];
27. Memset (CMD, 0, sizeof (CMD ));
28. Sprintf (CMD, "insmod % s", argv [1]);
30. Printf ("from userspace, before insmod, inerrput is enable: % d/N", is_interrupt_enable ());
31. System (CMD);/* insmod kernel module */
32. Printf ("from userspace, after insmod, interrupt is enable: % d/N", is_interrupt_enable ());
35. Memset (CMD, 0, sizeof (CMD ));
36. Sprintf (CMD, "rmmod % s", argv [1]);
37. System (CMD);/* rmmod kernel module */
40. Return 0;
41. }

Copy code

Generate the test binary file after compilation

Run the following command:

1. ./Test my_spin_lock.ko

Copy code

Running result:

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

It can be seen that interrupt is indeed disabled after the init function of the kernel module is run. Then return to the user State. Interrupt is enabled.