======================
(Un)patching Callbacks
======================

Livepatch (un)patch-callbacks provide a mechanism for livepatch modules
to execute callback functions when a kernel object is (un)patched.  They
can be considered a "power feature" that extends livepatching abilities
to include:

  - Safe updates to global data

  - "Patches" to init and probe functions

  - Patching otherwise unpatchable code (i.e. assembly)

In most cases, (un)patch callbacks will need to be used in conjunction
with memory barriers and kernel synchronization primitives, like
mutexes/spinlocks, or even stop_machine(), to avoid concurrency issues.

Callbacks differ from existing kernel facilities:

  - Module init/exit code doesn't run when disabling and re-enabling a
    patch.

  - A module notifier can't stop a to-be-patched module from loading.

Callbacks are part of the klp_object structure and their implementation
is specific to that klp_object.  Other livepatch objects may or may not
be patched, irrespective of the target klp_object's current state.

Callbacks can be registered for the following livepatch actions:

  * Pre-patch    - before a klp_object is patched

  * Post-patch   - after a klp_object has been patched and is active
                   across all tasks

  * Pre-unpatch  - before a klp_object is unpatched (ie, patched code is
                   active), used to clean up post-patch callback
                   resources

  * Post-unpatch - after a klp_object has been patched, all code has
                   been restored and no tasks are running patched code,
                   used to cleanup pre-patch callback resources

Each callback is optional, omitting one does not preclude specifying any
other.  However, the livepatching core executes the handlers in
symmetry: pre-patch callbacks have a post-unpatch counterpart and
post-patch callbacks have a pre-unpatch counterpart.  An unpatch
callback will only be executed if its corresponding patch callback was
executed.  Typical use cases pair a patch handler that acquires and
configures resources with an unpatch handler tears down and releases
those same resources.

A callback is only executed if its host klp_object is loaded.  For
in-kernel vmlinux targets, this means that callbacks will always execute
when a livepatch is enabled/disabled.  For patch target kernel modules,
callbacks will only execute if the target module is loaded.  When a
module target is (un)loaded, its callbacks will execute only if the
livepatch module is enabled.

The pre-patch callback, if specified, is expected to return a status
code (0 for success, -ERRNO on error).  An error status code indicates
to the livepatching core that patching of the current klp_object is not
safe and to stop the current patching request.  (When no pre-patch
callback is provided, the transition is assumed to be safe.)  If a
pre-patch callback returns failure, the kernel's module loader will:

  - Refuse to load a livepatch, if the livepatch is loaded after
    targeted code.

    or:

  - Refuse to load a module, if the livepatch was already successfully
    loaded.

No post-patch, pre-unpatch, or post-unpatch callbacks will be executed
for a given klp_object if the object failed to patch, due to a failed
pre_patch callback or for any other reason.

If a patch transition is reversed, no pre-unpatch handlers will be run
(this follows the previously mentioned symmetry -- pre-unpatch callbacks
will only occur if their corresponding post-patch callback executed).

If the object did successfully patch, but the patch transition never
started for some reason (e.g., if another object failed to patch),
only the post-unpatch callback will be called.


Example Use-cases
=================

Update global data
------------------

A pre-patch callback can be useful to update a global variable.  For
example, 75ff39ccc1bd ("tcp: make challenge acks less predictable")
changes a global sysctl, as well as patches the tcp_send_challenge_ack()
function.

In this case, if we're being super paranoid, it might make sense to
patch the data *after* patching is complete with a post-patch callback,
so that tcp_send_challenge_ack() could first be changed to read
sysctl_tcp_challenge_ack_limit with READ_ONCE.


Support __init and probe function patches
-----------------------------------------

Although __init and probe functions are not directly livepatch-able, it
may be possible to implement similar updates via pre/post-patch
callbacks.

48900cb6af42 ("virtio-net: drop NETIF_F_FRAGLIST") change the way that
virtnet_probe() initialized its driver's net_device features.  A
pre/post-patch callback could iterate over all such devices, making a
similar change to their hw_features value.  (Client functions of the
value may need to be updated accordingly.)


