| /linux-6.15/include/linux/ |
| D | ww_mutex.h | 119 * ww_acquire_init - initialize a w/w acquire context
120 * @ctx: w/w acquire context to initialize
123 * Initializes an context to acquire multiple mutexes of the given w/w class.
135 * Nesting of acquire contexts for _different_ w/w classes is possible, subject
138 * An acquire context must be released with ww_acquire_fini by the same task
171 * ww_acquire_done - marks the end of the acquire phase
172 * @ctx: the acquire context
174 * Marks the end of the acquire phase, any further w/w mutex lock calls using
178 * code and clearly designated the acquire phase from actually using the locked
192 * ww_acquire_fini - releases a w/w acquire context
[all …]
|
| D | local_lock.h | 13 * local_lock - Acquire a per CPU local lock
19 * local_lock_irq - Acquire a per CPU local lock and disable interrupts
25 * local_lock_irqsave - Acquire a per CPU local lock, save and disable
60 * local_trylock - Try to acquire a per CPU local lock
64 * locking constrains it will _always_ fail to acquire the lock in NMI or
70 * local_trylock_irqsave - Try to acquire a per CPU local lock, save and disable
76 * locking constrains it will _always_ fail to acquire the lock in NMI or
|
| D | atomic.h | 16 * - Acquire: Provides ACQUIRE semantics, _acquire suffix.
20 * For compound atomics performing both a load and a store, ACQUIRE
25 * See Documentation/memory-barriers.txt for ACQUIRE/RELEASE definitions.
35 * The idea here is to build acquire/release variants by adding explicit
|
| D | refcount.h | 69 * its the lock acquire, for RCU/lockless data structures its the dependent
74 * if we did not in fact acquire a reference.
87 * The decrements dec_and_test() and sub_and_test() also provide acquire
91 * acquire and release ordering for cases when the memory occupied by the
95 * the refcount is taken, hence acquire order is necessary. Similarly, when the
254 * refcount_add_not_zero_acquire - add a value to a refcount with acquire ordering unless it is 0
264 * Provides acquire memory ordering on success, it is assumed the caller has
344 * refcount_inc_not_zero_acquire - increment a refcount with acquire ordering unless it is 0
347 * Similar to refcount_inc_not_zero(), but provides acquire memory ordering on
353 * Provides acquire memory ordering on success, it is assumed the caller has
[all …]
|
| /linux-6.15/tools/memory-model/ |
| D | linux-kernel.def | 12 // Release Acquire and friends
14 smp_load_acquire(X) __load{ACQUIRE}(*X)
34 xchg_acquire(X,V) __xchg{ACQUIRE}(X,V)
37 cmpxchg_acquire(X,V,W) __cmpxchg{ACQUIRE}(X,V,W)
77 atomic_add_return_acquire(V,X) __atomic_op_return{ACQUIRE}(X,+,V)
81 atomic_fetch_add_acquire(V,X) __atomic_fetch_op{ACQUIRE}(X,+,V)
86 atomic_fetch_and_acquire(V,X) __atomic_fetch_op{ACQUIRE}(X,&,V)
91 atomic_fetch_or_acquire(V,X) __atomic_fetch_op{ACQUIRE}(X,|,V)
96 atomic_fetch_xor_acquire(V,X) __atomic_fetch_op{ACQUIRE}(X,^,V)
101 atomic_inc_return_acquire(X) __atomic_op_return{ACQUIRE}(X,+,1)
[all …]
|
| /linux-6.15/tools/testing/selftests/bpf/progs/ |
| D | verifier_load_acquire.c | 12 __description("load-acquire, 8-bit")
28 __description("load-acquire, 16-bit")
44 __description("load-acquire, 32-bit")
60 __description("load-acquire, 64-bit")
76 __description("load-acquire with uninitialized src_reg")
90 __description("load-acquire with non-pointer src_reg")
105 __description("misaligned load-acquire")
122 __description("load-acquire from ctx pointer")
136 __description("load-acquire from pkt pointer")
158 __description("load-acquire from flow_keys pointer")
[all …]
|
| /linux-6.15/kernel/locking/ |
| D | semaphore.c | 23 * The ->count variable represents how many more tasks can acquire this
45 * down - acquire the semaphore
48 * Acquires the semaphore. If no more tasks are allowed to acquire the
70 * down_interruptible - acquire the semaphore unless interrupted
73 * Attempts to acquire the semaphore. If no more tasks are allowed to
74 * acquire the semaphore, calling this function will put the task to sleep.
96 * down_killable - acquire the semaphore unless killed
99 * Attempts to acquire the semaphore. If no more tasks are allowed to
100 * acquire the semaphore, calling this function will put the task to sleep.
123 * down_trylock - try to acquire the semaphore, without waiting
[all …]
|
| D | mcs_spinlock.h | 9 * to acquire the lock spinning on a local variable.
20 * Using smp_cond_load_acquire() provides the acquire semantics
50 * In order to acquire the lock, the caller should declare a local node and
68 * observation of @node. And to provide the ACQUIRE ordering associated in mcs_spin_lock()
76 * However, since this thread can immediately acquire the lock in mcs_spin_lock()
91 * was used to acquire the lock.
|
| D | qrwlock.c | 18 * queued_read_lock_slowpath - acquire read lock of a queued rwlock
30 * so spin with ACQUIRE semantics until the lock is available in queued_read_lock_slowpath()
47 * The ACQUIRE semantics of the following spinning code ensure in queued_read_lock_slowpath()
63 * queued_write_lock_slowpath - acquire write lock of a queued rwlock
75 /* Try to acquire the lock directly if no reader is present */ in queued_write_lock_slowpath()
|
| /linux-6.15/tools/memory-model/litmus-tests/ |
| D | README | 46 and load-acquire replaced with READ_ONCE().
49 Can a release-acquire chain order a prior store against
58 Does a release-acquire pair suffice for the load-buffering
64 and load-acquire replaced with READ_ONCE().
75 in one process, and use an acquire load followed by a pair of
80 acquire load followed by a pair of spin_is_locked() calls
91 As below, but with a release-acquire chain.
134 As below, but without the smp_wmb() and acquire load.
137 Can a smp_wmb(), instead of a release, and an acquire order
157 Is the ordering provided by a release-acquire chain sufficient
[all …]
|
| /linux-6.15/Documentation/sound/cards/ |
| D | img-spdif-in.rst | 19 * name='SPDIF In Multi Frequency Acquire',index=0
20 * name='SPDIF In Multi Frequency Acquire',index=1
21 * name='SPDIF In Multi Frequency Acquire',index=2
22 * name='SPDIF In Multi Frequency Acquire',index=3
47 * name='SPDIF In Lock Acquire Threshold',index=0
|
| /linux-6.15/include/drm/ |
| D | drm_modeset_lock.h | 35 * @ww_ctx: base acquire ctx
42 * Each thread competing for a set of locks must use one acquire
152 * DRM_MODESET_LOCK_ALL_BEGIN - Helper to acquire modeset locks
154 * @ctx: local modeset acquire context, will be dereferenced
167 * Drivers can acquire additional modeset locks. If any lock acquisition
187 * @ctx: local modeset acquire context, will be dereferenced
198 * successfully acquire the locks, ret will be whatever your code sets it to. If
199 * there is a deadlock or other failure with acquire or backoff, ret will be set
|
| /linux-6.15/Documentation/driver-api/soundwire/ |
| D | locking.rst | 42 a. Acquire Message lock.
59 <-------------------------------+ a. Acquire Message lock
72 1. Acquire lock for Bus instance associated with Master 1.
76 a. Acquire Message lock.
93 <-------------------------------+ 1. Acquire bus lock
98 <-------------------------------+ a. Acquire Message lock
|
| /linux-6.15/include/linux/atomic/ |
| D | atomic-instrumented.h | 37 * atomic_read_acquire() - atomic load with acquire ordering
40 * Atomically loads the value of @v with acquire ordering.
128 * atomic_add_return_acquire() - atomic add with acquire ordering
132 * Atomically updates @v to (@v + @i) with acquire ordering.
202 * atomic_fetch_add_acquire() - atomic add with acquire ordering
206 * Atomically updates @v to (@v + @i) with acquire ordering.
294 * atomic_sub_return_acquire() - atomic subtract with acquire ordering
298 * Atomically updates @v to (@v - @i) with acquire ordering.
368 * atomic_fetch_sub_acquire() - atomic subtract with acquire ordering
372 * Atomically updates @v to (@v - @i) with acquire ordering.
[all …]
|
| D | atomic-long.h | 45 * raw_atomic_long_read_acquire() - atomic load with acquire ordering
48 * Atomically loads the value of @v with acquire ordering.
149 * raw_atomic_long_add_return_acquire() - atomic add with acquire ordering
153 * Atomically updates @v to (@v + @i) with acquire ordering.
233 * raw_atomic_long_fetch_add_acquire() - atomic add with acquire ordering
237 * Atomically updates @v to (@v + @i) with acquire ordering.
338 * raw_atomic_long_sub_return_acquire() - atomic subtract with acquire ordering
342 * Atomically updates @v to (@v - @i) with acquire ordering.
422 * raw_atomic_long_fetch_sub_acquire() - atomic subtract with acquire ordering
426 * Atomically updates @v to (@v - @i) with acquire ordering.
[all …]
|
| /linux-6.15/tools/memory-model/Documentation/ |
| D | glossary.txt | 27 Acquire: With respect to a lock, acquiring that lock, for example,
31 An example special acquire operation is smp_load_acquire(),
33 acquire loads.
35 When an acquire load returns the value stored by a release store
36 to that same variable, (in other words, the acquire load "reads
38 store "happen before" any operations following that load acquire.
163 See also "Acquire" and "Release".
173 See also "Acquire" and "Relaxed".
|
| D | herd-representation.txt | 24 # link, and W[ACQUIRE] are not included in the Acquire set.
39 | smp_load_acquire | R[ACQUIRE] |
86 | atomic_add_return_acquire | R*[ACQUIRE] ->rmw W*[ACQUIRE] |
107 | atomic_cmpxchg_acquire | On success: R*[ACQUIRE] ->rmw W*[ACQUIRE] |
108 | | On failure: R*[ACQUIRE] |
|
| /linux-6.15/Documentation/locking/ |
| D | ww-mutex-design.rst | 63 Acquire context: To ensure eventual forward progress it is important that a task
64 trying to acquire locks doesn't grab a new reservation id, but keeps the one it
66 acquire context. Furthermore the acquire context keeps track of debugging state
67 to catch w/w mutex interface abuse. An acquire context is representing a
71 w/w mutexes, since it is required to initialize the acquire context. The lock
74 Furthermore there are three different class of w/w lock acquire functions:
99 * Functions to only acquire a single w/w mutex, which results in the exact same
103 Again this is not strictly required. But often you only want to acquire a
104 single lock in which case it's pointless to set up an acquire context (and so
119 Three different ways to acquire locks within the same w/w class. Common
[all …]
|
| D | futex-requeue-pi.rst | 91 to be able to acquire the rt_mutex before returning to user space.
93 acquire the rt_mutex as it would open a race window between the
99 allow the requeue code to acquire an uncontended rt_mutex on behalf
115 requeueing, futex_requeue() attempts to acquire the requeue target
127 tasks as it can acquire the lock for, which in the majority of cases
129 either pthread_cond_broadcast() or pthread_cond_signal() acquire the
|
| D | mutex-design.rst | 40 (i) fastpath: tries to atomically acquire the lock by cmpxchg()ing the owner with
54 to acquire the lock spinning on a local variable. It avoids expensive
97 - Point-of-acquire tracking, symbolic lookup of function names,
115 acquire the mutex and assume that the mutex_unlock() context is not using
133 Acquire the mutex, uninterruptible::
139 Acquire the mutex, interruptible::
145 Acquire the mutex, interruptible, if dec to 0::
|
| /linux-6.15/drivers/gpu/drm/ |
| D | drm_modeset_lock.c | 35 * to use &ww_mutex and acquire-contexts to avoid deadlocks. But because
37 * of extra utility/tracking out of our acquire-ctx. This is provided
238 * drm_modeset_acquire_init - initialize acquire context
239 * @ctx: the acquire context
259 * drm_modeset_acquire_fini - cleanup acquire context
260 * @ctx: the acquire context
270 * @ctx: the acquire context
272 * Drop all locks currently held against this acquire context.
336 * @ctx: the acquire context
377 * @ctx: acquire ctx
[all …]
|
| /linux-6.15/drivers/net/ethernet/intel/igc/ |
| D | igc_i225.c | 10 * igc_acquire_nvm_i225 - Acquire exclusive access to EEPROM
13 * Acquire the necessary semaphores for exclusive access to the EEPROM.
36 * igc_get_hw_semaphore_i225 - Acquire hardware semaphore
39 * Acquire the HW semaphore to access the PHY or NVM
103 * igc_acquire_swfw_sync_i225 - Acquire SW/FW semaphore
105 * @mask: specifies which semaphore to acquire
107 * Acquire the SW/FW semaphore to access the PHY or NVM. The mask
151 * @mask: specifies which semaphore to acquire
201 status = hw->nvm.ops.acquire(hw); in igc_read_nvm_srrd_i225()
299 status = hw->nvm.ops.acquire(hw); in igc_write_nvm_srwr_i225()
[all …]
|
| /linux-6.15/tools/perf/pmu-events/arch/powerpc/power10/ |
| D | locks.json | 5 …onditional store instruction (STCX) failed. LARX and STCX are instructions used to acquire a lock."
10 …ditional store instruction (STCX) finished. LARX and STCX are instructions used to acquire a lock."
15 …onditional store instruction (STCX) passed. LARX and STCX are instructions used to acquire a lock."
|
| /linux-6.15/kernel/printk/ |
| D | nbcon.c | 43 * The acquire mechanism uses a few more fields:
59 * The acquire mechanism uses three approaches:
61 * 1) Direct acquire when the console is not owned or is owned by a lower
97 * The acquire/release functions implement only minimal policies:
111 * acquire()
193 * @ctxt: Pointer to an acquire context that contains
194 * all information about the acquire mode
216 * nbcon_context_try_acquire_direct - Try to acquire directly
220 * Acquire the console when it is released. Also acquire the console when
230 * priority. No acquire method can be successful in
[all …]
|
| /linux-6.15/tools/perf/util/ |
| D | lock-contention.h | 53 * UNINITIALIZED is required for detecting first event of acquire.
55 * that the first event for the locks are acquire,
81 * 1) acquire -> acquired -> release
82 * 2) acquire -> contended -> acquired -> release
83 * 3) acquire (with read or try) -> release
|