Skip to content

RFC livepatch: consistency model

Josh Poimboeuf lkml 1 version Applied

Status from this message: Applied to for-3.21/core, thanks.

Get series with b4
b4 am [email protected]

Versions newest first

  1. v1 RFC Latest9 patches 96 repliesApplied

Patches in v1 Applied

#Subject and filesSizeRepliesApplied
1/9livepatch: simplify disable error pathkernel/livepatch/core.c+17 -503 replies
2/9livepatch: separate enabled and patched statesinclude/linux/livepatch.h kernel/livepatch/core.c+45 -495 replies
3/9livepatch: move patching functions into patch.ckernel/livepatch/Makefile kernel/livepatch/core.c kernel/livepatch/patch.c +1 more+203 -1754 replies
4/9livepatch: get function sizesinclude/linux/livepatch.h kernel/livepatch/core.c+21 -12 replies
5/9sched: move task rq locking functions to sched.hkernel/sched/core.c kernel/sched/sched.h+33 -322 replies
6/9livepatch: create per-task consistency modelinclude/linux/livepatch.h include/linux/sched.h kernel/fork.c +7 more+423 -2646 replies
7/9proc: add /proc/<pid>/universe to show livepatch statusfs/proc/base.c+11 -02 replies
8/9livepatch: allow patch modules to be removedkernel/livepatch/core.c kernel/livepatch/transition.c+7 -2112 replies
9/9livepatch: update task universe when exiting kernelarch/x86/include/asm/thread_info.h arch/x86/kernel/signal.c include/linux/livepatch.h +2 more+28 -12 replies

Reviews trailers per patch

1 of 9 patches has a Reviewed-by or Acked-by.

PatchMiroslav BenesPetr Mladek
1/9R-b R-b
2/9
3/9
4/9
5/9
6/9
7/9
8/9
9/9

Trailers given in replies are filled; those carried in the patches from earlier versions are outlined with dashes.

Read the v1 thread

Cover letter [RFC PATCH 0/9] livepatch: consistency model

This patch set implements a livepatch consistency model, targeted for 3.21. Now that we have a solid livepatch code base, this is the biggest remaining missing piece.

This code stems from the design proposal made by Vojtech [1] in November. It makes live patching safer in general. Specifically, it allows you to apply patches which change function prototypes. It also lays the groundwork for future code changes which will enable data and data semantic changes.

It's basically a hybrid of kpatch and kGraft, combining kpatch's backtrace checking with kGraft's per-task consistency. When patching, tasks are carefully transitioned from the old universe to the new universe. A task can only be switched to the new universe if it's not using a function that is to be patched or unpatched. After all tasks have moved to the new universe, the patching process is complete.

How it transitions various tasks to the new universe:

- The stacks of all sleeping tasks are checked. Each task that is not sleeping on a to-be-patched function is switched.

- Other user tasks are handled by do_notify_resume() (see patch 9/9). If a task is I/O bound, it switches universes when returning from a system call. If it's CPU bound, it switches when returning from an interrupt. If it's sleeping on a patched function, the user can send SIGSTOP and SIGCONT to force it to switch upon return from the signal handler.

- Idle "swapper" tasks which are sleeping on a to-be-patched function can be switched from within the outer idle loop.

- An interrupt handler will inherit the universe of the task it interrupts.

- kthreads which are sleeping on to-be-patched functions are not yet handled (more on this below).

I think this approach provides the best benefits of both kpatch and kGraft:

advantages vs kpatch:
- no stop machine latency
- higher patch success rate (can patch in-use functions)
- patching failures are more predictable (primary failure mode is attempting to patch a kthread which is sleeping forever on a patched function, more on this below)

advantages vs kGraft:
- less code complexity (don't have to hack up the code of all the different kthreads)
- less impact to processes (don't have to signal all sleeping tasks)

disadvantages vs kpatch:
- no system-wide switch point (not really a functional limitation, just forces the patch author to be more careful. but that's probably a good thing anyway)

My biggest concerns and questions related to this patch set are:

1) To safely examine the task stacks, the transition code locks each task's rq struct, which requires using the scheduler's internal rq locking functions. It seems to work well, but I'm not sure if there's a cleaner way to safely do stack checking without stop_machine().

2) As mentioned above, kthreads which are always sleeping on a patched function will never transition to the new universe. This is really a minor issue (less than 1% of patches). It's not necessarily something that needs to be resolved with this patch set, but it would be good to have some discussion about it regardless.

To overcome this issue, I have 1/2 an idea: we could add some stack checking code to the ftrace handler itself to transition the kthread to the new universe after it re-enters the function it was originally sleeping on, if the stack doesn't already have have any other to-be-patched functions. Combined with the klp_transition_work_fn()'s periodic stack checking of sleeping tasks, that would handle most of the cases (except when trying to patch the high-level thread_fn itself).

But then how do you make the kthread wake up? As far as I can tell, wake_up_process() doesn't seem to work on a kthread (unless I messed up my testing somehow). What does kGraft do in this case?

[1] https://lkml.org/lkml/2014/11/7/354

Josh Poimboeuf (9):
livepatch: simplify disable error path
livepatch: separate enabled and patched states
livepatch: move patching functions into patch.c
livepatch: get function sizes
sched: move task rq locking functions to sched.h
livepatch: create per-task consistency model
proc: add /proc/<pid>/universe to show livepatch status
livepatch: allow patch modules to be removed
livepatch: update task universe when exiting kernel

 arch/x86/include/asm/thread_info.h |   4 +-
 arch/x86/kernel/signal.c           |   4 +
 fs/proc/base.c                     |  11 ++
 include/linux/livepatch.h          |  38 ++--
 include/linux/sched.h              |   3 +
 kernel/fork.c                      |   2 +
 kernel/livepatch/Makefile          |   2 +-
 kernel/livepatch/core.c            | 360 ++++++++++---------------------------
 kernel/livepatch/patch.c           | 206 +++++++++++++++++++++
 kernel/livepatch/patch.h           |  26 +++
 kernel/livepatch/transition.c      | 318 ++++++++++++++++++++++++++++++++
 kernel/livepatch/transition.h      |  16 ++
 kernel/sched/core.c                |  34 +---
 kernel/sched/idle.c                |   4 +
 kernel/sched/sched.h               |  33 ++++
 15 files changed, 747 insertions(+), 314 deletions(-)
 create mode 100644 kernel/livepatch/patch.c
 create mode 100644 kernel/livepatch/patch.h
 create mode 100644 kernel/livepatch/transition.c
 create mode 100644 kernel/livepatch/transition.h
Signature · 1 line
2.1.0