Test cases
==========

What follows is not an exhaustive test suite of every possible livepatch
pre/post-(un)patch combination, but a selection that demonstrates a few
important concepts.  Each test case uses the kernel modules located in
the samples/livepatch/ and assumes that no livepatches are loaded at the
beginning of the test.


Test 1
------

Test a combination of loading a kernel module and a livepatch that
patches a function in the first module.  (Un)load the target module
before the livepatch module:

- load target module
- load livepatch
- disable livepatch
- unload target module
- unload livepatch

First load a target module:

  % insmod samples/livepatch/livepatch-callbacks-mod.ko
  [   34.475708] livepatch_callbacks_mod: livepatch_callbacks_mod_init

On livepatch enable, before the livepatch transition starts, pre-patch
callbacks are executed for vmlinux and livepatch_callbacks_mod (those
klp_objects currently loaded).  After klp_objects are patched according
to the klp_patch, their post-patch callbacks run and the transition
completes:

  % insmod samples/livepatch/livepatch-callbacks-demo.ko
  [   36.503719] livepatch: enabling patch 'livepatch_callbacks_demo'
  [   36.504213] livepatch: 'livepatch_callbacks_demo': initializing patching transition
  [   36.504238] livepatch_callbacks_demo: pre_patch_callback: vmlinux
  [   36.504721] livepatch_callbacks_demo: pre_patch_callback: livepatch_callbacks_mod -> [MODULE_STATE_LIVE] Normal state
  [   36.505849] livepatch: 'livepatch_callbacks_demo': starting patching transition
  [   37.727133] livepatch: 'livepatch_callbacks_demo': completing patching transition
  [   37.727232] livepatch_callbacks_demo: post_patch_callback: vmlinux
  [   37.727860] livepatch_callbacks_demo: post_patch_callback: livepatch_callbacks_mod -> [MODULE_STATE_LIVE] Normal state
  [   37.728792] livepatch: 'livepatch_callbacks_demo': patching complete

Similarly, on livepatch disable, pre-patch callbacks run before the
unpatching transition starts.  klp_objects are reverted, post-patch
callbacks execute and the transition completes:

  % echo 0 > /sys/kernel/livepatch/livepatch_callbacks_demo/enabled
  [   38.510209] livepatch: 'livepatch_callbacks_demo': initializing unpatching transition
  [   38.510234] livepatch_callbacks_demo: pre_unpatch_callback: vmlinux
  [   38.510982] livepatch_callbacks_demo: pre_unpatch_callback: livepatch_callbacks_mod -> [MODULE_STATE_LIVE] Normal state
  [   38.512209] livepatch: 'livepatch_callbacks_demo': starting unpatching transition
  [   39.711132] livepatch: 'livepatch_callbacks_demo': completing unpatching transition
  [   39.711210] livepatch_callbacks_demo: post_unpatch_callback: vmlinux
  [   39.711779] livepatch_callbacks_demo: post_unpatch_callback: livepatch_callbacks_mod -> [MODULE_STATE_LIVE] Normal state
  [   39.712735] livepatch: 'livepatch_callbacks_demo': unpatching complete

  % rmmod samples/livepatch/livepatch-callbacks-demo.ko
  % rmmod samples/livepatch/livepatch-callbacks-mod.ko
  [   42.534183] livepatch_callbacks_mod: livepatch_callbacks_mod_exit


Test 2
------

This test is similar to the previous test, but (un)load the livepatch
module before the target kernel module.  This tests the livepatch core's
module_coming handler:

- load livepatch
- load target module
- disable livepatch
- unload livepatch
- unload target module


