| /linux/Documentation/ |
| H A D | atomic_bitops.txt | 5 While our bitmap_{}() functions are non-atomic, we have a number of operations
12 The single bit operations are:
18 RMW atomic operations without return value:
23 RMW atomic operations with return value:
33 All RMW atomic operations have a '__' prefixed variant which is non-atomic.
47 The test_and_{}_bit() operations return the original value of the bit.
55 - non-RMW operations are unordered;
57 - RMW operations that have no return value are unordered;
59 - RMW operations that have a return value are fully ordered.
61 - RMW operations that are conditional are fully ordered.
[all …]
|
| H A D | atomic_t.txt | 5 RMW operations between CPUs (atomic operations on MMIO are not supported and
20 RMW atomic operations:
85 the Non-RMW operations of atomic_t, you do not in fact need atomic_t at all
138 - plain operations without return value: atomic_{}()
140 - operations which return the modified value: atomic_{}_return()
142 these are limited to the arithmetic operations because those are
146 - operations which return the original value: atomic_fetch_{}()
148 - swap operations: xchg(), cmpxchg() and try_cmpxchg()
150 - misc; the special purpose operations that are commonly used and would,
155 All these operations are SMP atomic; that is, the operations (for a single
[all …]
|
| /linux/rust/kernel/debugfs/ |
| H A D | file_ops.rs | 28 /// `FileOps<T>` will always contain an `operations` which is safe to use for a file backed
33 operations: bindings::file_operations,
42 /// The caller asserts that the provided `operations` is safe to use for a file whose in new()
44 const unsafe fn new(operations: bindings::file_operations, mode: u16) -> Self {
47 operations, in mode()
72 &self.operations in fmt()
133 let operations = bindings::file_operations {
140 // SAFETY: `operations` is all stock `seq_file` implementations except for `writer_open`. in read()
144 unsafe { FileOps::new(operations, 0o400) } in read()
177 // A trait to get the file operations fo
24 operations: bindings::file_operations, global() field
124 let operations = bindings::file_operations { global() localVariable
176 let operations = bindings::file_operations { global() localVariable
234 let operations = bindings::file_operations { global() localVariable
287 let operations = bindings::file_operations { global() localVariable
342 let operations = bindings::file_operations { global() localVariable
367 let operations = bindings::file_operations { global() localVariable
[all...] |
| /linux/tools/memory-model/Documentation/ |
| H A D | ordering.txt | 2 operations provided by the Linux-kernel memory model (LKMM).
9 operations in decreasing order of strength:
12 all of the CPU's prior operations against some or all of its
13 subsequent operations.
15 2. Ordered memory accesses. These operations order themselves
23 some of these "unordered" operations provide limited ordering
62 o Value-returning RMW atomic operations whose names do not end in
82 Second, some RMW atomic operations provide full ordering. These
83 operations include value-returning RMW atomic operations (that is, those
86 cmpxchg(), and xchg(). Note that conditional RMW atomic operations such
[all …]
|
| /linux/Documentation/virt/ |
| H A D | paravirt_ops.rst | 11 hypervisors. It allows each hypervisor to override critical operations and
15 pv_ops provides a set of function pointers which represent operations
18 time by enabling binary patching of the low-level critical operations
21 pv_ops operations are classified into three categories:
24 These operations correspond to high-level functionality where it is
28 Usually these operations correspond to low-level critical instructions. They
|
| /linux/Documentation/arch/arm/ |
| H A D | firmware.rst | 2 Interface for registering and calling firmware-specific operations for ARM
10 operations and call them when needed.
12 Firmware operations can be specified by filling in a struct firmware_ops
21 There is a default, empty set of operations provided, so there is no need to
22 set anything if platform does not require firmware operations.
33 Example of registering firmware operations::
52 /* other operations not available on platformX */
|
| /linux/Documentation/bpf/standardization/ |
| H A D | instruction-set.rst | 142 * atomic32: includes 32-bit atomic operation instructions (see `Atomic operations`_).
277 LD 0x0 non-standard load operations `Load and store instructions`_
278 LDX 0x1 load into register operations `Load and store instructions`_
279 ST 0x2 store from immediate operations `Load and store instructions`_
280 STX 0x3 store from register operations `Load and store instructions`_
281 ALU 0x4 32-bit arithmetic operations `Arithmetic and jump instructions`_
282 JMP 0x5 64-bit jump operations `Arithmetic and jump instructions`_
283 JMP32 0x6 32-bit jump operations `Arithmetic and jump instructions`_
284 ALU64 0x7 64-bit arithmetic operations `Arithmetic and jump instructions`_
319 otherwise identical operations. ``ALU64`` instructions belong to the
[all …]
|
| /linux/Documentation/gpu/ |
| H A D | drm-vm-bind-async.rst | 15 * ``VM_BIND``: An operation or a list of operations to modify a gpu_vm using
16 an IOCTL. The operations include mapping and unmapping system- or
57 operation. VM_BIND operations that use the same bind context can be
59 assumptions can be made for VM_BIND operations using separate bind contexts.
71 With Synchronous VM_BIND, the VM_BIND operations all complete before the
73 out-fences. Synchronous VM_BIND may block and wait for GPU operations;
79 IOCTL may return immediately, the VM_BIND operations wait for the in-syncobjs
88 If the VM_BIND IOCTL takes a list or an array of operations as an argument,
94 Since asynchronous VM_BIND operations may use dma-fences embedded in
109 operations for long-running workloads will not allow for pipelining
[all …]
|
| /linux/Documentation/core-api/ |
| H A D | local_ops.rst | 11 This document explains the purpose of the local atomic operations, how
18 Note that ``local_t`` based operations are not recommended for general
19 kernel use. Please use the ``this_cpu`` operations instead unless there is
21 replaced by ``this_cpu`` operations. ``this_cpu`` operations combine the
26 Purpose of local atomic operations
29 Local atomic operations are meant to provide fast and highly reentrant per CPU
30 counters. They minimize the performance cost of standard atomic operations by
39 Local atomic operations only guarantee variable modification atomicity wrt the
50 It can be done by slightly modifying the standard atomic operations: only
63 Rules to follow when using local atomic operations
[all …]
|
| /linux/drivers/fwctl/pds/ |
| H A D | main.c | 28 struct pds_fwctl_query_data *operations; member
136 if (ei->operations) { in pdsfc_free_operations()
138 ei->operations, ei->operations_pa); in pdsfc_free_operations()
139 ei->operations = NULL; in pdsfc_free_operations()
320 if (!ep_info->operations) { in pdsfc_validate_rpc()
321 struct pds_fwctl_query_data *operations; in pdsfc_validate_rpc() local
323 operations = pdsfc_get_operations(pdsfc, in pdsfc_validate_rpc()
326 if (IS_ERR(operations)) { in pdsfc_validate_rpc()
330 ep_info->operations = operations; in pdsfc_validate_rpc()
335 op_entry = (struct pds_fwctl_query_data_operation *)ep_info->operations->entries; in pdsfc_validate_rpc()
[all …]
|
| /linux/Documentation/crypto/ |
| H A D | async-tx-api.rst | 15 3.2 Supported operations
36 the API will fit the chain of operations to the available offload
54 operations to be submitted, like xor->copy->xor in the raid5 case. The
71 3.2 Supported operations
97 operations complete. When an application needs to submit a chain of
98 operations it must guarantee that the descriptor is not automatically recycled
104 1. setting the ASYNC_TX_ACK flag if no child operations are to be submitted
113 async_<operation> call. Offload engine drivers batch operations to
116 automatically issues pending operations. An application can force this
129 chains and issuing pending operations.
[all …]
|
| /linux/mm/damon/ |
| H A D | Kconfig | 28 bool "Data access monitoring operations for virtual address spaces"
33 This builds the default data access monitoring operations for DAMON
37 bool "Data access monitoring operations for the physical address space"
42 This builds the default data access monitoring operations for DAMON
46 bool "Test for DAMON operations" if !KUNIT_ALL_TESTS
50 This builds the DAMON virtual addresses operations Kunit test suite.
|
| /linux/Documentation/filesystems/spufs/ |
| H A D | spufs.rst | 45 the operations supported on regular file systems. This list details the
46 supported operations and the deviations from the behaviour in the
51 All files support the access(2) and stat(2) family of operations, but
57 possible operations, e.g. read access on the wbox file.
65 data in the address space of the SPU. The possible operations on an
84 operations on an open mbox file are:
98 operations on an open ibox file are:
121 operations on an open wbox file are: write(2) If a count smaller than
143 operations on an open ``*box_stat`` file are:
173 The possible operations on an open npc, decr, decr_status,
[all …]
|
| /linux/Documentation/driver-api/ |
| H A D | clk.rst | 17 gating, rate adjustment, muxing or other operations. This framework is
25 drivers/clk/clk.c. Finally there is struct clk_ops, whose operations
67 the operations defined in clk-provider.h::
175 To take advantage of your data you'll need to support valid operations
276 .disable operations. Those operations are thus not allowed to sleep,
290 The prepare lock is a mutex and is held across calls to all other operations.
291 All those operations are allowed to sleep, and calls to the corresponding API
294 This effectively divides operations in two groups from a locking perspective.
296 Drivers don't need to manually protect resources shared between the operations
298 clocks or not. However, access to resources that are shared between operations
[all …]
|
| H A D | i2c.rst | 26 are functions to perform various I2C protocol operations; at this writing
32 Controllers that support I2C can also support most SMBus operations, but
35 operations, either using I2C primitives or by issuing SMBus commands to
36 i2c_adapter devices which don't support those I2C operations.
|
| /linux/Documentation/filesystems/iomap/ |
| H A D | design.rst | 20 iomap is a filesystem library for handling common file operations.
34 The library exports various APIs for implementing file operations such
47 has now been extended to cover several other operations.
65 initiates operations on that basis.
83 So far only the pagecache operations need to do this.
143 metadata or zeroing operations to perform during either submission
234 heads for pagecache operations.
264 These flags can be set by iomap itself during file operations.
275 Currently, these flags are only set by pagecache operations.
280 This only needs to be set for mapped or unwritten operations.
[all …]
|
| H A D | porting.rst | 23 Pagecache operations lock a single base page at a time and then call
25 Direct I/O operations build I/O requests a single file block at a
38 iomap handles common pagecache related operations itself, such as
62 other read-only mapping operations will do the right thing.
66 file space for selected read operations.
94 iomap ops for write operations.
100 Now, convert any remaining file operations to call the iomap functions.
|
| /linux/Documentation/arch/arm/vfp/ |
| H A D | release-notes.rst | 19 The operations which have been tested with this package are:
41 Other operations which have been tested by basic assembly-only tests
51 The combination operations have not been tested:
|
| /linux/Documentation/ABI/testing/ |
| H A D | debugfs-pfo-nx-crypto | 33 The total number of AES operations submitted to the hardware.
39 The total number of SHA-256 operations submitted to the hardware.
45 The total number of SHA-512 operations submitted to the hardware.
|
| /linux/Documentation/filesystems/ |
| H A D | directory-locking.rst | 6 Locking scheme used for directory operations is based on two
18 For our purposes all operations fall in 6 classes:
74 operations on directory trees, but we obviously do not have the full
77 Trees grow as we do operations; memory pressure prunes them. Normally
108 the lock is dropped. So from the directory operations' point of view
120 using a local one as a cache, etc. In all such cases the operations
122 directory operation on this filesystem might involve directory operations
125 on a filesystem could trigger directory operations only on higher-ranked
160 It's easy to verify that operations never take a lock with rank
170 Moreover, without loss of generality we can assume that all operations
[all …]
|
| /linux/Documentation/admin-guide/perf/ |
| H A D | hisi-pmu.rst | 67 This will only count the operations from core/thread 0 and 1 in this cluster.
74 operations via the tt_req parameeter in perf. The default value counts all
75 operations. tt_req is 3bits, 3'b100 represents read operations, 3'b101
76 represents write operations, 3'b110 represents atomic store operations and
77 3'b111 represents atomic non-store operations, other values are reserved::
81 This will only count the read operations in this cluster.
|
| /linux/Documentation/driver-api/soundwire/ |
| H A D | locking.rst | 6 following locks in order to avoid race conditions in Bus operations on
18 serialize each of the following operations(s) within SoundWire Bus instance.
22 - Prepare, Enable, Disable and De-prepare stream operations.
|
| /linux/Documentation/filesystems/fuse/ |
| H A D | fuse-passthrough.rst | 11 performance of FUSE filesystems for I/O operations. Typically, FUSE operations
13 incur overhead. Passthrough allows certain operations on a FUSE file to bypass
23 operations.
25 Currently, passthrough is supported for operations like ``read(2)``/``write(2)``
129 the kernel to perform direct operations on its behalf based on user-provided
|
| /linux/Documentation/translations/zh_CN/locking/ |
| H A D | spinlocks.rst | 35 (5) ACQUIRE operations.
37 (6) RELEASE operations.
|
| /linux/fs/fuse/ |
| H A D | Kconfig | 58 bool "FUSE passthrough operations support"
63 This allows bypassing FUSE server by mapping specific FUSE operations
66 If you want to allow passthrough operations, answer Y.
|