| /linux/samples/livepatch/ |
| H A D | livepatch-callbacks-demo.c | 7 * livepatch-callbacks-demo.c - (un)patching callbacks livepatch demo
13 * Demonstration of registering livepatch (un)patching callbacks.
21 * insmod samples/livepatch/livepatch-callbacks-mod.ko
24 * Step 2 - load the demonstration livepatch (with callbacks)
26 * insmod samples/livepatch/livepatch-callbacks-demo.ko
38 * NOTE: swap the insmod order of livepatch-callbacks-mod.ko and
39 * livepatch-callbacks-demo.ko to observe what happens when a
40 * target module is loaded after a livepatch with callbacks.
47 * insmod samples/livepatch/livepatch-callbacks-demo.ko
53 * insmod samples/livepatch/livepatch-callbacks-mod.ko
[all …]
|
| H A D | livepatch-callbacks-mod.c | 7 * livepatch-callbacks-mod.c - (un)patching callbacks demo support module
13 * Simple module to demonstrate livepatch (un)patching callbacks.
20 * section of livepatch-callbacks-demo.c.
41 MODULE_DESCRIPTION("Live patching demo for (un)patching callbacks, support module");
|
| H A D | livepatch-callbacks-busymod.c | 7 * livepatch-callbacks-busymod.c - (un)patching callbacks demo support module
13 * Simple module to demonstrate livepatch (un)patching callbacks.
20 * section of livepatch-callbacks-mod.c.
59 MODULE_DESCRIPTION("Live patching demo for (un)patching callbacks, support module");
|
| /linux/kernel/livepatch/ |
| H A D | core.h | 30 if (obj->callbacks.pre_patch) in klp_pre_patch_callback()
31 ret = (*obj->callbacks.pre_patch)(obj); in klp_pre_patch_callback()
33 obj->callbacks.post_unpatch_enabled = !ret; in klp_pre_patch_callback()
40 if (obj->callbacks.post_patch) in klp_post_patch_callback()
41 (*obj->callbacks.post_patch)(obj); in klp_post_patch_callback()
46 if (obj->callbacks.pre_unpatch) in klp_pre_unpatch_callback()
47 (*obj->callbacks.pre_unpatch)(obj); in klp_pre_unpatch_callback()
52 if (obj->callbacks.post_unpatch_enabled && in klp_post_unpatch_callback()
53 obj->callbacks.post_unpatch) in klp_post_unpatch_callback()
54 (*obj->callbacks.post_unpatch)(obj); in klp_post_unpatch_callback()
[all …]
|
| /linux/kernel/rcu/ |
| H A D | rcu_segcblist.c | 97 /* Return number of callbacks in segmented callback list by summing seglen. */
146 * field to disagree with the actual number of callbacks on the structure.
155 * This can of course race with both queuing and invoking of callbacks.
157 * rcu_barrier() failing to IPI a CPU that actually had callbacks queued
168 * CASE 1: Suppose that CPU 0 has no callbacks queued, but invokes
226 * callbacks on the structure. This increase is fully ordered with respect
253 * Disable the specified rcu_segcblist structure, so that callbacks can
264 * Does the specified rcu_segcblist structure contain callbacks that
274 * Does the specified rcu_segcblist structure contain callbacks that
326 * for rcu_barrier() to sometimes post callbacks needlessly, but
[all …]
|
| H A D | rcu_segcblist.h | 12 /* Return number of callbacks in the specified callback list. */
20 /* Return number of callbacks in segmented callback list by summing seglen. */
34 * necessarily imply that there are no callbacks associated with
35 * this structure. When callbacks are being invoked, they are
37 * the remaining callbacks will be added back to the list. Either
48 /* Return number of callbacks in segmented callback list. */
100 * rcu_segcblist structure empty of callbacks? (The specified
101 * segment might well contain callbacks.)
110 * empty of callbacks?
|
| /linux/Documentation/driver-api/usb/ |
| H A D | callbacks.rst | 1 USB core callbacks
4 What callbacks will usbcore do?
7 Usbcore will call into a driver through callbacks defined in the driver
10 callbacks are completely independent of each other. Information on the
13 The callbacks defined in the driver structure are:
15 1. Hotplugging callbacks:
34 3. Power management (PM) callbacks:
55 reason. Sysfs is preferred these days. The PM callbacks are covered
61 All callbacks are mutually exclusive. There's no need for locking
62 against other USB callbacks. All callbacks are called from a task
[all …]
|
| /linux/Documentation/livepatch/ |
| H A D | callbacks.rst | 2 (Un)patching Callbacks
5 Livepatch (un)patch-callbacks provide a mechanism for livepatch modules
16 In most cases, (un)patch callbacks will need to be used in conjunction
23 Callbacks differ from existing kernel facilities:
30 Callbacks are part of the klp_object structure and their implementation
37 Callbacks can be registered for the following livepatch actions:
61 symmetry: pre-patch callbacks have a post-unpatch counterpart and
62 post-patch callbacks have a pre-unpatch counterpart. An unpatch
69 in-kernel vmlinux targets, this means that callbacks will always execute
71 callbacks will only execute if the target module is loaded. When a
[all …]
|
| H A D | cumulative-patches.rst | 70 extra modifications in (un)patching callbacks or in the module_init()
77 - Only the (un)patching callbacks from the _new_ cumulative livepatch are
78 executed. Any callbacks from the replaced patches are ignored.
84 older ones. The old livepatches might not provide the necessary callbacks.
92 the various callbacks and their interactions if the callbacks from all
|
| /linux/Documentation/core-api/ |
| H A D | cpu_hotplug.rst | 133 Once a CPU has been logically shutdown the teardown callbacks of registered
158 When a CPU is onlined, the startup callbacks are invoked sequentially until
160 callbacks of a state are set up or an instance is added to a multi-instance
163 When a CPU is offlined the teardown callbacks are invoked in the reverse
165 be invoked when the callbacks of a state are removed or an instance is
179 The startup callbacks in this section are invoked before the CPU is
180 started during a CPU online operation. The teardown callbacks are invoked
183 The callbacks are invoked on a control CPU as they can't obviously run on
187 The startup callbacks are used to setup resources which are required to
188 bring a CPU successfully online. The teardown callbacks are used to free
[all …]
|
| /linux/include/linux/ |
| H A D | rcu_segcblist.h | 37 * Callbacks whose grace period has elapsed, and thus can be invoked.
39 * Callbacks waiting for the current GP from the current CPU's viewpoint.
41 * Callbacks that arrived before the next GP started, again from
44 * Callbacks that might have arrived after the next GP started.
54 * corresponding segment of callbacks will be ready to invoke. A given
56 * is non-empty, and it is never valid for RCU_DONE_TAIL (whose callbacks
57 * are already ready to invoke) or for RCU_NEXT_TAIL (whose callbacks have
74 * | Callbacks processed by rcu_core() from softirqs or local |
82 * | Callbacks processed by rcu_core() from softirqs or local |
91 * | CB kthread got unparked and processes callbacks concurrently with |
[all …]
|
| H A D | cpuhotplug.h | 27 * startup callbacks sequentially from CPUHP_OFFLINE + 1 to CPUHP_ONLINE
29 * installed teardown callbacks are invoked in the reverse order from
34 * PREPARE: The callbacks are invoked on a control CPU before the
37 * STARTING: The callbacks are invoked on the hotplugged CPU from the low level
40 * ONLINE: The callbacks are invoked on the hotplugged CPU from the per CPU
261 * cpuhp_setup_state - Setup hotplug state callbacks with calling the @startup
280 * cpuhp_setup_state_cpuslocked - Setup hotplug state callbacks with calling
301 * cpuhp_setup_state_nocalls - Setup hotplug state callbacks without calling the
321 * cpuhp_setup_state_nocalls_cpuslocked - Setup hotplug state callbacks without
324 * callbacks
[all …]
|
| H A D | i2c-of-prober.h | 18 * struct i2c_of_probe_ops - I2C OF component prober callbacks
20 * A set of callbacks to be used by i2c_of_probe_component().
22 * All callbacks are optional. Callbacks are called only once per run, and are
25 * All callbacks that have return values shall return %0 on success,
28 * The @dev parameter passed to the callbacks is the same as @dev passed to
62 * @ops: Callbacks for the prober to use.
94 * struct i2c_of_probe_simple_opts - Options for simple I2C component prober callbacks
|
| H A D | powercap.h | 24 * struct powercap_control_type_ops - Define control type callbacks
37 * This structure defines control type callbacks to be implemented by client
75 * struct powercap_zone_ops - Define power zone callbacks
92 * This structure defines zone callbacks to be implemented by client drivers.
93 * Client drives can define both energy and power related callbacks. But at
95 * should handle mutual exclusion, if required in callbacks.
155 * struct powercap_zone_constraint_ops - Define constraint callbacks
166 * This structure is used to define the constraint callbacks for the client
167 * drivers. The following callbacks are mandatory and can't be NULL:
173 * Client drivers should handle mutual exclusion, if required in callbacks.
[all …]
|
| /linux/tools/testing/selftests/livepatch/ |
| H A D | test-callbacks.sh | 20 # pre-patch callbacks are executed for vmlinux and $MOD_TARGET (those
22 # according to the klp_patch, their post-patch callbacks run and the
25 # - Similarly, on livepatch disable, pre-patch callbacks run before the
27 # callbacks execute and the transition completes.
67 # - On livepatch enable, only pre/post-patch callbacks are executed for
71 # pre/post-patch callbacks are executed.
74 # $MOD_TARGET) pre/post-unpatch callbacks are executed.
119 # post-unpatch callbacks are executed when this occurs.
121 # - When the livepatch is disabled, pre and post-unpatch callbacks are
166 # pre/post-patch callbacks are executed.
[all …]
|
| /linux/Documentation/RCU/ |
| H A D | UP.rst | 77 It is far better to guarantee that callbacks are invoked
85 What locking restriction must RCU callbacks respect?
90 permit call_rcu() to directly invoke callbacks, but only if a full
91 grace period has elapsed since those callbacks were queued. This is
94 encouraged to avoid invoking callbacks from call_rcu(), thus obtaining
102 infrastructure *must* respect grace periods, and *must* invoke callbacks
123 What locking restriction must RCU callbacks respect?
134 then, since RCU callbacks can be invoked from softirq context,
140 callbacks acquire locks directly. However, a great many RCU
141 callbacks do acquire locks *indirectly*, for example, via
|
| /linux/net/lapb/ |
| H A D | lapb_iface.c | 140 const struct lapb_register_struct *callbacks) in lapb_register() argument
159 lapb->callbacks = callbacks; in lapb_register()
411 if (lapb->callbacks->connect_confirmation) in lapb_connect_confirmation()
412 lapb->callbacks->connect_confirmation(lapb->dev, reason); in lapb_connect_confirmation()
417 if (lapb->callbacks->connect_indication) in lapb_connect_indication()
418 lapb->callbacks->connect_indication(lapb->dev, reason); in lapb_connect_indication()
423 if (lapb->callbacks->disconnect_confirmation) in lapb_disconnect_confirmation()
424 lapb->callbacks->disconnect_confirmation(lapb->dev, reason); in lapb_disconnect_confirmation()
429 if (lapb->callbacks->disconnect_indication) in lapb_disconnect_indication()
430 lapb->callbacks->disconnect_indication(lapb->dev, reason); in lapb_disconnect_indication()
[all …]
|
| /linux/tools/rcu/ |
| H A D | rcu-cbs.py | 4 # Dump out the number of RCU callbacks outstanding.
7 # number of callbacks for the most heavily used flavor.
39 # Sum up RCU callbacks.
44 # print("CPU " + str(cpu) + " RCU callbacks: " + str(len));
46 print("Number of RCU callbacks in flight: " + str(sum));
|
| /linux/sound/drivers/opl3/ |
| H A D | opl3_oss.c | 49 struct snd_seq_port_callback callbacks; in snd_opl3_oss_create_port() local
60 memset(&callbacks, 0, sizeof(callbacks)); in snd_opl3_oss_create_port()
61 callbacks.owner = THIS_MODULE; in snd_opl3_oss_create_port()
62 callbacks.event_input = snd_opl3_oss_event_input; in snd_opl3_oss_create_port()
63 callbacks.private_free = snd_opl3_oss_free_port; in snd_opl3_oss_create_port()
64 callbacks.private_data = opl3; in snd_opl3_oss_create_port()
70 opl3->oss_chset->port = snd_seq_event_port_attach(opl3->seq_client, &callbacks, in snd_opl3_oss_create_port()
|
| /linux/block/ |
| H A D | blk-stat.c | 15 struct list_head callbacks; member
62 list_for_each_entry_rcu(cb, &q->stats->callbacks, list) { in blk_stat_add()
148 list_add_tail_rcu(&cb->list, &q->stats->callbacks); in blk_stat_add_callback()
160 if (list_empty(&q->stats->callbacks) && !q->stats->accounting) in blk_stat_remove_callback()
188 if (!--q->stats->accounting && list_empty(&q->stats->callbacks)) in blk_stat_disable_accounting()
199 if (!q->stats->accounting++ && list_empty(&q->stats->callbacks)) in blk_stat_enable_accounting()
213 INIT_LIST_HEAD(&stats->callbacks); in blk_alloc_queue_stats()
225 WARN_ON(!list_empty(&stats->callbacks)); in blk_free_queue_stats()
|
| /linux/sound/hda/codecs/side-codecs/ |
| H A D | tas2781_hda.h | 18 * No standard control callbacks for SNDRV_CTL_ELEM_IFACE_CARD
19 * Define two controls, one is Volume control callbacks, the other is
20 * flag setting control callbacks.
23 /* Volume control callbacks for tas2781 */
39 /* Flag control callbacks for tas2781 */
|
| /linux/Documentation/driver-api/pm/ |
| H A D | notifiers.rst | 16 ``->resume()`` or even ``->prepare()`` and ``->complete()`` callbacks are not
33 callbacks for the "freeze" transition.
37 error occurred during hibernation. Device restore callbacks have been
47 callbacks have been executed and tasks have been thawed.
54 resume callbacks have been executed and tasks have been thawed.
|
| /linux/Documentation/driver-api/media/ |
| H A D | v4l2-event.rst | 59 ``merge()`` and ``replace()`` callbacks which drivers can set. These
60 callbacks are called when a new event is raised and there is no more room.
75 A good example of these ``replace``/``merge`` callbacks is in v4l2-event.c:
76 ``ctrls_replace()`` and ``ctrls_merge()`` callbacks for the control event.
79 these callbacks can be called from interrupt context, so they must
110 The ops argument allows the driver to specify a number of callbacks:
124 All 4 callbacks are optional, if you don't want to specify any callbacks
|
| /linux/net/ipv6/ |
| H A D | ip6_offload.c | 131 if (likely(ops && ops->callbacks.gso_segment)) { in ipv6_gso_segment()
135 segs = ops->callbacks.gso_segment(skb, features); in ipv6_gso_segment()
228 if (!ops || !ops->callbacks.gro_receive) { in ipv6_gro_receive()
232 if (!ops || !ops->callbacks.gro_receive) in ipv6_gro_receive()
294 pp = ops->callbacks.gro_receive(head, skb); in ipv6_gro_receive()
354 if (WARN_ON(!ops || !ops->callbacks.gro_complete)) in ipv6_gro_complete()
357 err = ops->callbacks.gro_complete(skb, nhoff); in ipv6_gro_complete()
413 .callbacks = {
421 .callbacks = { in sit_gso_segment()
429 .callbacks in ip4ip6_gso_segment()
[all...] |
| /linux/Documentation/RCU/Design/Data-Structures/ |
| H A D | Data-Structures.rst | 121 RCU updaters wait for normal grace periods by registering RCU callbacks,
123 ``synchronize_rcu()`` and friends. RCU callbacks are represented by
156 serves as short-term repository for callbacks orphaned by CPU-hotplug
182 #. ``rcu_head``: This structure represents RCU callbacks, and is the
703 The ``rcu_segcblist`` structure maintains a segmented list of callbacks
724 #. ``RCU_DONE_TAIL``: Callbacks whose grace periods have elapsed. These
725 callbacks are ready to be invoked.
726 #. ``RCU_WAIT_TAIL``: Callbacks that are waiting for the current grace
729 #. ``RCU_NEXT_READY_TAIL``: Callbacks waiting for the next grace period
731 #. ``RCU_NEXT_TAIL``: Callbacks that have not yet been associated with a
[all …]
|