Lines Matching defs:lock

60  *   anything - not even acquiring a lock or dropping a refcount.

105     spinlock_t lock;                /* spinlock for fine-grained semtimedop */

124     unsigned int use_global_lock;   /* >0: global lock required */

164     spinlock_t lock;

199  *    * undo_list->lock for write

278  * It must be called prior to dropping the global semaphore array lock.

333  * Caller must own sem_perm.lock.

342          * We are already in global lock mode.

353         spin_lock(&sem->lock);

354         spin_unlock(&sem->lock);

360  * Caller must own sem_perm.lock.

381  * no complex transactions pending, lock only the semaphore involved.

382  * Otherwise, lock the entire semaphore array, since we either have

392         /* Complex operation - acquire a full lock */

417          * Acquire the per-semaphore lock.

419         spin_lock(&sem->lock);

426         spin_unlock(&sem->lock);

429     /* slow path: acquire the full lock */

435          * sma->sem_perm.lock. Thus we must switch to locking

436          * with sem->lock.

438          * sma->use_global_lock after we have acquired sem->lock:

439          * We own sma->sem_perm.lock, thus use_global_lock cannot

442         spin_lock(&sem->lock);

448          * Not a false alarm, thus continue to use the global lock

464         spin_unlock(&sem->lock);

472  * The caller holds the RCU read lock.

564         spin_lock_init(&sma->sems[i].lock);

1182         spin_lock(&un->ulp->lock);

1185         spin_unlock(&un->ulp->lock);

1901         spin_lock_init(&undo_list->lock);

1915     list_for_each_entry_rcu(un, &ulp->list_proc, list_proc, spin_is_locked(&ulp->lock))

1928     assert_spin_locked(&ulp->lock);

1962     spin_lock(&ulp->lock);

1964     spin_unlock(&ulp->lock);

1992     /* step 3: Acquire the lock on semaphore array */

2002     spin_lock(&ulp->lock);

2016     assert_spin_locked(&ulp->lock);

2023     spin_unlock(&ulp->lock);

2137      * If nsops == 1 and there is no contention for sem_perm.lock, then

2138      * only a per-semaphore lock is held and it's OK to proceed with the

2221         /* memory ordering ensured by the lock in sem_lock() */

2225         /* memory ordering is ensured by the lock in sem_lock() */

2405             spin_lock(&ulp->lock);

2406             spin_unlock(&ulp->lock);

2410         spin_lock(&ulp->lock);

2412         spin_unlock(&ulp->lock);

2448         spin_lock(&ulp->lock);

2450         spin_unlock(&ulp->lock);