On livepatch enable, only pre/post-patch callbacks are executed for
currently loaded klp_objects, in this case, vmlinux:

  % insmod samples/livepatch/livepatch-callbacks-demo.ko
  [   44.553328] livepatch: enabling patch 'livepatch_callbacks_demo'
  [   44.553997] livepatch: 'livepatch_callbacks_demo': initializing patching transition
  [   44.554049] livepatch_callbacks_demo: pre_patch_callback: vmlinux
  [   44.554845] livepatch: 'livepatch_callbacks_demo': starting patching transition
  [   45.727128] livepatch: 'livepatch_callbacks_demo': completing patching transition
  [   45.727212] livepatch_callbacks_demo: post_patch_callback: vmlinux
  [   45.727961] livepatch: 'livepatch_callbacks_demo': patching complete

When a targeted module is subsequently loaded, only its pre/post-patch
callbacks are executed:

  % insmod samples/livepatch/livepatch-callbacks-mod.ko
  [   46.560845] livepatch: applying patch 'livepatch_callbacks_demo' to loading module 'livepatch_callbacks_mod'
  [   46.561988] livepatch_callbacks_demo: pre_patch_callback: livepatch_callbacks_mod -> [MODULE_STATE_COMING] Full formed, running module_init
  [   46.563452] livepatch_callbacks_demo: post_patch_callback: livepatch_callbacks_mod -> [MODULE_STATE_COMING] Full formed, running module_init
  [   46.565495] livepatch_callbacks_mod: livepatch_callbacks_mod_init

On livepatch disable, all currently loaded klp_objects' (vmlinux and
livepatch_callbacks_mod) pre/post-unpatch callbacks are executed:

  % echo 0 > /sys/kernel/livepatch/livepatch_callbacks_demo/enabled
  [   48.568885] livepatch: 'livepatch_callbacks_demo': initializing unpatching transition
  [   48.568910] livepatch_callbacks_demo: pre_unpatch_callback: vmlinux
  [   48.569441] livepatch_callbacks_demo: pre_unpatch_callback: livepatch_callbacks_mod -> [MODULE_STATE_LIVE] Normal state
  [   48.570502] livepatch: 'livepatch_callbacks_demo': starting unpatching transition
  [   49.759091] livepatch: 'livepatch_callbacks_demo': completing unpatching transition
  [   49.759171] livepatch_callbacks_demo: post_unpatch_callback: vmlinux
  [   49.759742] livepatch_callbacks_demo: post_unpatch_callback: livepatch_callbacks_mod -> [MODULE_STATE_LIVE] Normal state
  [   49.760690] livepatch: 'livepatch_callbacks_demo': unpatching complete

  % rmmod samples/livepatch/livepatch-callbacks-demo.ko
  % rmmod samples/livepatch/livepatch-callbacks-mod.ko
  [   52.592283] livepatch_callbacks_mod: livepatch_callbacks_mod_exit


Test 3
------

Test loading the livepatch after a targeted kernel module, then unload
the kernel module before disabling the livepatch.  This tests the
livepatch core's module_going handler:

- load target module
- load livepatch
- unload target module
- disable livepatch
- unload livepatch

First load a target module, then the livepatch:

  % insmod samples/livepatch/livepatch-callbacks-mod.ko
  [   54.607948] livepatch_callbacks_mod: livepatch_callbacks_mod_init

  % insmod samples/livepatch/livepatch-callbacks-demo.ko
  [   56.613919] livepatch: enabling patch 'livepatch_callbacks_demo'
  [   56.614411] livepatch: 'livepatch_callbacks_demo': initializing patching transition
  [   56.614436] livepatch_callbacks_demo: pre_patch_callback: vmlinux
  [   56.614818] livepatch_callbacks_demo: pre_patch_callback: livepatch_callbacks_mod -> [MODULE_STATE_LIVE] Normal state
  [   56.615656] livepatch: 'livepatch_callbacks_demo': starting patching transition
  [   57.759070] livepatch: 'livepatch_callbacks_demo': completing patching transition
  [   57.759147] livepatch_callbacks_demo: post_patch_callback: vmlinux
  [   57.759621] livepatch_callbacks_demo: post_patch_callback: livepatch_callbacks_mod -> [MODULE_STATE_LIVE] Normal state
  [   57.760307] livepatch: 'livepatch_callbacks_demo': patching complete

