kernel/lglock.c

   1 /* See include/linux/lglock.h for description */
   2 #include <linux/module.h>
   3 #include <linux/lglock.h>
   4
   5 void lg_lock_init(struct lglock *lg, char *name)
   6 {
   7         LOCKDEP_INIT_MAP(&lg->lock_dep_map, name, &lg->lock_key, 0);
   8 }
   9 EXPORT_SYMBOL(lg_lock_init);
  10
  11 void lg_local_lock(struct lglock *lg)
  12 {
  13         arch_spinlock_t *lock;
  14         preempt_disable();
  15         rwlock_acquire_read(&lg->lock_dep_map, 0, 0, _RET_IP_);
  16         lock = this_cpu_ptr(lg->lock);
  17         arch_spin_lock(lock);
  18 }
  19 EXPORT_SYMBOL(lg_local_lock);
  20
  21 void lg_local_unlock(struct lglock *lg)
  22 {
  23         arch_spinlock_t *lock;
  24         rwlock_release(&lg->lock_dep_map, 1, _RET_IP_);
  25         lock = this_cpu_ptr(lg->lock);
  26         arch_spin_unlock(lock);
  27         preempt_enable();
  28 }
  29 EXPORT_SYMBOL(lg_local_unlock);
  30
  31 void lg_local_lock_cpu(struct lglock *lg, int cpu)
  32 {
  33         arch_spinlock_t *lock;
  34         preempt_disable();
  35         rwlock_acquire_read(&lg->lock_dep_map, 0, 0, _RET_IP_);
  36         lock = per_cpu_ptr(lg->lock, cpu);
  37         arch_spin_lock(lock);
  38 }
  39 EXPORT_SYMBOL(lg_local_lock_cpu);
  40
  41 void lg_local_unlock_cpu(struct lglock *lg, int cpu)
  42 {
  43         arch_spinlock_t *lock;
  44         rwlock_release(&lg->lock_dep_map, 1, _RET_IP_);
  45         lock = per_cpu_ptr(lg->lock, cpu);
  46         arch_spin_unlock(lock);
  47         preempt_enable();
  48 }
  49 EXPORT_SYMBOL(lg_local_unlock_cpu);
  50
  51 void lg_global_lock_online(struct lglock *lg)
  52 {
  53         int i;
  54         preempt_disable();
  55         rwlock_acquire(&lg->lock_dep_map, 0, 0, _RET_IP_);
  56         for_each_online_cpu(i) {
  57                 arch_spinlock_t *lock;
  58                 lock = per_cpu_ptr(lg->lock, i);
  59                 arch_spin_lock(lock);
  60         }
  61 }
  62 EXPORT_SYMBOL(lg_global_lock_online);
  63
  64 void lg_global_unlock_online(struct lglock *lg)
  65 {
  66         int i;
  67         rwlock_release(&lg->lock_dep_map, 1, _RET_IP_);
  68         for_each_online_cpu(i) {
  69                 arch_spinlock_t *lock;
  70                 lock = per_cpu_ptr(lg->lock, i);
  71                 arch_spin_unlock(lock);
  72         }
  73         preempt_enable();
  74 }
  75 EXPORT_SYMBOL(lg_global_unlock_online);
  76
  77 void lg_global_lock(struct lglock *lg)
  78 {
  79         int i;
  80         preempt_disable();
  81         rwlock_acquire(&lg->lock_dep_map, 0, 0, _RET_IP_);
  82         for_each_possible_cpu(i) {
  83                 arch_spinlock_t *lock;
  84                 lock = per_cpu_ptr(lg->lock, i);
  85                 arch_spin_lock(lock);
  86         }
  87 }
  88 EXPORT_SYMBOL(lg_global_lock);
  89
  90 void lg_global_unlock(struct lglock *lg)
  91 {
  92         int i;
  93         rwlock_release(&lg->lock_dep_map, 1, _RET_IP_);
  94         for_each_possible_cpu(i) {
  95                 arch_spinlock_t *lock;
  96                 lock = per_cpu_ptr(lg->lock, i);
  97                 arch_spin_unlock(lock);
  98         }
  99         preempt_enable();
 100 }
 101 EXPORT_SYMBOL(lg_global_unlock);