| @@ -0,0 +1,605 @@ |
| 1 | +====================== |
| 2 | +(Un)patching Callbacks |
| 3 | +====================== |
| 4 | + |
| 5 | +Livepatch (un)patch-callbacks provide a mechanism for livepatch modules |
| 6 | +to execute callback functions when a kernel object is (un)patched. They |
| 7 | +can be considered a "power feature" that extends livepatching abilities |
| 8 | +to include: |
| 9 | + |
| 10 | + - Safe updates to global data |
| 11 | + |
| 12 | + - "Patches" to init and probe functions |
| 13 | + |
| 14 | + - Patching otherwise unpatchable code (i.e. assembly) |
| 15 | + |
| 16 | +In most cases, (un)patch callbacks will need to be used in conjunction |
| 17 | +with memory barriers and kernel synchronization primitives, like |
| 18 | +mutexes/spinlocks, or even stop_machine(), to avoid concurrency issues. |
| 19 | + |
| 20 | +Callbacks differ from existing kernel facilities: |
| 21 | + |
| 22 | + - Module init/exit code doesn't run when disabling and re-enabling a |
| 23 | + patch. |
| 24 | + |
| 25 | + - A module notifier can't stop a to-be-patched module from loading. |
| 26 | + |
| 27 | +Callbacks are part of the klp_object structure and their implementation |
| 28 | +is specific to that klp_object. Other livepatch objects may or may not |
| 29 | +be patched, irrespective of the target klp_object's current state. |
| 30 | + |
| 31 | +Callbacks can be registered for the following livepatch actions: |
| 32 | + |
| 33 | + * Pre-patch - before a klp_object is patched |
| 34 | + |
| 35 | + * Post-patch - after a klp_object has been patched and is active |
| 36 | + across all tasks |
| 37 | + |
| 38 | + * Pre-unpatch - before a klp_object is unpatched (ie, patched code is |
| 39 | + active), used to clean up post-patch callback |
| 40 | + resources |
| 41 | + |
| 42 | + * Post-unpatch - after a klp_object has been patched, all code has |
| 43 | + been restored and no tasks are running patched code, |
| 44 | + used to cleanup pre-patch callback resources |
| 45 | + |
| 46 | +Each callback is optional, omitting one does not preclude specifying any |
| 47 | +other. However, the livepatching core executes the handlers in |
| 48 | +symmetry: pre-patch callbacks have a post-unpatch counterpart and |
| 49 | +post-patch callbacks have a pre-unpatch counterpart. An unpatch |
| 50 | +callback will only be executed if its corresponding patch callback was |
| 51 | +executed. Typical use cases pair a patch handler that acquires and |
| 52 | +configures resources with an unpatch handler tears down and releases |
| 53 | +those same resources. |
| 54 | + |
| 55 | +A callback is only executed if its host klp_object is loaded. For |
| 56 | +in-kernel vmlinux targets, this means that callbacks will always execute |
| 57 | +when a livepatch is enabled/disabled. For patch target kernel modules, |
| 58 | +callbacks will only execute if the target module is loaded. When a |
| 59 | +module target is (un)loaded, its callbacks will execute only if the |
| 60 | +livepatch module is enabled. |
| 61 | + |
| 62 | +The pre-patch callback, if specified, is expected to return a status |
| 63 | +code (0 for success, -ERRNO on error). An error status code indicates |
| 64 | +to the livepatching core that patching of the current klp_object is not |
| 65 | +safe and to stop the current patching request. (When no pre-patch |
| 66 | +callback is provided, the transition is assumed to be safe.) If a |
| 67 | +pre-patch callback returns failure, the kernel's module loader will: |
| 68 | + |
| 69 | + - Refuse to load a livepatch, if the livepatch is loaded after |
| 70 | + targeted code. |
| 71 | + |
| 72 | + or: |
| 73 | + |
| 74 | + - Refuse to load a module, if the livepatch was already successfully |
| 75 | + loaded. |
| 76 | + |
| 77 | +No post-patch, pre-unpatch, or post-unpatch callbacks will be executed |
| 78 | +for a given klp_object if the object failed to patch, due to a failed |
| 79 | +pre_patch callback or for any other reason. |
| 80 | + |
| 81 | +If a patch transition is reversed, no pre-unpatch handlers will be run |
| 82 | +(this follows the previously mentioned symmetry -- pre-unpatch callbacks |
| 83 | +will only occur if their corresponding post-patch callback executed). |
| 84 | + |
| 85 | +If the object did successfully patch, but the patch transition never |
| 86 | +started for some reason (e.g., if another object failed to patch), |
| 87 | +only the post-unpatch callback will be called. |
| 88 | + |
| 89 | + |
| 90 | +Example Use-cases |
| 91 | +================= |
| 92 | + |
| 93 | +Update global data |
| 94 | +------------------ |
| 95 | + |
| 96 | +A pre-patch callback can be useful to update a global variable. For |
| 97 | +example, 75ff39ccc1bd ("tcp: make challenge acks less predictable") |
| 98 | +changes a global sysctl, as well as patches the tcp_send_challenge_ack() |
| 99 | +function. |
| 100 | + |
| 101 | +In this case, if we're being super paranoid, it might make sense to |
| 102 | +patch the data *after* patching is complete with a post-patch callback, |
| 103 | +so that tcp_send_challenge_ack() could first be changed to read |
| 104 | +sysctl_tcp_challenge_ack_limit with READ_ONCE. |
| 105 | + |
| 106 | + |
| 107 | +Support __init and probe function patches |
| 108 | +----------------------------------------- |
| 109 | + |
| 110 | +Although __init and probe functions are not directly livepatch-able, it |
| 111 | +may be possible to implement similar updates via pre/post-patch |
| 112 | +callbacks. |
| 113 | + |
| 114 | +48900cb6af42 ("virtio-net: drop NETIF_F_FRAGLIST") change the way that |
| 115 | +virtnet_probe() initialized its driver's net_device features. A |
| 116 | +pre/post-patch callback could iterate over all such devices, making a |
| 117 | +similar change to their hw_features value. (Client functions of the |
| 118 | +value may need to be updated accordingly.) |
| 119 | + |
| 120 | + |
| 121 | +Test cases |
| 122 | +========== |
| 123 | + |
| 124 | +What follows is not an exhaustive test suite of every possible livepatch |
| 125 | +pre/post-(un)patch combination, but a selection that demonstrates a few |
| 126 | +important concepts. Each test case uses the kernel modules located in |
| 127 | +the samples/livepatch/ and assumes that no livepatches are loaded at the |
| 128 | +beginning of the test. |
| 129 | + |
| 130 | + |
| 131 | +Test 1 |
| 132 | +------ |
| 133 | + |
| 134 | +Test a combination of loading a kernel module and a livepatch that |
| 135 | +patches a function in the first module. (Un)load the target module |
| 136 | +before the livepatch module: |
| 137 | + |
| 138 | +- load target module |
| 139 | +- load livepatch |
| 140 | +- disable livepatch |
| 141 | +- unload target module |
| 142 | +- unload livepatch |
| 143 | + |
| 144 | +First load a target module: |
| 145 | + |
| 146 | + % insmod samples/livepatch/livepatch-callbacks-mod.ko |
| 147 | + [ 34.475708] livepatch_callbacks_mod: livepatch_callbacks_mod_init |
| 148 | + |
| 149 | +On livepatch enable, before the livepatch transition starts, pre-patch |
| 150 | +callbacks are executed for vmlinux and livepatch_callbacks_mod (those |
| 151 | +klp_objects currently loaded). After klp_objects are patched according |
| 152 | +to the klp_patch, their post-patch callbacks run and the transition |
| 153 | +completes: |
| 154 | + |
| 155 | + % insmod samples/livepatch/livepatch-callbacks-demo.ko |
| 156 | + [ 36.503719] livepatch: enabling patch 'livepatch_callbacks_demo' |
| 157 | + [ 36.504213] livepatch: 'livepatch_callbacks_demo': initializing patching transition |
| 158 | + [ 36.504238] livepatch_callbacks_demo: pre_patch_callback: vmlinux |
| 159 | + [ 36.504721] livepatch_callbacks_demo: pre_patch_callback: livepatch_callbacks_mod -> [MODULE_STATE_LIVE] Normal state |
| 160 | + [ 36.505849] livepatch: 'livepatch_callbacks_demo': starting patching transition |
| 161 | + [ 37.727133] livepatch: 'livepatch_callbacks_demo': completing patching transition |
| 162 | + [ 37.727232] livepatch_callbacks_demo: post_patch_callback: vmlinux |
| 163 | + [ 37.727860] livepatch_callbacks_demo: post_patch_callback: livepatch_callbacks_mod -> [MODULE_STATE_LIVE] Normal state |
| 164 | + [ 37.728792] livepatch: 'livepatch_callbacks_demo': patching complete |
| 165 | + |
| 166 | +Similarly, on livepatch disable, pre-patch callbacks run before the |
| 167 | +unpatching transition starts. klp_objects are reverted, post-patch |
| 168 | +callbacks execute and the transition completes: |
| 169 | + |
| 170 | + % echo 0 > /sys/kernel/livepatch/livepatch_callbacks_demo/enabled |
| 171 | + [ 38.510209] livepatch: 'livepatch_callbacks_demo': initializing unpatching transition |
| 172 | + [ 38.510234] livepatch_callbacks_demo: pre_unpatch_callback: vmlinux |
| 173 | + [ 38.510982] livepatch_callbacks_demo: pre_unpatch_callback: livepatch_callbacks_mod -> [MODULE_STATE_LIVE] Normal state |
| 174 | + [ 38.512209] livepatch: 'livepatch_callbacks_demo': starting unpatching transition |
| 175 | + [ 39.711132] livepatch: 'livepatch_callbacks_demo': completing unpatching transition |
| 176 | + [ 39.711210] livepatch_callbacks_demo: post_unpatch_callback: vmlinux |
| 177 | + [ 39.711779] livepatch_callbacks_demo: post_unpatch_callback: livepatch_callbacks_mod -> [MODULE_STATE_LIVE] Normal state |
| 178 | + [ 39.712735] livepatch: 'livepatch_callbacks_demo': unpatching complete |
| 179 | + |
| 180 | + % rmmod samples/livepatch/livepatch-callbacks-demo.ko |
| 181 | + % rmmod samples/livepatch/livepatch-callbacks-mod.ko |
| 182 | + [ 42.534183] livepatch_callbacks_mod: livepatch_callbacks_mod_exit |
| 183 | + |
| 184 | + |
| 185 | +Test 2 |
| 186 | +------ |
| 187 | + |
| 188 | +This test is similar to the previous test, but (un)load the livepatch |
| 189 | +module before the target kernel module. This tests the livepatch core's |
| 190 | +module_coming handler: |
| 191 | + |
| 192 | +- load livepatch |
| 193 | +- load target module |
| 194 | +- disable livepatch |
| 195 | +- unload livepatch |
| 196 | +- unload target module |
| 197 | + |
| 198 | + |
| 199 | +On livepatch enable, only pre/post-patch callbacks are executed for |
| 200 | +currently loaded klp_objects, in this case, vmlinux: |
| 201 | + |
| 202 | + % insmod samples/livepatch/livepatch-callbacks-demo.ko |
| 203 | + [ 44.553328] livepatch: enabling patch 'livepatch_callbacks_demo' |
| 204 | + [ 44.553997] livepatch: 'livepatch_callbacks_demo': initializing patching transition |
| 205 | + [ 44.554049] livepatch_callbacks_demo: pre_patch_callback: vmlinux |
| 206 | + [ 44.554845] livepatch: 'livepatch_callbacks_demo': starting patching transition |
| 207 | + [ 45.727128] livepatch: 'livepatch_callbacks_demo': completing patching transition |
| 208 | + [ 45.727212] livepatch_callbacks_demo: post_patch_callback: vmlinux |
| 209 | + [ 45.727961] livepatch: 'livepatch_callbacks_demo': patching complete |
| 210 | + |
| 211 | +When a targeted module is subsequently loaded, only its pre/post-patch |
| 212 | +callbacks are executed: |
| 213 | + |
| 214 | + % insmod samples/livepatch/livepatch-callbacks-mod.ko |
| 215 | + [ 46.560845] livepatch: applying patch 'livepatch_callbacks_demo' to loading module 'livepatch_callbacks_mod' |
| 216 | + [ 46.561988] livepatch_callbacks_demo: pre_patch_callback: livepatch_callbacks_mod -> [MODULE_STATE_COMING] Full formed, running module_init |
| 217 | + [ 46.563452] livepatch_callbacks_demo: post_patch_callback: livepatch_callbacks_mod -> [MODULE_STATE_COMING] Full formed, running module_init |
| 218 | + [ 46.565495] livepatch_callbacks_mod: livepatch_callbacks_mod_init |
| 219 | + |
| 220 | +On livepatch disable, all currently loaded klp_objects' (vmlinux and |
| 221 | +livepatch_callbacks_mod) pre/post-unpatch callbacks are executed: |
| 222 | + |
| 223 | + % echo 0 > /sys/kernel/livepatch/livepatch_callbacks_demo/enabled |
| 224 | + [ 48.568885] livepatch: 'livepatch_callbacks_demo': initializing unpatching transition |
| 225 | + [ 48.568910] livepatch_callbacks_demo: pre_unpatch_callback: vmlinux |
| 226 | + [ 48.569441] livepatch_callbacks_demo: pre_unpatch_callback: livepatch_callbacks_mod -> [MODULE_STATE_LIVE] Normal state |
| 227 | + [ 48.570502] livepatch: 'livepatch_callbacks_demo': starting unpatching transition |
| 228 | + [ 49.759091] livepatch: 'livepatch_callbacks_demo': completing unpatching transition |
| 229 | + [ 49.759171] livepatch_callbacks_demo: post_unpatch_callback: vmlinux |
| 230 | + [ 49.759742] livepatch_callbacks_demo: post_unpatch_callback: livepatch_callbacks_mod -> [MODULE_STATE_LIVE] Normal state |
| 231 | + [ 49.760690] livepatch: 'livepatch_callbacks_demo': unpatching complete |
| 232 | + |
| 233 | + % rmmod samples/livepatch/livepatch-callbacks-demo.ko |
| 234 | + % rmmod samples/livepatch/livepatch-callbacks-mod.ko |
| 235 | + [ 52.592283] livepatch_callbacks_mod: livepatch_callbacks_mod_exit |
| 236 | + |
| 237 | + |
| 238 | +Test 3 |
| 239 | +------ |
| 240 | + |
| 241 | +Test loading the livepatch after a targeted kernel module, then unload |
| 242 | +the kernel module before disabling the livepatch. This tests the |
| 243 | +livepatch core's module_going handler: |
| 244 | + |
| 245 | +- load target module |
| 246 | +- load livepatch |
| 247 | +- unload target module |
| 248 | +- disable livepatch |
| 249 | +- unload livepatch |
| 250 | + |
| 251 | +First load a target module, then the livepatch: |
| 252 | + |
| 253 | + % insmod samples/livepatch/livepatch-callbacks-mod.ko |
| 254 | + [ 54.607948] livepatch_callbacks_mod: livepatch_callbacks_mod_init |
| 255 | + |
| 256 | + % insmod samples/livepatch/livepatch-callbacks-demo.ko |
| 257 | + [ 56.613919] livepatch: enabling patch 'livepatch_callbacks_demo' |
| 258 | + [ 56.614411] livepatch: 'livepatch_callbacks_demo': initializing patching transition |
| 259 | + [ 56.614436] livepatch_callbacks_demo: pre_patch_callback: vmlinux |
| 260 | + [ 56.614818] livepatch_callbacks_demo: pre_patch_callback: livepatch_callbacks_mod -> [MODULE_STATE_LIVE] Normal state |
| 261 | + [ 56.615656] livepatch: 'livepatch_callbacks_demo': starting patching transition |
| 262 | + [ 57.759070] livepatch: 'livepatch_callbacks_demo': completing patching transition |
| 263 | + [ 57.759147] livepatch_callbacks_demo: post_patch_callback: vmlinux |
| 264 | + [ 57.759621] livepatch_callbacks_demo: post_patch_callback: livepatch_callbacks_mod -> [MODULE_STATE_LIVE] Normal state |
| 265 | + [ 57.760307] livepatch: 'livepatch_callbacks_demo': patching complete |
| 266 | + |
| 267 | +When a target module is unloaded, the livepatch is only reverted from |
| 268 | +that klp_object (livepatch_callbacks_mod). As such, only its pre and |
| 269 | +post-unpatch callbacks are executed when this occurs: |
| 270 | + |
| 271 | + % rmmod samples/livepatch/livepatch-callbacks-mod.ko |
| 272 | + [ 58.623409] livepatch_callbacks_mod: livepatch_callbacks_mod_exit |
| 273 | + [ 58.623903] livepatch_callbacks_demo: pre_unpatch_callback: livepatch_callbacks_mod -> [MODULE_STATE_GOING] Going away |
| 274 | + [ 58.624658] livepatch: reverting patch 'livepatch_callbacks_demo' on unloading module 'livepatch_callbacks_mod' |
| 275 | + [ 58.625305] livepatch_callbacks_demo: post_unpatch_callback: livepatch_callbacks_mod -> [MODULE_STATE_GOING] Going away |
| 276 | + |
| 277 | +When the livepatch is disabled, pre and post-unpatch callbacks are run |
| 278 | +for the remaining klp_object, vmlinux: |
| 279 | + |
| 280 | + % echo 0 > /sys/kernel/livepatch/livepatch_callbacks_demo/enabled |
| 281 | + [ 60.638420] livepatch: 'livepatch_callbacks_demo': initializing unpatching transition |
| 282 | + [ 60.638444] livepatch_callbacks_demo: pre_unpatch_callback: vmlinux |
| 283 | + [ 60.638996] livepatch: 'livepatch_callbacks_demo': starting unpatching transition |
| 284 | + [ 61.727088] livepatch: 'livepatch_callbacks_demo': completing unpatching transition |
| 285 | + [ 61.727165] livepatch_callbacks_demo: post_unpatch_callback: vmlinux |
| 286 | + [ 61.727985] livepatch: 'livepatch_callbacks_demo': unpatching complete |
| 287 | + |
| 288 | + % rmmod samples/livepatch/livepatch-callbacks-demo.ko |
| 289 | + |
| 290 | + |
| 291 | +Test 4 |
| 292 | +------ |
| 293 | + |
| 294 | +This test is similar to the previous test, however the livepatch is |
| 295 | +loaded first. This tests the livepatch core's module_coming and |
| 296 | +module_going handlers: |
| 297 | + |
| 298 | +- load livepatch |
| 299 | +- load target module |
| 300 | +- unload target module |
| 301 | +- disable livepatch |
| 302 | +- unload livepatch |
| 303 | + |
| 304 | +First load the livepatch: |
| 305 | + |
| 306 | + % insmod samples/livepatch/livepatch-callbacks-demo.ko |
| 307 | + [ 64.661552] livepatch: enabling patch 'livepatch_callbacks_demo' |
| 308 | + [ 64.662147] livepatch: 'livepatch_callbacks_demo': initializing patching transition |
| 309 | + [ 64.662175] livepatch_callbacks_demo: pre_patch_callback: vmlinux |
| 310 | + [ 64.662850] livepatch: 'livepatch_callbacks_demo': starting patching transition |
| 311 | + [ 65.695056] livepatch: 'livepatch_callbacks_demo': completing patching transition |
| 312 | + [ 65.695147] livepatch_callbacks_demo: post_patch_callback: vmlinux |
| 313 | + [ 65.695561] livepatch: 'livepatch_callbacks_demo': patching complete |
| 314 | + |
| 315 | +When a targeted kernel module is subsequently loaded, only its |
| 316 | +pre/post-patch callbacks are executed: |
| 317 | + |
| 318 | + % insmod samples/livepatch/livepatch-callbacks-mod.ko |
| 319 | + [ 66.669196] livepatch: applying patch 'livepatch_callbacks_demo' to loading module 'livepatch_callbacks_mod' |
| 320 | + [ 66.669882] livepatch_callbacks_demo: pre_patch_callback: livepatch_callbacks_mod -> [MODULE_STATE_COMING] Full formed, running module_init |
| 321 | + [ 66.670744] livepatch_callbacks_demo: post_patch_callback: livepatch_callbacks_mod -> [MODULE_STATE_COMING] Full formed, running module_init |
| 322 | + [ 66.672873] livepatch_callbacks_mod: livepatch_callbacks_mod_init |
| 323 | + |
| 324 | +When the target module is unloaded, the livepatch is only reverted from |
| 325 | +the livepatch_callbacks_mod klp_object. As such, only pre and |
| 326 | +post-unpatch callbacks are executed when this occurs: |
| 327 | + |
| 328 | + % rmmod samples/livepatch/livepatch-callbacks-mod.ko |
| 329 | + [ 68.680065] livepatch_callbacks_mod: livepatch_callbacks_mod_exit |
| 330 | + [ 68.680688] livepatch_callbacks_demo: pre_unpatch_callback: livepatch_callbacks_mod -> [MODULE_STATE_GOING] Going away |
| 331 | + [ 68.681452] livepatch: reverting patch 'livepatch_callbacks_demo' on unloading module 'livepatch_callbacks_mod' |
| 332 | + [ 68.682094] livepatch_callbacks_demo: post_unpatch_callback: livepatch_callbacks_mod -> [MODULE_STATE_GOING] Going away |
| 333 | + |
| 334 | + % echo 0 > /sys/kernel/livepatch/livepatch_callbacks_demo/enabled |
| 335 | + [ 70.689225] livepatch: 'livepatch_callbacks_demo': initializing unpatching transition |
| 336 | + [ 70.689256] livepatch_callbacks_demo: pre_unpatch_callback: vmlinux |
| 337 | + [ 70.689882] livepatch: 'livepatch_callbacks_demo': starting unpatching transition |
| 338 | + [ 71.711080] livepatch: 'livepatch_callbacks_demo': completing unpatching transition |
| 339 | + [ 71.711481] livepatch_callbacks_demo: post_unpatch_callback: vmlinux |
| 340 | + [ 71.711988] livepatch: 'livepatch_callbacks_demo': unpatching complete |
| 341 | + |
| 342 | + % rmmod samples/livepatch/livepatch-callbacks-demo.ko |
| 343 | + |
| 344 | + |
| 345 | +Test 5 |
| 346 | +------ |
| 347 | + |
| 348 | +A simple test of loading a livepatch without one of its patch target |
| 349 | +klp_objects ever loaded (livepatch_callbacks_mod): |
| 350 | + |
| 351 | +- load livepatch |
| 352 | +- disable livepatch |
| 353 | +- unload livepatch |
| 354 | + |
| 355 | +Load the livepatch: |
| 356 | + |
| 357 | + % insmod samples/livepatch/livepatch-callbacks-demo.ko |
| 358 | + [ 74.711081] livepatch: enabling patch 'livepatch_callbacks_demo' |
| 359 | + [ 74.711595] livepatch: 'livepatch_callbacks_demo': initializing patching transition |
| 360 | + [ 74.711639] livepatch_callbacks_demo: pre_patch_callback: vmlinux |
| 361 | + [ 74.712272] livepatch: 'livepatch_callbacks_demo': starting patching transition |
| 362 | + [ 75.743137] livepatch: 'livepatch_callbacks_demo': completing patching transition |
| 363 | + [ 75.743219] livepatch_callbacks_demo: post_patch_callback: vmlinux |
| 364 | + [ 75.743867] livepatch: 'livepatch_callbacks_demo': patching complete |
| 365 | + |
| 366 | +As expected, only pre/post-(un)patch handlers are executed for vmlinux: |
| 367 | + |
| 368 | + % echo 0 > /sys/kernel/livepatch/livepatch_callbacks_demo/enabled |
| 369 | + [ 76.716254] livepatch: 'livepatch_callbacks_demo': initializing unpatching transition |
| 370 | + [ 76.716278] livepatch_callbacks_demo: pre_unpatch_callback: vmlinux |
| 371 | + [ 76.716666] livepatch: 'livepatch_callbacks_demo': starting unpatching transition |
| 372 | + [ 77.727089] livepatch: 'livepatch_callbacks_demo': completing unpatching transition |
| 373 | + [ 77.727194] livepatch_callbacks_demo: post_unpatch_callback: vmlinux |
| 374 | + [ 77.727907] livepatch: 'livepatch_callbacks_demo': unpatching complete |
| 375 | + |
| 376 | + % rmmod samples/livepatch/livepatch-callbacks-demo.ko |
| 377 | + |
| 378 | + |
| 379 | +Test 6 |
| 380 | +------ |
| 381 | + |
| 382 | +Test a scenario where a vmlinux pre-patch callback returns a non-zero |
| 383 | +status (ie, failure): |
| 384 | + |
| 385 | +- load target module |
| 386 | +- load livepatch -ENODEV |
| 387 | +- unload target module |
| 388 | + |
| 389 | +First load a target module: |
| 390 | + |
| 391 | + % insmod samples/livepatch/livepatch-callbacks-mod.ko |
| 392 | + [ 80.740520] livepatch_callbacks_mod: livepatch_callbacks_mod_init |
| 393 | + |
| 394 | +Load the livepatch module, setting its 'pre_patch_ret' value to -19 |
| 395 | +(-ENODEV). When its vmlinux pre-patch callback executed, this status |
| 396 | +code will propagate back to the module-loading subsystem. The result is |
| 397 | +that the insmod command refuses to load the livepatch module: |
| 398 | + |
| 399 | + % insmod samples/livepatch/livepatch-callbacks-demo.ko pre_patch_ret=-19 |
| 400 | + [ 82.747326] livepatch: enabling patch 'livepatch_callbacks_demo' |
| 401 | + [ 82.747743] livepatch: 'livepatch_callbacks_demo': initializing patching transition |
| 402 | + [ 82.747767] livepatch_callbacks_demo: pre_patch_callback: vmlinux |
| 403 | + [ 82.748237] livepatch: pre-patch callback failed for object 'vmlinux' |
| 404 | + [ 82.748637] livepatch: failed to enable patch 'livepatch_callbacks_demo' |
| 405 | + [ 82.749059] livepatch: 'livepatch_callbacks_demo': canceling transition, going to unpatch |
| 406 | + [ 82.749060] livepatch: 'livepatch_callbacks_demo': completing unpatching transition |
| 407 | + [ 82.749868] livepatch: 'livepatch_callbacks_demo': unpatching complete |
| 408 | + [ 82.765809] insmod: ERROR: could not insert module samples/livepatch/livepatch-callbacks-demo.ko: No such device |
| 409 | + |
| 410 | + % rmmod samples/livepatch/livepatch-callbacks-mod.ko |
| 411 | + [ 84.774238] livepatch_callbacks_mod: livepatch_callbacks_mod_exit |
| 412 | + |
| 413 | + |
| 414 | +Test 7 |
| 415 | +------ |
| 416 | + |
| 417 | +Similar to the previous test, setup a livepatch such that its vmlinux |
| 418 | +pre-patch callback returns success. However, when a targeted kernel |
| 419 | +module is later loaded, have the livepatch return a failing status code: |
| 420 | + |
| 421 | +- load livepatch |
| 422 | +- setup -ENODEV |
| 423 | +- load target module |
| 424 | +- disable livepatch |
| 425 | +- unload livepatch |
| 426 | + |
| 427 | +Load the livepatch, notice vmlinux pre-patch callback succeeds: |
| 428 | + |
| 429 | + % insmod samples/livepatch/livepatch-callbacks-demo.ko |
| 430 | + [ 86.787845] livepatch: enabling patch 'livepatch_callbacks_demo' |
| 431 | + [ 86.788325] livepatch: 'livepatch_callbacks_demo': initializing patching transition |
| 432 | + [ 86.788427] livepatch_callbacks_demo: pre_patch_callback: vmlinux |
| 433 | + [ 86.788821] livepatch: 'livepatch_callbacks_demo': starting patching transition |
| 434 | + [ 87.711069] livepatch: 'livepatch_callbacks_demo': completing patching transition |
| 435 | + [ 87.711143] livepatch_callbacks_demo: post_patch_callback: vmlinux |
| 436 | + [ 87.711886] livepatch: 'livepatch_callbacks_demo': patching complete |
| 437 | + |
| 438 | +Set a trap so subsequent pre-patch callbacks to this livepatch will |
| 439 | +return -ENODEV: |
| 440 | + |
| 441 | + % echo -19 > /sys/module/livepatch_callbacks_demo/parameters/pre_patch_ret |
| 442 | + |
| 443 | +The livepatch pre-patch callback for subsequently loaded target modules |
| 444 | +will return failure, so the module loader refuses to load the kernel |
| 445 | +module. Notice that no post-patch or pre/post-unpatch callbacks are |
| 446 | +executed for this klp_object: |
| 447 | + |
| 448 | + % insmod samples/livepatch/livepatch-callbacks-mod.ko |
| 449 | + [ 90.796976] livepatch: applying patch 'livepatch_callbacks_demo' to loading module 'livepatch_callbacks_mod' |
| 450 | + [ 90.797834] livepatch_callbacks_demo: pre_patch_callback: livepatch_callbacks_mod -> [MODULE_STATE_COMING] Full formed, running module_init |
| 451 | + [ 90.798900] livepatch: pre-patch callback failed for object 'livepatch_callbacks_mod' |
| 452 | + [ 90.799652] livepatch: patch 'livepatch_callbacks_demo' failed for module 'livepatch_callbacks_mod', refusing to load module 'livepatch_callbacks_mod' |
| 453 | + [ 90.819737] insmod: ERROR: could not insert module samples/livepatch/livepatch-callbacks-mod.ko: No such device |
| 454 | + |
| 455 | +However, pre/post-unpatch callbacks run for the vmlinux klp_object: |
| 456 | + |
| 457 | + % echo 0 > /sys/kernel/livepatch/livepatch_callbacks_demo/enabled |
| 458 | + [ 92.823547] livepatch: 'livepatch_callbacks_demo': initializing unpatching transition |
| 459 | + [ 92.823573] livepatch_callbacks_demo: pre_unpatch_callback: vmlinux |
| 460 | + [ 92.824331] livepatch: 'livepatch_callbacks_demo': starting unpatching transition |
| 461 | + [ 93.727128] livepatch: 'livepatch_callbacks_demo': completing unpatching transition |
| 462 | + [ 93.727327] livepatch_callbacks_demo: post_unpatch_callback: vmlinux |
| 463 | + [ 93.727861] livepatch: 'livepatch_callbacks_demo': unpatching complete |
| 464 | + |
| 465 | + % rmmod samples/livepatch/livepatch-callbacks-demo.ko |
| 466 | + |
| 467 | + |
| 468 | +Test 8 |
| 469 | +------ |
| 470 | + |
| 471 | +Test loading multiple targeted kernel modules. This test-case is |
| 472 | +mainly for comparing with the next test-case. |
| 473 | + |
| 474 | +- load busy target module (0s sleep), |
| 475 | +- load livepatch |
| 476 | +- load target module |
| 477 | +- unload target module |
| 478 | +- disable livepatch |
| 479 | +- unload livepatch |
| 480 | +- unload busy target module |
| 481 | + |
| 482 | + |
| 483 | +Load a target "busy" kernel module which kicks off a worker function |
| 484 | +that immediately exits: |
| 485 | + |
| 486 | + % insmod samples/livepatch/livepatch-callbacks-busymod.ko sleep_secs=0 |
| 487 | + [ 96.910107] livepatch_callbacks_busymod: livepatch_callbacks_mod_init |
| 488 | + [ 96.910600] livepatch_callbacks_busymod: busymod_work_func, sleeping 0 seconds ... |
| 489 | + [ 96.913024] livepatch_callbacks_busymod: busymod_work_func exit |
| 490 | + |
| 491 | +Proceed with loading the livepatch and another ordinary target module, |
| 492 | +notice that the post-patch callbacks are executed and the transition |
| 493 | +completes quickly: |
| 494 | + |
| 495 | + % insmod samples/livepatch/livepatch-callbacks-demo.ko |
| 496 | + [ 98.917892] livepatch: enabling patch 'livepatch_callbacks_demo' |
| 497 | + [ 98.918426] livepatch: 'livepatch_callbacks_demo': initializing patching transition |
| 498 | + [ 98.918453] livepatch_callbacks_demo: pre_patch_callback: vmlinux |
| 499 | + [ 98.918955] livepatch_callbacks_demo: pre_patch_callback: livepatch_callbacks_busymod -> [MODULE_STATE_LIVE] Normal state |
| 500 | + [ 98.923835] livepatch: 'livepatch_callbacks_demo': starting patching transition |
| 501 | + [ 99.743104] livepatch: 'livepatch_callbacks_demo': completing patching transition |
| 502 | + [ 99.743156] livepatch_callbacks_demo: post_patch_callback: vmlinux |
| 503 | + [ 99.743679] livepatch_callbacks_demo: post_patch_callback: livepatch_callbacks_busymod -> [MODULE_STATE_LIVE] Normal state |
| 504 | + [ 99.744616] livepatch: 'livepatch_callbacks_demo': patching complete |
| 505 | + |
| 506 | + % insmod samples/livepatch/livepatch-callbacks-mod.ko |
| 507 | + [ 100.930955] livepatch: applying patch 'livepatch_callbacks_demo' to loading module 'livepatch_callbacks_mod' |
| 508 | + [ 100.931668] livepatch_callbacks_demo: pre_patch_callback: livepatch_callbacks_mod -> [MODULE_STATE_COMING] Full formed, running module_init |
| 509 | + [ 100.932645] livepatch_callbacks_demo: post_patch_callback: livepatch_callbacks_mod -> [MODULE_STATE_COMING] Full formed, running module_init |
| 510 | + [ 100.934125] livepatch_callbacks_mod: livepatch_callbacks_mod_init |
| 511 | + |
| 512 | + % rmmod samples/livepatch/livepatch-callbacks-mod.ko |
| 513 | + [ 102.942805] livepatch_callbacks_mod: livepatch_callbacks_mod_exit |
| 514 | + [ 102.943640] livepatch_callbacks_demo: pre_unpatch_callback: livepatch_callbacks_mod -> [MODULE_STATE_GOING] Going away |
| 515 | + [ 102.944585] livepatch: reverting patch 'livepatch_callbacks_demo' on unloading module 'livepatch_callbacks_mod' |
| 516 | + [ 102.945455] livepatch_callbacks_demo: post_unpatch_callback: livepatch_callbacks_mod -> [MODULE_STATE_GOING] Going away |
| 517 | + |
| 518 | + % echo 0 > /sys/kernel/livepatch/livepatch_callbacks_demo/enabled |
| 519 | + [ 104.953815] livepatch: 'livepatch_callbacks_demo': initializing unpatching transition |
| 520 | + [ 104.953838] livepatch_callbacks_demo: pre_unpatch_callback: vmlinux |
| 521 | + [ 104.954431] livepatch_callbacks_demo: pre_unpatch_callback: livepatch_callbacks_busymod -> [MODULE_STATE_LIVE] Normal state |
| 522 | + [ 104.955426] livepatch: 'livepatch_callbacks_demo': starting unpatching transition |
| 523 | + [ 106.719073] livepatch: 'livepatch_callbacks_demo': completing unpatching transition |
| 524 | + [ 106.722633] livepatch_callbacks_demo: post_unpatch_callback: vmlinux |
| 525 | + [ 106.723282] livepatch_callbacks_demo: post_unpatch_callback: livepatch_callbacks_busymod -> [MODULE_STATE_LIVE] Normal state |
| 526 | + [ 106.724279] livepatch: 'livepatch_callbacks_demo': unpatching complete |
| 527 | + |
| 528 | + % rmmod samples/livepatch/livepatch-callbacks-demo.ko |
| 529 | + % rmmod samples/livepatch/livepatch-callbacks-busymod.ko |
| 530 | + [ 108.975660] livepatch_callbacks_busymod: livepatch_callbacks_mod_exit |
| 531 | + |
| 532 | + |
| 533 | +Test 9 |
| 534 | +------ |
| 535 | + |
| 536 | +A similar test as the previous one, but force the "busy" kernel module |
| 537 | +to do longer work. |
| 538 | + |
| 539 | +The livepatching core will refuse to patch a task that is currently |
| 540 | +executing a to-be-patched function -- the consistency model stalls the |
| 541 | +current patch transition until this safety-check is met. Test a |
| 542 | +scenario where one of a livepatch's target klp_objects sits on such a |
| 543 | +function for a long time. Meanwhile, load and unload other target |
| 544 | +kernel modules while the livepatch transition is in progress. |
| 545 | + |
| 546 | +- load busy target module (30s sleep) |
| 547 | +- load livepatch |
| 548 | +- load target module |
| 549 | +- unload target module |
| 550 | +- disable livepatch |
| 551 | +- unload livepatch |
| 552 | +- unload busy target module |
| 553 | + |
| 554 | + |
| 555 | +Load the "busy" kernel module, this time make it do 30 seconds worth of |
| 556 | +work: |
| 557 | + |
| 558 | + % insmod samples/livepatch/livepatch-callbacks-busymod.ko sleep_secs=30 |
| 559 | + [ 110.993362] livepatch_callbacks_busymod: livepatch_callbacks_mod_init |
| 560 | + [ 110.994059] livepatch_callbacks_busymod: busymod_work_func, sleeping 30 seconds ... |
| 561 | + |
| 562 | +Meanwhile, the livepatch is loaded. Notice that the patch transition |
| 563 | +does not complete as the targeted "busy" module is sitting on a |
| 564 | +to-be-patched function: |
| 565 | + |
| 566 | + % insmod samples/livepatch/livepatch-callbacks-demo.ko |
| 567 | + [ 113.000309] livepatch: enabling patch 'livepatch_callbacks_demo' |
| 568 | + [ 113.000764] livepatch: 'livepatch_callbacks_demo': initializing patching transition |
| 569 | + [ 113.000791] livepatch_callbacks_demo: pre_patch_callback: vmlinux |
| 570 | + [ 113.001289] livepatch_callbacks_demo: pre_patch_callback: livepatch_callbacks_busymod -> [MODULE_STATE_LIVE] Normal state |
| 571 | + [ 113.005208] livepatch: 'livepatch_callbacks_demo': starting patching transition |
| 572 | + |
| 573 | +Load a second target module (this one is an ordinary idle kernel |
| 574 | +module). Note that *no* post-patch callbacks will be executed while the |
| 575 | +livepatch is still in transition: |
| 576 | + |
| 577 | + % insmod samples/livepatch/livepatch-callbacks-mod.ko |
| 578 | + [ 115.012740] livepatch: applying patch 'livepatch_callbacks_demo' to loading module 'livepatch_callbacks_mod' |
| 579 | + [ 115.013406] livepatch_callbacks_demo: pre_patch_callback: livepatch_callbacks_mod -> [MODULE_STATE_COMING] Full formed, running module_init |
| 580 | + [ 115.015315] livepatch_callbacks_mod: livepatch_callbacks_mod_init |
| 581 | + |
| 582 | +Request an unload of the simple kernel module. The patch is still |
| 583 | +transitioning, so its pre-unpatch callbacks are skipped: |
| 584 | + |
| 585 | + % rmmod samples/livepatch/livepatch-callbacks-mod.ko |
| 586 | + [ 117.022626] livepatch_callbacks_mod: livepatch_callbacks_mod_exit |
| 587 | + [ 117.023376] livepatch: reverting patch 'livepatch_callbacks_demo' on unloading module 'livepatch_callbacks_mod' |
| 588 | + [ 117.024533] livepatch_callbacks_demo: post_unpatch_callback: livepatch_callbacks_mod -> [MODULE_STATE_GOING] Going away |
| 589 | + |
| 590 | +Finally the livepatch is disabled. Since none of the patch's |
| 591 | +klp_object's post-patch callbacks executed, the remaining klp_object's |
| 592 | +pre-unpatch callbacks are skipped: |
| 593 | + |
| 594 | + % echo 0 > /sys/kernel/livepatch/livepatch_callbacks_demo/enabled |
| 595 | + [ 119.035408] livepatch: 'livepatch_callbacks_demo': reversing transition from patching to unpatching |
| 596 | + [ 119.035485] livepatch: 'livepatch_callbacks_demo': starting unpatching transition |
| 597 | + [ 119.711166] livepatch: 'livepatch_callbacks_demo': completing unpatching transition |
| 598 | + [ 119.714179] livepatch_callbacks_demo: post_unpatch_callback: vmlinux |
| 599 | + [ 119.714653] livepatch_callbacks_demo: post_unpatch_callback: livepatch_callbacks_busymod -> [MODULE_STATE_LIVE] Normal state |
| 600 | + [ 119.715437] livepatch: 'livepatch_callbacks_demo': unpatching complete |
| 601 | + |
| 602 | + % rmmod samples/livepatch/livepatch-callbacks-demo.ko |
| 603 | + % rmmod samples/livepatch/livepatch-callbacks-busymod.ko |
| 604 | + [ 141.279111] livepatch_callbacks_busymod: busymod_work_func exit |
| 605 | + [ 141.279760] livepatch_callbacks_busymod: livepatch_callbacks_mod_exit |