Jump to content

kpatch

From Wikipedia, the free encyclopedia

This is an old revision of this page, as edited by Bender the Bot (talk | contribs) at 16:05, 27 November 2016 (→Internals: clean up; http→https for YouTube using AWB). The present address (URL) is a permanent link to this revision, which may differ significantly from the current revision.

kpatch
Developer(s)Red Hat
Initial releaseFebruary 26, 2014 (2014-02-26)[1]
Repository
Operating systemLinux
TypeKernel extension
LicenseGNU GPL version 2
Websitegithub.com/dynup/kpatch

kpatch is a feature of the Linux kernel that implements live patching of a running kernel, which allows kernel patches to be applied while the kernel is still running. By avoiding the need for rebooting the system with a new kernel that contains the desired patches, kpatch aims to maximize the system uptime and availability. At the same time, kpatch allows kernel-related security updates to be applied without deferring them to scheduled downtimes.[1][2] Internally, kpatch allows entire functions in a running kernel to be replaced with their patched versions, doing that safely by stopping all running processes while the live patching is performed.[3]

kpatch is developed by Red Hat, with its source code licensed under the terms of the GNU General Public License version 2 (GPLv2).[1] In May 2014, kpatch was submitted for inclusion into the Linux kernel mainline,[4] and the minimalistic foundations for live patching were merged into the Linux kernel mainline in kernel version 4.0, which was released on April 12, 2015.[5]

Internals

With live patching in place, calls to patched kernel functions invoke their replacement counterparts.[6]: 2:07 

Internally, kpatch consists of two parts – the core kernel module executes the live patching mechanism by altering kernel's inner workings, while a set of userspace utilities prepares individual hot patch kernel modules from source diffs and manages their application. Live kernel patching is performed at the function level, meaning that kpatch can replace entire functions in the running kernel with their patched versions by using facilities provided by ftrace to "route around" old versions of functions; that way, hot patches can also easily be undone. No changes to the kernel's internal data structures are possible; however, security patches, which are one of the natural candidates to be used with kpatch, rarely contain changes to the kernel's data structures.[3][4][6]

kpatch ensures that hot patches are applied atomically and safely by stopping all running processes while the hot patch is applied, and by ensuring that none of the stopped processes is running inside the functions that are to be patched. Such an approach simplifies the whole live patching mechanism and prevents certain issues associated with the way data structures are used by original and patched versions of functions. As the downside, this approach also leaves the possibility for a hot patch to fail, and introduces a small amount of latency required for stopping all running processes.[3][4][6]

History

Red Hat announced and publicly released kpatch in February 2014 under the terms of the GNU General Public License version 2 (GPLv2),[1] shortly before SUSE released its own live kernel patching implementation called kGraft.[7] kpatch aims to become merged into the Linux kernel mainline, and it was submitted for the inclusion in May 2014.[4][8]

kpatch has been included in Red Hat Enterprise Linux 7.0, released on June 10, 2014, as a technology preview.[9][10]

Minimalistic foundations for live kernel patching were merged into the Linux kernel mainline in kernel version 4.0, which was released on April 12, 2015. Those foundations, based primarily on the kernel's ftrace functionality, form a common core capable of supporting hot patching by both kpatch and kGraft, by providing an application programming interface (API) for kernel modules that contain hot patches and an application binary interface (ABI) for the userspace management utilities. However, the common core included into Linux kernel 4.0 supports only the x86 architecture and does not provide any mechanisms for ensuring function-level consistency while the hot patches are applied.[5][11][12]

Since April 2015, there is ongoing work on porting kpatch to the common live patching core provided by the Linux kernel mainline.[12] However, implementation of the required function-level consistency mechanisms has been delayed because the call stacks provided by the Linux kernel may be unreliable in situations that involve assembly code without proper stack frames; as a result, the porting work remains in progress as of September 2015. In an attempt to improve the reliability of kernel's call stacks, a specialized sanity-check stacktool userspace utility has also been developed.[13][14]

See also

  • Dynamic software updating – a field of research focusing on upgrading programs while they are running
  • kexec – a method for loading a whole new Linux kernel from a running system
  • Ksplice and KernelCare – other Linux kernel live patching technologies developed by Ksplice, Inc. (later acquired by Oracle) and CloudLinux, respectively

References

  1. ^ a b c d Josh Poimboeuf; Seth Jennings (February 26, 2014). "Introducing kpatch: Dynamic Kernel Patching". redhat.com. Retrieved July 23, 2014.
  2. ^ Sean Michael Kerner (June 6, 2014). "Linux Kernel Patching Gets Dynamic". ServerWatch. Retrieved July 23, 2014.
  3. ^ a b c Jonathan Corbet (May 7, 2014). "The first kpatch submission". LWN.net. Retrieved July 23, 2014.
  4. ^ a b c d Josh Poimboeuf (May 1, 2014). "kpatch: dynamic kernel patching". LWN.net. Retrieved July 23, 2014.
  5. ^ a b "Linux kernel 4.0, Section 1.2. Live patching". kernelnewbies.org. April 26, 2015. Retrieved April 27, 2015.
  6. ^ a b c Seth Jennings; Josh Poimboeuf (June 10, 2014). "Dynamic Kernel Patching". Red Hat. Retrieved July 23, 2014.
  7. ^ "SUSE Releases kGraft for Live Patching of Linux Kernel". SUSE. March 27, 2014. Retrieved February 11, 2015.
  8. ^ Michael Larabel (May 1, 2014). "SUSE Posts kGraft, Red Hat Posts Kpatch Patches". Phoronix. Retrieved July 23, 2014.
  9. ^ "Red Hat Enterprise Linux 7.0 Release Notes, Chapter 5. Kernel". Red Hat. July 15, 2014. Retrieved July 23, 2014.
  10. ^ Carlos Sanchez (June 26, 2014). "Red Hat Releases Red Hat Enterprise Linux 7 with Increased Linux Containers Support". infoq.com. Retrieved July 23, 2014.
  11. ^ Jonathan Corbet (February 25, 2015). "A rough patch for live patching". LWN.net. Retrieved April 27, 2015.
  12. ^ a b "Linux kernel source tree: kernel/git/torvalds/linux.git: Pull live patching infrastructure from Jiri Kosina". kernel.org. February 11, 2015. Retrieved April 27, 2015.
  13. ^ Jonathan Corbet (September 30, 2015). "Compile-time stack validation". LWN.net. Retrieved October 2, 2015.
  14. ^ Josh Poimboeuf (September 24, 2015). "Linux kernel documentation: Documentation/stack-validation.txt (from the v13 patch)". LWN.net. Retrieved October 2, 2015.
Wikimedia Commons has media related to Linux kernel live patching.
Retrieved from "https://en.wikipedia.org/w/index.php?title=Kpatch&oldid=751742293"