When a target module is unloaded, the livepatch is only reverted from
that klp_object (livepatch_callbacks_mod).  As such, only its pre and
post-unpatch callbacks are executed when this occurs:

  % rmmod samples/livepatch/livepatch-callbacks-mod.ko
  [   58.623409] livepatch_callbacks_mod: livepatch_callbacks_mod_exit
  [   58.623903] livepatch_callbacks_demo: pre_unpatch_callback: livepatch_callbacks_mod -> [MODULE_STATE_GOING] Going away
  [   58.624658] livepatch: reverting patch 'livepatch_callbacks_demo' on unloading module 'livepatch_callbacks_mod'
  [   58.625305] livepatch_callbacks_demo: post_unpatch_callback: livepatch_callbacks_mod -> [MODULE_STATE_GOING] Going away

When the livepatch is disabled, pre and post-unpatch callbacks are run
for the remaining klp_object, vmlinux:

  % echo 0 > /sys/kernel/livepatch/livepatch_callbacks_demo/enabled
  [   60.638420] livepatch: 'livepatch_callbacks_demo': initializing unpatching transition
  [   60.638444] livepatch_callbacks_demo: pre_unpatch_callback: vmlinux
  [   60.638996] livepatch: 'livepatch_callbacks_demo': starting unpatching transition
  [   61.727088] livepatch: 'livepatch_callbacks_demo': completing unpatching transition
  [   61.727165] livepatch_callbacks_demo: post_unpatch_callback: vmlinux
  [   61.727985] livepatch: 'livepatch_callbacks_demo': unpatching complete

  % rmmod samples/livepatch/livepatch-callbacks-demo.ko


Test 4
------

This test is similar to the previous test, however the livepatch is
loaded first.  This tests the livepatch core's module_coming and
module_going handlers:

- load livepatch
- load target module
- unload target module
- disable livepatch
- unload livepatch

First load the livepatch:

  % insmod samples/livepatch/livepatch-callbacks-demo.ko
  [   64.661552] livepatch: enabling patch 'livepatch_callbacks_demo'
  [   64.662147] livepatch: 'livepatch_callbacks_demo': initializing patching transition
  [   64.662175] livepatch_callbacks_demo: pre_patch_callback: vmlinux
  [   64.662850] livepatch: 'livepatch_callbacks_demo': starting patching transition
  [   65.695056] livepatch: 'livepatch_callbacks_demo': completing patching transition
  [   65.695147] livepatch_callbacks_demo: post_patch_callback: vmlinux
  [   65.695561] livepatch: 'livepatch_callbacks_demo': patching complete

When a targeted kernel module is subsequently loaded, only its
pre/post-patch callbacks are executed:

  % insmod samples/livepatch/livepatch-callbacks-mod.ko
  [   66.669196] livepatch: applying patch 'livepatch_callbacks_demo' to loading module 'livepatch_callbacks_mod'
  [   66.669882] livepatch_callbacks_demo: pre_patch_callback: livepatch_callbacks_mod -> [MODULE_STATE_COMING] Full formed, running module_init
  [   66.670744] livepatch_callbacks_demo: post_patch_callback: livepatch_callbacks_mod -> [MODULE_STATE_COMING] Full formed, running module_init
  [   66.672873] livepatch_callbacks_mod: livepatch_callbacks_mod_init

