Lines Matching full:that
9 that make use of RCU. Violating any of the rules listed below will
10 result in the same sorts of problems that leaving out a locking primitive
17 performance measurements show that RCU is nonetheless the right
36 of lockless algorithms that garbage collectors do.
54 relating to itself that other tasks can read, there by definition
55 can be no bottleneck). Note that the definition of "large" has
73 Please note that you *cannot* rely on code known to be built
86 any locks or atomic operations. This means that readers will
93 RCU-protected data structures that have been added to
99 locks (that are acquired by both readers and writers)
100 that guard per-element state. Fields that the readers
118 d. Carefully order the updates and the reads so that readers
129 changing data into a separate structure, so that the
139 accesses. The rcu_dereference() primitive ensures that
141 that the pointer points to. This really is necessary
147 Please note that compilers can also reorder code, and
149 just that. The rcu_dereference() primitive therefore also
157 as the list_for_each_entry_rcu(). Note that it is
160 primitives. This is particularly useful in code that
190 e. Updates must ensure that initialization of a given
191 structure happens before pointers to that structure are
193 when publicizing a pointer to a structure that can
201 to block, run that code in a workqueue handler scheduled from
214 configuration-change operations that would not normally be
215 undertaken while a real-time workload is running. Note that
222 Restructure your code so that it batches the updates, allowing
234 rcu_read_unlock(), (2) any pair of primitives that disables
236 rcu_read_unlock_bh(), or (3) any pair of primitives that disables
248 executing voluntary context switches, that is, from
258 readers must use anything that disables preemption,
270 that this usage is safe is that readers can use anything that
285 primitive is that it automatically self-limits: if grace periods
308 the memory allocator, so that this wrapper function
322 here is that superuser already has lots of ways to crash
334 Note that although these primitives do take action to avoid
351 The reason that it is permissible to use RCU list-traversal
352 primitives when the update-side lock is held is that doing so
359 time that readers might be accessing that structure. In such
372 disable softirq on a given acquisition of that lock will result
374 your RCU callback while interrupting that acquisition's critical
378 the callback code simply wrappers around kfree(), so that this
379 is not an issue (or, more accurately, to the extent that it is
383 to safely access and/or modify that data structure.
385 Do not assume that RCU callbacks will be executed on the same
386 CPU that executed the corresponding call_rcu() or call_srcu().
388 callback pending, then that RCU callback will execute on some
396 In addition, do not assume that callbacks queued in a given order
397 will be invoked in that order, even if they all are queued on the
398 same CPU. Furthermore, do not assume that same-CPU callbacks will
402 might be concurrently invoked by that CPU's softirq handler and
403 that CPU's rcuo kthread. At such times, that CPU's callbacks
409 Please note that if you don't need to sleep in read-side critical
417 "struct srcu_struct" that defines the scope of a given
423 calls that have been passed the same srcu_struct. This property
452 Note that rcu_assign_pointer() relates to SRCU just as it does to
460 that readers can follow that could be affected by the
465 is the caller's responsibility to guarantee that any subsequent
482 check that accesses to RCU-protected data structures
488 check that you don't pass the same object to call_rcu()
490 since the last time that you passed that same object to
495 with __rcu, and sparse will warn you if you access that
499 These debugging aids can help you find problems that are
505 pending callbacks to be invoked before unloading that module.
506 Note that it is absolutely *not* sufficient to wait for a grace
509 call_rcu(). Or even on the current CPU if that CPU recently