smp_lock.h 1.4 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152
  1. #ifndef __LINUX_SMPLOCK_H
  2. #define __LINUX_SMPLOCK_H
  3. #ifdef CONFIG_LOCK_KERNEL
  4. #include <linux/sched.h>
  5. #include <linux/spinlock.h>
  6. #define kernel_locked() (current->lock_depth >= 0)
  7. extern int __lockfunc __reacquire_kernel_lock(void);
  8. extern void __lockfunc __release_kernel_lock(void);
  9. /*
  10. * Release/re-acquire global kernel lock for the scheduler
  11. */
  12. #define release_kernel_lock(tsk) do { \
  13. if (unlikely((tsk)->lock_depth >= 0)) \
  14. __release_kernel_lock(); \
  15. } while (0)
  16. /*
  17. * Non-SMP kernels will never block on the kernel lock,
  18. * so we are better off returning a constant zero from
  19. * reacquire_kernel_lock() so that the compiler can see
  20. * it at compile-time.
  21. */
  22. #if defined(CONFIG_SMP) && !defined(CONFIG_PREEMPT_BKL)
  23. # define return_value_on_smp return
  24. #else
  25. # define return_value_on_smp
  26. #endif
  27. static inline int reacquire_kernel_lock(struct task_struct *task)
  28. {
  29. if (unlikely(task->lock_depth >= 0))
  30. return_value_on_smp __reacquire_kernel_lock();
  31. return 0;
  32. }
  33. extern void __lockfunc lock_kernel(void) __acquires(kernel_lock);
  34. extern void __lockfunc unlock_kernel(void) __releases(kernel_lock);
  35. #else
  36. #define lock_kernel() do { } while(0)
  37. #define unlock_kernel() do { } while(0)
  38. #define release_kernel_lock(task) do { } while(0)
  39. #define reacquire_kernel_lock(task) 0
  40. #define kernel_locked() 1
  41. #endif /* CONFIG_LOCK_KERNEL */
  42. #endif /* __LINUX_SMPLOCK_H */