When the target module is unloaded, the livepatch is only reverted from
the livepatch_callbacks_mod klp_object.  As such, only pre and
post-unpatch callbacks are executed when this occurs:

  % rmmod samples/livepatch/livepatch-callbacks-mod.ko
  [   68.680065] livepatch_callbacks_mod: livepatch_callbacks_mod_exit
  [   68.680688] livepatch_callbacks_demo: pre_unpatch_callback: livepatch_callbacks_mod -> [MODULE_STATE_GOING] Going away
  [   68.681452] livepatch: reverting patch 'livepatch_callbacks_demo' on unloading module 'livepatch_callbacks_mod'
  [   68.682094] livepatch_callbacks_demo: post_unpatch_callback: livepatch_callbacks_mod -> [MODULE_STATE_GOING] Going away

  % echo 0 > /sys/kernel/livepatch/livepatch_callbacks_demo/enabled
  [   70.689225] livepatch: 'livepatch_callbacks_demo': initializing unpatching transition
  [   70.689256] livepatch_callbacks_demo: pre_unpatch_callback: vmlinux
  [   70.689882] livepatch: 'livepatch_callbacks_demo': starting unpatching transition
  [   71.711080] livepatch: 'livepatch_callbacks_demo': completing unpatching transition
  [   71.711481] livepatch_callbacks_demo: post_unpatch_callback: vmlinux
  [   71.711988] livepatch: 'livepatch_callbacks_demo': unpatching complete

  % rmmod samples/livepatch/livepatch-callbacks-demo.ko


Test 5
------

A simple test of loading a livepatch without one of its patch target
klp_objects ever loaded (livepatch_callbacks_mod):

- load livepatch
- disable livepatch
- unload livepatch

Load the livepatch:

  % insmod samples/livepatch/livepatch-callbacks-demo.ko
  [   74.711081] livepatch: enabling patch 'livepatch_callbacks_demo'
  [   74.711595] livepatch: 'livepatch_callbacks_demo': initializing patching transition
  [   74.711639] livepatch_callbacks_demo: pre_patch_callback: vmlinux
  [   74.712272] livepatch: 'livepatch_callbacks_demo': starting patching transition
  [   75.743137] livepatch: 'livepatch_callbacks_demo': completing patching transition
  [   75.743219] livepatch_callbacks_demo: post_patch_callback: vmlinux
  [   75.743867] livepatch: 'livepatch_callbacks_demo': patching complete

As expected, only pre/post-(un)patch handlers are executed for vmlinux:

  % echo 0 > /sys/kernel/livepatch/livepatch_callbacks_demo/enabled
  [   76.716254] livepatch: 'livepatch_callbacks_demo': initializing unpatching transition
  [   76.716278] livepatch_callbacks_demo: pre_unpatch_callback: vmlinux
  [   76.716666] livepatch: 'livepatch_callbacks_demo': starting unpatching transition
  [   77.727089] livepatch: 'livepatch_callbacks_demo': completing unpatching transition
  [   77.727194] livepatch_callbacks_demo: post_unpatch_callback: vmlinux
  [   77.727907] livepatch: 'livepatch_callbacks_demo': unpatching complete

  % rmmod samples/livepatch/livepatch-callbacks-demo.ko


Test 6
------

Test a scenario where a vmlinux pre-patch callback returns a non-zero
status (ie, failure):

- load target module
- load livepatch -ENODEV
- unload target module

First load a target module:

  % insmod samples/livepatch/livepatch-callbacks-mod.ko
  [   80.740520] livepatch_callbacks_mod: livepatch_callbacks_mod_init

Load the livepatch module, setting its 'pre_patch_ret' value to -19
(-ENODEV).  When its vmlinux pre-patch callback executed, this status
code will propagate back to the module-loading subsystem.  The result is
that the insmod command refuses to load the livepatch module:

  % insmod samples/livepatch/livepatch-callbacks-demo.ko pre_patch_ret=-19
  [   82.747326] livepatch: enabling patch 'livepatch_callbacks_demo'
  [   82.747743] livepatch: 'livepatch_callbacks_demo': initializing patching transition
  [   82.747767] livepatch_callbacks_demo: pre_patch_callback: vmlinux
  [   82.748237] livepatch: pre-patch callback failed for object 'vmlinux'
  [   82.748637] livepatch: failed to enable patch 'livepatch_callbacks_demo'
  [   82.749059] livepatch: 'livepatch_callbacks_demo': canceling transition, going to unpatch
  [   82.749060] livepatch: 'livepatch_callbacks_demo': completing unpatching transition
  [   82.749868] livepatch: 'livepatch_callbacks_demo': unpatching complete
  [   82.765809] insmod: ERROR: could not insert module samples/livepatch/livepatch-callbacks-demo.ko: No such device

  % rmmod samples/livepatch/livepatch-callbacks-mod.ko
  [   84.774238] livepatch_callbacks_mod: livepatch_callbacks_mod_exit


