| /linux/include/linux/ |
| H A D | kcsan-checks.h | 340 * ASSERT_EXCLUSIVE_WRITER - assert no concurrent writes to @var
342 * Assert that there are no concurrent writes to @var; other readers are
343 * allowed. This assertion can be used to specify properties of concurrent code,
346 * For example, if we only have a single writer, but multiple concurrent
348 * concurrent marked writes racing with the single writer are bugs.
366 * checking if a clear scope where no concurrent writes are expected exists.
388 * ASSERT_EXCLUSIVE_WRITER_SCOPED - assert no concurrent writes to @var in scope
392 * Assert that there are no concurrent writes to @var for the duration of the
423 * ASSERT_EXCLUSIVE_ACCESS - assert no concurrent accesses to @var
425 * Assert that there are no concurrent accesses to @var (no readers nor
[all …]
|
| H A D | kfifo.h | 225 * from the reader thread and there is only one concurrent reader. Otherwise
413 * Note that with only one concurrent reader and one concurrent
450 * Note that with only one concurrent reader and one concurrent
489 * Note that with only one concurrent reader and one concurrent
527 * Note that with only one concurrent reader and one concurrent
595 * Note that with only one concurrent reader and one concurrent
670 * Note that with only one concurrent reader and one concurrent
698 * Note that with only one concurrent reader and one concurrent
727 * Note that with only one concurrent reader and one concurrent
755 * Note that with only one concurrent reader and one concurrent
[all …]
|
| /linux/Documentation/gpu/rfc/ |
| H A D | gpusvm.rst | 40 * Races (especially against concurrent eviction or migrate_to_ram)
48 Concurrent CPU access could cause a livelock due to endless retries.
59 concurrent user would be very difficult unless the page is free.
94 * Concurrent GPU faults
95 * CPU faults are concurrent so makes sense to have concurrent GPU
|
| /linux/tools/memory-model/Documentation/ |
| H A D | access-marking.txt | 4 This document provides guidelines for marking intentionally concurrent
189 5. Any other loads for which there is not supposed to be a concurrent
192 6. Any other stores for which there should be neither concurrent
193 loads nor concurrent stores to that same variable.
244 concurrent access to variable foo by any other CPU is an error, even
245 if that concurrent access is marked with READ_ONCE(). In addition,
247 to be concurrent reads from foo from other CPUs, it is an error for some
248 other CPU to be concurrently writing to foo, even if that concurrent
261 your concurrent algorithm, to help the human reader, and to inform
368 concurrent write, whether marked or not.
[all …]
|
| H A D | ordering.txt | 273 different pieces of the concurrent algorithm. The variable stored to
275 an acquire operation in other parts of the concurrent algorithm.
331 the different pieces of the concurrent algorithm by looking for the
481 concurrent atomic_inc() operations applied to a given variable
509 concurrent code. It is possible to use unmarked C-language accesses for
510 shared variables that are subject to concurrent access, but great care
524 so that there are never concurrent conflicting accesses to
526 (1) at least one of the concurrent accesses to a variable is an
533 o Use locking or other means to ensure that all concurrent accesses
|
| H A D | README | 39 o You would like to mark concurrent normal accesses to shared
65 Guidelines for marking intentionally concurrent accesses to
|
| /linux/drivers/net/ethernet/microchip/ |
| H A D | lan743x_ptp.h | 30 /* gpio_lock: used to prevent concurrent access to gpio settings */
78 /* command_lock: used to prevent concurrent ptp commands */
93 /* tx_ts_lock: used to prevent concurrent access to timestamp arrays */
|
| /linux/rust/kernel/ |
| H A D | revocable.rs | 20 /// Once access is revoked and all concurrent users complete (i.e., all existing instances of
158 /// Callers must ensure that there are no more concurrent users of the revocable object.
179 /// expecting that there are no concurrent users of the object.
186 /// Callers must ensure that there are no more concurrent users of the revocable object.
198 /// If there are concurrent users of the object (i.e., ones that called
200 /// function waits for the concurrent access to complete before dropping the wrapped object.
|
| /linux/lib/ |
| H A D | rcuref.c | 28 * O(N^2) behaviour under contention with N concurrent operations.
65 * concurrent rcuref_get() can acquire the reference count and bring it
68 * If the cmpxchg() succeeds then a concurrent rcuref_get() will result in
234 * with a concurrent get()/put() pair. Caller is not allowed to
244 * This can fail if a concurrent get() operation has in rcuref_put_slowpath()
|
| /linux/drivers/clk/sifive/ |
| H A D | sifive-prci.c | 311 * Context: Any context. Caller must prevent concurrent changes to the
332 * Context: Any context. Caller must prevent concurrent changes to the
354 * Context: Any context. Caller must prevent concurrent changes to the
375 * Context: Any context. Caller must prevent concurrent changes to the
396 * Context: Any context. Caller must prevent concurrent changes to the
417 * Context: Any context. Caller must prevent concurrent changes to the
438 * Context: Any context. Caller must prevent concurrent changes to the
|
| /linux/drivers/usb/gadget/function/ |
| H A D | g_zero.h | 43 * This is to protect the data from concurrent access by read/write
58 * This is to protect the data from concurrent access by read/write
|
| /linux/tools/include/uapi/asm-generic/ |
| H A D | fcntl.h | |
| /linux/include/uapi/asm-generic/ |
| H A D | fcntl.h | 187 #define LOCK_READ 64 /* which allows concurrent read operations */
188 #define LOCK_WRITE 128 /* which allows concurrent write operations */
189 #define LOCK_RW 192 /* which allows concurrent read & write ops */
|
| /linux/arch/arc/mm/ |
| H A D | highmem.c | 26 * means the total number of concurrent fixmaps will be limited to max
42 * - pkmap being preemptible, in theory could do with more than 256 concurrent
|
| /linux/fs/xfs/ |
| H A D | xfs_aops.c | 300 * because concurrent changes could have invalidated the extent. Check in xfs_imap_valid()
301 * the COW fork because concurrent changes since the last time we in xfs_imap_valid()
351 * we've indirectly protected against concurrent updates: writeback has in xfs_map_blocks()
352 * the page locked, which prevents concurrent invalidations by reflink in xfs_map_blocks()
353 * and directio and prevents concurrent buffered writes to the same in xfs_map_blocks()
355 * against concurrent updates and provides a memory barrier on the way in xfs_map_blocks()
767 * Swap file activation can race against concurrent shared extent in xfs_vm_swap_activate()
|
| /linux/security/landlock/ |
| H A D | object.h | 34 * in a safe way. This implies to handle concurrent use and modification.
50 * @lock: Protects against concurrent modifications. This lock must be
|
| /linux/include/sound/ |
| H A D | seq_kernel.h | 18 /* max number of concurrent clients */
21 /* max number of concurrent ports */
|
| /linux/drivers/s390/cio/ |
| H A D | device_status.c | 90 /* Copy concurrent sense / model dependent information. */ in ccw_device_accumulate_ecw()
184 /* Copy concurrent sense bit. */ in ccw_device_accumulate_esw()
293 * concurrent sense facility installed for the subchannel. in ccw_device_accumulate_irb()
299 * operand exception for virtual devices without concurrent in ccw_device_accumulate_irb()
301 * concurrent sense facility. in ccw_device_accumulate_irb()
|
| /linux/Documentation/trace/ |
| H A D | ring-buffer-map.rst | 43 Concurrent readers (either another application mapping that ring-buffer or the
45 the ring-buffer and the output is unpredictable, just like concurrent readers on
|
| /linux/drivers/net/ethernet/mscc/ |
| H A D | ocelot_fdma.h | 87 * @xmit_lock: lock for concurrent xmit access
95 /* Protect concurrent xmit calls */
|
| /linux/kernel/trace/rv/ |
| H A D | rv_reactors.c | 352 /* Ensures that concurrent monitors read consistent reacting_on */ in rv_reacting_on()
371 /* Ensures that concurrent monitors read consistent reacting_on */ in turn_reacting_off()
378 /* Ensures that concurrent monitors read consistent reacting_on */ in turn_reacting_on()
|
| /linux/drivers/gpu/drm/xe/ |
| H A D | xe_userptr.c | 167 /* Protect against concurrent userptr pinning */ in xe_vma_userptr_force_invalidate()
169 /* Protect against concurrent notifiers */ in xe_vma_userptr_force_invalidate()
172 * Protect against concurrent instances of this function and in xe_vma_userptr_force_invalidate()
|
| /linux/Documentation/process/ |
| H A D | volatile-considered-harmful.rst | 17 unwanted concurrent access, which is very much a different task. The
21 Like volatile, the kernel primitives which make concurrent access to data
|
| /linux/Documentation/filesystems/ |
| H A D | ocfs2.rst | 106 coherency=full (*) Disallow concurrent O_DIRECT writes, cluster inode
110 coherency=buffered Allow concurrent O_DIRECT writes without EX lock among
|
| /linux/drivers/media/pci/ddbridge/ |
| H A D | ddbridge-mci.h | 218 struct mutex tuner_lock; /* concurrent tuner access lock */
219 struct mutex mci_lock; /* concurrent MCI access lock */
|