Test 7
------

Similar to the previous test, setup a livepatch such that its vmlinux
pre-patch callback returns success.  However, when a targeted kernel
module is later loaded, have the livepatch return a failing status code:

- load livepatch
- setup -ENODEV
- load target module
- disable livepatch
- unload livepatch

Load the livepatch, notice vmlinux pre-patch callback succeeds:

  % insmod samples/livepatch/livepatch-callbacks-demo.ko
  [   86.787845] livepatch: enabling patch 'livepatch_callbacks_demo'
  [   86.788325] livepatch: 'livepatch_callbacks_demo': initializing patching transition
  [   86.788427] livepatch_callbacks_demo: pre_patch_callback: vmlinux
  [   86.788821] livepatch: 'livepatch_callbacks_demo': starting patching transition
  [   87.711069] livepatch: 'livepatch_callbacks_demo': completing patching transition
  [   87.711143] livepatch_callbacks_demo: post_patch_callback: vmlinux
  [   87.711886] livepatch: 'livepatch_callbacks_demo': patching complete

Set a trap so subsequent pre-patch callbacks to this livepatch will
return -ENODEV:

  % echo -19 > /sys/module/livepatch_callbacks_demo/parameters/pre_patch_ret

The livepatch pre-patch callback for subsequently loaded target modules
will return failure, so the module loader refuses to load the kernel
module.  Notice that no post-patch or pre/post-unpatch callbacks are
executed for this klp_object:

  % insmod samples/livepatch/livepatch-callbacks-mod.ko
  [   90.796976] livepatch: applying patch 'livepatch_callbacks_demo' to loading module 'livepatch_callbacks_mod'
  [   90.797834] livepatch_callbacks_demo: pre_patch_callback: livepatch_callbacks_mod -> [MODULE_STATE_COMING] Full formed, running module_init
  [   90.798900] livepatch: pre-patch callback failed for object 'livepatch_callbacks_mod'
  [   90.799652] livepatch: patch 'livepatch_callbacks_demo' failed for module 'livepatch_callbacks_mod', refusing to load module 'livepatch_callbacks_mod'
  [   90.819737] insmod: ERROR: could not insert module samples/livepatch/livepatch-callbacks-mod.ko: No such device

However, pre/post-unpatch callbacks run for the vmlinux klp_object:

  % echo 0 > /sys/kernel/livepatch/livepatch_callbacks_demo/enabled
  [   92.823547] livepatch: 'livepatch_callbacks_demo': initializing unpatching transition
  [   92.823573] livepatch_callbacks_demo: pre_unpatch_callback: vmlinux
  [   92.824331] livepatch: 'livepatch_callbacks_demo': starting unpatching transition
  [   93.727128] livepatch: 'livepatch_callbacks_demo': completing unpatching transition
  [   93.727327] livepatch_callbacks_demo: post_unpatch_callback: vmlinux
  [   93.727861] livepatch: 'livepatch_callbacks_demo': unpatching complete

  % rmmod samples/livepatch/livepatch-callbacks-demo.ko


Test 8
------

Test loading multiple targeted kernel modules.  This test-case is
mainly for comparing with the next test-case.

- load busy target module (0s sleep),
- load livepatch
- load target module
- unload target module
- disable livepatch
- unload livepatch
- unload busy target module


Load a target "busy" kernel module which kicks off a worker function
that immediately exits:

  % insmod samples/livepatch/livepatch-callbacks-busymod.ko sleep_secs=0
  [   96.910107] livepatch_callbacks_busymod: livepatch_callbacks_mod_init
  [   96.910600] livepatch_callbacks_busymod: busymod_work_func, sleeping 0 seconds ...
  [   96.913024] livepatch_callbacks_busymod: busymod_work_func exit

Proceed with loading the livepatch and another ordinary target module,
notice that the post-patch callbacks are executed and the transition
completes quickly:

  % insmod samples/livepatch/livepatch-callbacks-demo.ko
  [   98.917892] livepatch: enabling patch 'livepatch_callbacks_demo'
  [   98.918426] livepatch: 'livepatch_callbacks_demo': initializing patching transition
  [   98.918453] livepatch_callbacks_demo: pre_patch_callback: vmlinux
  [   98.918955] livepatch_callbacks_demo: pre_patch_callback: livepatch_callbacks_busymod -> [MODULE_STATE_LIVE] Normal state
  [   98.923835] livepatch: 'livepatch_callbacks_demo': starting patching transition
  [   99.743104] livepatch: 'livepatch_callbacks_demo': completing patching transition
  [   99.743156] livepatch_callbacks_demo: post_patch_callback: vmlinux
  [   99.743679] livepatch_callbacks_demo: post_patch_callback: livepatch_callbacks_busymod -> [MODULE_STATE_LIVE] Normal state
  [   99.744616] livepatch: 'livepatch_callbacks_demo': patching complete

  % insmod samples/livepatch/livepatch-callbacks-mod.ko
  [  100.930955] livepatch: applying patch 'livepatch_callbacks_demo' to loading module 'livepatch_callbacks_mod'
  [  100.931668] livepatch_callbacks_demo: pre_patch_callback: livepatch_callbacks_mod -> [MODULE_STATE_COMING] Full formed, running module_init
  [  100.932645] livepatch_callbacks_demo: post_patch_callback: livepatch_callbacks_mod -> [MODULE_STATE_COMING] Full formed, running module_init
  [  100.934125] livepatch_callbacks_mod: livepatch_callbacks_mod_init

  % rmmod samples/livepatch/livepatch-callbacks-mod.ko
  [  102.942805] livepatch_callbacks_mod: livepatch_callbacks_mod_exit
  [  102.943640] livepatch_callbacks_demo: pre_unpatch_callback: livepatch_callbacks_mod -> [MODULE_STATE_GOING] Going away
  [  102.944585] livepatch: reverting patch 'livepatch_callbacks_demo' on unloading module 'livepatch_callbacks_mod'
  [  102.945455] livepatch_callbacks_demo: post_unpatch_callback: livepatch_callbacks_mod -> [MODULE_STATE_GOING] Going away

  % echo 0 > /sys/kernel/livepatch/livepatch_callbacks_demo/enabled
  [  104.953815] livepatch: 'livepatch_callbacks_demo': initializing unpatching transition
  [  104.953838] livepatch_callbacks_demo: pre_unpatch_callback: vmlinux
  [  104.954431] livepatch_callbacks_demo: pre_unpatch_callback: livepatch_callbacks_busymod -> [MODULE_STATE_LIVE] Normal state
  [  104.955426] livepatch: 'livepatch_callbacks_demo': starting unpatching transition
  [  106.719073] livepatch: 'livepatch_callbacks_demo': completing unpatching transition
  [  106.722633] livepatch_callbacks_demo: post_unpatch_callback: vmlinux
  [  106.723282] livepatch_callbacks_demo: post_unpatch_callback: livepatch_callbacks_busymod -> [MODULE_STATE_LIVE] Normal state
  [  106.724279] livepatch: 'livepatch_callbacks_demo': unpatching complete

  % rmmod samples/livepatch/livepatch-callbacks-demo.ko
  % rmmod samples/livepatch/livepatch-callbacks-busymod.ko
  [  108.975660] livepatch_callbacks_busymod: livepatch_callbacks_mod_exit


Test 9
------

A similar test as the previous one, but force the "busy" kernel module
to do longer work.

The livepatching core will refuse to patch a task that is currently
executing a to-be-patched function -- the consistency model stalls the
current patch transition until this safety-check is met.  Test a
scenario where one of a livepatch's target klp_objects sits on such a
function for a long time.  Meanwhile, load and unload other target
kernel modules while the livepatch transition is in progress.

- load busy target module (30s sleep)
- load livepatch
- load target module
- unload target module
- disable livepatch
- unload livepatch
- unload busy target module


Load the "busy" kernel module, this time make it do 30 seconds worth of
work:

  % insmod samples/livepatch/livepatch-callbacks-busymod.ko sleep_secs=30
  [  110.993362] livepatch_callbacks_busymod: livepatch_callbacks_mod_init
  [  110.994059] livepatch_callbacks_busymod: busymod_work_func, sleeping 30 seconds ...

Meanwhile, the livepatch is loaded.  Notice that the patch transition
does not complete as the targeted "busy" module is sitting on a
to-be-patched function:

  % insmod samples/livepatch/livepatch-callbacks-demo.ko
  [  113.000309] livepatch: enabling patch 'livepatch_callbacks_demo'
  [  113.000764] livepatch: 'livepatch_callbacks_demo': initializing patching transition
  [  113.000791] livepatch_callbacks_demo: pre_patch_callback: vmlinux
  [  113.001289] livepatch_callbacks_demo: pre_patch_callback: livepatch_callbacks_busymod -> [MODULE_STATE_LIVE] Normal state
  [  113.005208] livepatch: 'livepatch_callbacks_demo': starting patching transition

Load a second target module (this one is an ordinary idle kernel
module).  Note that *no* post-patch callbacks will be executed while the
livepatch is still in transition:

  % insmod samples/livepatch/livepatch-callbacks-mod.ko
  [  115.012740] livepatch: applying patch 'livepatch_callbacks_demo' to loading module 'livepatch_callbacks_mod'
  [  115.013406] livepatch_callbacks_demo: pre_patch_callback: livepatch_callbacks_mod -> [MODULE_STATE_COMING] Full formed, running module_init
  [  115.015315] livepatch_callbacks_mod: livepatch_callbacks_mod_init

Request an unload of the simple kernel module.  The patch is still
transitioning, so its pre-unpatch callbacks are skipped:

  % rmmod samples/livepatch/livepatch-callbacks-mod.ko
  [  117.022626] livepatch_callbacks_mod: livepatch_callbacks_mod_exit
  [  117.023376] livepatch: reverting patch 'livepatch_callbacks_demo' on unloading module 'livepatch_callbacks_mod'
  [  117.024533] livepatch_callbacks_demo: post_unpatch_callback: livepatch_callbacks_mod -> [MODULE_STATE_GOING] Going away

Finally the livepatch is disabled.  Since none of the patch's
klp_object's post-patch callbacks executed, the remaining klp_object's
pre-unpatch callbacks are skipped:

  % echo 0 > /sys/kernel/livepatch/livepatch_callbacks_demo/enabled
  [  119.035408] livepatch: 'livepatch_callbacks_demo': reversing transition from patching to unpatching
  [  119.035485] livepatch: 'livepatch_callbacks_demo': starting unpatching transition
  [  119.711166] livepatch: 'livepatch_callbacks_demo': completing unpatching transition
  [  119.714179] livepatch_callbacks_demo: post_unpatch_callback: vmlinux
  [  119.714653] livepatch_callbacks_demo: post_unpatch_callback: livepatch_callbacks_busymod -> [MODULE_STATE_LIVE] Normal state
  [  119.715437] livepatch: 'livepatch_callbacks_demo': unpatching complete

  % rmmod samples/livepatch/livepatch-callbacks-demo.ko
  % rmmod samples/livepatch/livepatch-callbacks-busymod.ko
  [  141.279111] livepatch_callbacks_busymod: busymod_work_func exit
  [  141.279760] livepatch_callbacks_busymod: livepatch_callbacks_mod_exit
