Kdump, A Kexec-based Kernel Crash Dumping Mechanism
Vivek Goyal Eric W. Biederman Hariprasad Nellitheertha IBM Linux NetworkX IBM vgoyal@in.ibm.com [email protected] [email protected]
Abstract important consideration for the success of a so- lution has been the reliability and ease of use. Kdump is a crash dumping solution that pro- Kdump is a kexec based kernel crash dump- vides a very reliable dump generation and cap- ing mechanism, which is being perceived as turing mechanism [01]. It is simple, easy to a reliable crash dumping solution for Linux R . configure and provides a great deal of flexibility This paper begins with brief description of what in terms of dump device selection, dump saving kexec is and what it can do in general case, and mechanism, and plugging-in filtering mecha- then details how kexec has been modified to nism. boot a new kernel even in a system crash event. The idea of kdump has been around for Kexec enables booting into a new kernel while quite some time now, and initial patches for preserving the memory contents in a crash sce- kdump implementation were posted to the nario, and kdump uses this feature to capture Linux kernel mailing list last year [03]. Since the kernel crash dump. Physical memory lay- then, kdump has undergone significant design out and processor state are encoded in ELF core changes to ensure improved reliability, en- format, and these headers are stored in a re- hanced ease of use and cleaner interfaces. This served section of memory. Upon a crash, new paper starts with an overview of the kdump de- kernel boots up from reserved memory and pro- sign and development history. Then the limi- vides a platform to retrieve stored ELF headers tations of existing designs are highlighted and and capture the crash dump. Also detailed are this paper goes on to detail the new design and ELF core header creation, dump capture mech- enhancements. anism, and how to configure and use the kdump feature. Section 2 provides background of kexec and kdump development. Details regarding how kexec has been enhanced to boot-into a new 1 Introduction kernel in panic events are covered in section 3. Section 4 details the new kdump design. De- tails about how to configure and use this mech- Various crash dumping solutions have been anism are captured in Section 5. Briefly dis- evolving over a period of time for Linux and cussed are advantages and limitations of this other UNIX R like operating systems. All so- approach in section 6. A concise description lutions have their pros and cons, but the most of current status of project and TODOs are in-
• 169 • 170 • Kdump, A Kexec-based Kernel Crash Dumping Mechanism cluded in Section 7. 2.2 A Brief History of Kdump Develop- ment
The core design principle behind this approach 2 Background is that dump is captured with the help of a cus- tom built kernel that runs with a small amount of memory. This custom built kernel is called capture kernel and is booted into upon a sys- This section provides an overview of the kexec tem crash event without clearing crashed ker- and original kdump design philosophy and im- nel’s memory. Here onwards, for discussion plementation approach. It also brings forward purposes, crashing kernel is referred to as first the design deficiencies of kdump approach so kernel and the kernel which captures the dump far, and highlights the requirements that justi- after a system crash is called capture kernel. fied kexec and kdump design enhancements. While capture kernel boots, first kernel’s mem- ory is not overwritten except for the small 2.1 Kexec amount of memory used by new kernel for its execution. Kdump used this feature of kexec and added hooks in kexec code to boot into a capture kernel in a panic event without stomp- Kexec is a kernel-to-kernel boot-loader [07], ing crashed kernel’s memory. which provides the functionality to boot into a new kernel, over a reboot, without going Capture kernel used the first 16 MB of memory through the BIOS. Essentially, kexec pre-loads for booting and this region of memory needed the new kernel and stores the kernel image in to be preserved before booting into capture ker- RAM. Memory required to store the new kernel nel. Kdump added the functionality to copy the image need not be contiguous and kexec keeps contents of the first 16 MB to a reserved mem- a track of pages where new kernel image has ory area called backup region. Memory for the been stored. When a reboot is initiated, kexec backup region was reserved during the first ker- copies the new kernel image to destination lo- nel’s boot time, and location and size of the cation from where the new kernel is supposed backup region was specified using kernel con- to run, and after executing some setup code, fig options. Kdump also copied over the CPU kexec transfers the control to the new kernel. register states to an area immediately after the backup region during a crash event [03]. Kexec functionality is constituted of mainly two components; kernel space [08] and user After the crash event, the system is unstable space [02]. Kernel space component imple- and usual device shutdown methods can not be ments a new system call kexec_load() relied upon, hence, devices are not shutdown which facilitates pre-loading of new kernel. after a crash. This essentially means that any User space component, here onwards called ongoing DMAs at the time of crash are not kexec tools, parses the new kernel image, pre- stopped. In the above approach, the capture pares the appropriate parameter segment, and kernel was booting from the same memory lo- setup code segment and passes the this data to cation as the first kernel (1 MB) and used first the running kernel through newly implemented 16 MB to boot, hence, it was prone to cor- system call for further processing. ruption due to any on-going DMA in that re- 2005 Linux Symposium • 171 gion. An idea was proposed and a prototype 1. In the design above, kexec pre-loads the patch was provided for booting the capture ker- capture kernel wherever it can manage to nel from a reserved region of memory instead grab a page frame. At the time of crash, of a default location. This reduced the chances the capture kernel image is copied to the of corruption of the capture kernel due to on- destination location and control is trans- going DMA [04] [05]. Kdump’s design was up- ferred to the new kernel. Given the fact dated to accommodate this change and now the that the capture kernel runs from a re- capture kernel booted from reserved location. served area of memory, it can be loaded This reserved region was still being determined there directly and extra copying of kernel by kernel config options [06]. can be avoided. In general terms, kexec can be enhanced to provide a fast reboot Despite the fact that the capture kernel was path to handle booting into a new kernel booting from a reserved region of memory, it in crash events also. needed first 640 KB of memory to boot for SMP configurations. This memory was re- 2. Capture kernel and the associated data is quired to retrieve configuration data like the pre-loaded and stored in the kernel mem- MP configuration table saved by BIOS while ory, but there is no way to detect any data booting the first kernel. It was also required to corruption due to faulty kernel program- place the trampoline code needed to kick-start ming. application processors in the system. Kdump reserved 640 KB of memory (backup region) 3. During the first kernel boot, kdump re- immediately after the reserved region, and pre- serves a chunk of memory for booting the served the first 640 KB of memory contents by capture kernel. The location of this region copying it to a backup region just before trans- is determined during kernel compilation ferring control to capture kernel. CPU register time with the help of config options. De- states were being stored immediately after the termining the location of reserved region backup region [06]. through config options is a little cumber- some. It brings in hard-coding in many After booting, capture kernel retrieved the places, at the same time it is static in na- saved register states and backup region con- ture and a user has to compile the kernel tents, and made available the old kernel’s dump again if he decides to change the location image through two kernel interfaces. The of reserved region. first one was through the /proc/vmcore in- terface, which exported the dump image in 4. Capture kernel has to boot into a lim- ELF core format, and other one being the ited amount of memory, and to achieve /dev/oldmem, which provided a linear raw this, the capture kernel is booted with view of memory. user defined memory map with the help of memmap=exactmap command line op- tions. User has to provide this user de- 2.3 Need for Design Enhancement fined memory map while pre-loading the capture kernel and need to be explicitly aware of memory region reserved for cap- Following are some of the key limitations of ture kernel. This process can be automated the above approach that triggered the design en- by kexec tools and these details can be hancement of kdump. made opaque to the user. 172 • Kdump, A Kexec-based Kernel Crash Dumping Mechanism
5. When the capture kernel boots up, it needs nel’s memory location (1 MB). However, cur- to determine the location of the backup re- rently only a vmlinux image can be used as a gion to access the crashed kernel’s backed- capture kernel. A bzImage can not be used as up memory contents. Capture kernel re- capture kernel because even if it is compiled ceives this information through hard coded to run from a reserved location, it always first config options. It also retrieves the saved loads at 1 MB and later it relocates itself to register states assuming these to be stored the memory location it was compiled to run immediately after the backup region and from. This essentially means that loading bz- this introduces another level of hard- Image shall overwrite the first kernel’s memory coding. contents at 1 MB location and that is not the In this approach, the capture kernel is desired behavior. explicitly aware of the presence of the From here on out the discussion is limited to backup region, which can be done away the loading of a vmlinux image for i386 plat- with. In general, there is no stan- form. Details regarding loading of other kind dard format for the exchange of infor- of images is outside the scope of this paper. mation between two kernels which essen- tially makes two kernel dependent on each other, and it might now allow kernel skew 3.1 Capture Kernel Space Reservation between the first kernel and the capture kernel as kernel development progresses. On i386, the default location a kernel runs from 6. The /proc/vmcore implementation is 1 MB. The capture kernel is compiled and does not support discontiguous memory linked to run from a non default location like 16 systems and assumes memory is contigu- MB. The first kernel needs to reserve a chunk ous, hence exports only one ELF program of memory where the capture kernel and as- header for the whole of the memory. sociated data can be pre-loaded. Capture ker- nel will directly run from this reserved mem- ory location. This space reservation is done with the help of crashkernel=X@Y boot 3 Kexec On Panic time parameter to first kernel, where X is the the amount of memory to be reserved and Y Initially, kexec was designed to allow booting indicates the location where reserved memory a new kernel from a sane kernel over a reboot. section starts. Emergence of kdump called for kexec to allow booting a new kernel even in a crash scenario. 3.2 Pre-loading the Capture Kernel Kexec has now been modified to handle system crash events, and it provides a separate reboot path to a new kernel in panic situations. Capture kernel and associated data are pre- loaded in the reserved region of memory. Kexec as a boot-loader supports loading of var- Kexec tools parses the capture kernel image ious kinds of images for a particular platform. and loads it in reserved region of memory us- For i386, vmlinux, bzImage, and multiboot im- ing kexec_load() system call. Kexec tools ages can be loaded. Capture kernel is compiled manage a contiguous chunk of data belonging to load and run from a reserved memory loca- to the same group in the form of segment. For tion which does not overlap with the first ker- example, bzImage code is considered as one 2005 Linux Symposium • 173 segment, parameter block is treated as another 3.3 Post Crash Processing segment and so on. Kexec tools parses the cap- ture kernel image and prepares a list of seg- Upon a crash, kexec performs a minimum ma- ments and passes the list to kernel. This list chine shutdown procedure and then jumps to basically conveys the information like location the purgatory code. During machine shut- of various data blocks in user space and where down, crashing CPU sends the NMI IPIs to these blocks have to be loaded in reserved re- other processors to halt them. Upon receiving gion of memory. kexec_load() system call NMI, the processor saves the register state, dis- does the verification on destination location of ables the local APIC and goes into halt state. a segments and copies the segment data from After stopping the other CPUs, crashing CPU user space to kernel space. Capture kernel is disables its local APIC, disables IOAPIC, and directly loaded into the memory where it is sup- saves its register states. posed to run from and no extra copying of cap- ture kernel is required. CPU register states are saved in ELF note sec- tion format [09]. Currently the processor sta- purgatory is an ELF relocatable object that tus is stored in note type NT_PRSTATUS at runs between the kernels. Apart from setup the time of crash. Framework provides enough code, purgatory also implements a sha256 hash flexibility to store more information down the to verify that loaded kernel is not corrupt. In line, if needed. One kilobyte of memory is re- addition, purgatory also saves the contents served for every CPU for storing information in to backup region after the crash (section 4.3). the form of notes. A final null note is appended Figure 1 depicts one of the possible arrange- at the end to mark the end of notes. Memory ments of various segments after being loaded for the note section is allocated statically in the into a reserved region of memory. In this ex- kernel and the memory address is exported to ample, memory from 16 MB to 48 MB has been user space through sysfs. This address is in reserved for loading capture kernel. turn used by kexec tools while generating the ELF headers (Section 4.2).
4G 1K 1K 1K
cpu[0] cpu[1] cpu[NR_CPUS] 48M
Backup Region Reserved Region NT_PRSTATUS Null Empty Space Parameter Segment Note filled with zero Purgatory
Capture Kernel Image Figure 2: Saving CPU Register States 16M After saving register states, control is trans- ferred to purgatory. purgatory runs 0K sha256 hash to verify the integrity of the cap- Figure 1: Various Data Segments in Reserved ture kernel and associated data. If no corruption Region is detected, purgatory goes on to copy the first 174 • Kdump, A Kexec-based Kernel Crash Dumping Mechanism
640 KB of memory to the backup region (Sec- and backup region, if any. ELF headers are pre- tion 4.3). Once the backup is completed control pared by kexec tools and stored in a reserved flow jumps to start of the new kernel image and memory location along with other segments as the new kernel starts execution. shown in Figure 3.
4G 4 Kdump 48M Previous kdump design had certain drawbacks which have been overcome in the new design. ELF Backup Core Headers Region Reserved Following section captures the details of the Region new kdump design. Parameter Segment
Purgatory
4.1 Design Overview Capture Kernel Image 16M
Most of the older crash dumping solutions have had the drawback of capturing/writing out the 0K dump in the context of crashing kernel, which Figure 3: ELF Core Headers in Reserved Re- is inherently unreliable. This led to the idea of gion first booting into a sane kernel after the crash and then capturing the dump. Kexec enables Memory for ELF core headers is reserved by kdump to boot into the already loaded capture bootmem allocator during first kernel boot us- kernel without clearing the memory contents ing the reserve_bootmem() function call. and this sets the stage for a reliable dump cap- Upon crash, system boots into new kernel and ture. stored ELF headers are retrieved and exported through /proc/vmcore interface. The dump image can be represented in many ways. It can be a raw snapshot of memory read This provides a platform for capturing the from a device interface similar to /dev/mem, dump image and storing it for later analysis. or it can be exported in ELF core format. Ex- Implementation details are discussed in follow- porting a dump image in ELF core format car- ing sections of this paper. ries the advantage of being a standard approach for representing core dumps and provides the 4.2 ELF Core Header Generation compatibility with existing analysis tools like gdb, crash, and so on. Kdump provides ELF core view of a dump through /proc/vmcore Kdump uses the ELF core format to exchange interface and at the same time it also provides the information about dump image, between /dev/oldmem interface presenting linear raw two kernels. ELF core format provides a view of memory. generic and flexible framework for exchange of dump information. The address of the start ELF core headers encapsulate the information of these headers is passed to the new kernel like processor registers, valid RAM locations, through a command line option. This provides 2005 Linux Symposium • 175 a cleaner interface between the two kernels, and where actual notes section reside. This ad- at the same time ensures that the two kernels dress is exported to user space through sysfs are independent of each other. It also allows by kexec. Kexec user space tools read in the kernel skew between the crashing kernel and /sys/kernel/crash_notes file and pre- the capture kernel, which essentially means that pare the PT_NOTE headers accordingly. version of the crashing kernel and the capture kernel do not need to be the same. Also, an In the event of memory hotplug, the cap- older capture kernel should be able to capture ture kernel needs to be reloaded so that the the dump for a relatively newer first kernel. ELF headers are generated again reflecting the changes. Kexec tools are responsible for ELF core header generation. ELF64 headers are suffi- 4.3 Backup Region cient to encode all the required information, but gdb can not open a ELF64 core file for 32 bit Capture kernel boots from the reserved area of systems. Hence, kexec also provides a com- memory after a crash event. Depending on the mand line option to force preparation of ELF32 architecture, it may still need to use some fixed headers. This is useful for the users with non- memory locations that were used by the first PAE systems. kernel. For example, on i386, it needs to use the first 640 KB of memory for trampoline code for One PT_LOAD type program header is created booting SMP kernel. Some architectures like for every contiguous memory chunk present in ppc64 need fixed memory locations for stor- the system. Information regarding valid RAM ing exception vectors and other data structures. locations is obtained from /proc/iomem. Contents of these memory locations are copied Considering system RAM as a file, physical ad- to a reserved memory area (backup region) just dress represents the offset in the file. Hence the after crash to avoid any stomping by the capture p_offset field of program header is set to kernel. purgatory takes care of copying the actual physical address of the memory chunk. contents to backup region (Section 3.2). p_paddr is the same as p_offset except in case of a backup region (Section 4.3). Virtual Capture kernel/capture tool need to be aware address (p_vaddr) is set to zero except for the of the presence of a backup region because ef- linearly mapped region as virtual addresses for fectively some portion of the physical mem- this region can be determined easily at the time ory has been relocated. ELF format comes in of header creation. This allows a restricted de- handy here as it allows to envelop this informa- bugging with gdb directly, without assistance tion without creating any dependencies. A sep- from any other utility used to fill in virtual ad- arate PT_LOAD type program header is gener- dresses during post crash processing. ated for the backup region. The p_paddr field is filled with the original physical address and One PT_NOTE type program header is cre- the p_offset field is populated with the re- ated per CPU for representing note informa- located physical address as shown in Figure 4. tion associated with that CPU. Actual notes in- formation is saved at the time of crash (Sec- Currently, kexec user space tools provide the tion 3.3), but PT_NOTE type program header backup region handling for i386, and the first is created in advance at the time of loading 640 KB of memory is backed-up. This code is the capture kernel. The only information re- more or less architecture dependent. Other ar- quired at this point is the address of location chitectures can define their own backup regions 176 • Kdump, A Kexec-based Kernel Crash Dumping Mechanism
list of memory regions that the capture ker- 4G nel can safely use to boot into, and appropriate memmap options are appended to the command line accordingly. The backup region and ELF header segments are excluded from this list to Program Elf core headers Header avoid stomping of these memory areas by new Backup Region p_offset kernel. Parameter segment p_paddr Purgatory Address of start of ELF header segment is passed to the capture kernel through the Capture kernel image elfcorehdr= command line option. This option is also added automatically to command line by kexec tools.
640K 4.5 Dump Capture Mechanism 0K Once the capture kernel has booted there are Copy to backup region multiple design options for dump capturing mechanism. Few of them are as following. Figure 4: Saving Contents To Backup Region and plug-in the implementations into existing • Kernel Space kexec user space code. Export ELF core image through the /proc/vmcore interface which can be 4.4 Booting into Capture Kernel directly used by ELF core format aware analysis tools such as gdb. Also export The capture kernel is compiled to boot from raw linear view of memory through device a non-default memory location. It should not interface /dev/oldmem. Other crash stomp over crashed kernel’s memory contents analysis tools can undergo required modi- to be able to retrieve a sane dump. Hence, cap- fications to adapt to these formats. ture kernel is booted with an user defined mem- This is an easy to use solution which of- ory map instead of the one provided by BIOS or fers a wide variety of choices. Standard one passed in parameter segment by kexec. The tools like cp, scp, and ftp can be used command line option memmap=exactmap to copy the image to the disk either locally along with memmap=X@Y is used to override or over the network. gdb can be used di- BIOS provided memory map and define user rectly for limited debugging. The flip side memory map. is that the /proc/vmcore code is in the kernel and debugging the kernel code is These boot time parameters are automatically relatively harder. added to command line by kexec tools while loading the capture kernel and it’s details are • User Space opaque to user. Internally, kexec prepares a User space utilities which read the raw 2005 Linux Symposium • 177
physical memory through suitable inter- Program Program Per Cpu Dump faces like /dev/oldmem and write out ELF Header Header Register Memory Header PT_NOTE PT_LOAD States Image the dump image. • Early User Space Utilities that run from initial ramdisk and Figure 5: ELF Core Format Dump Image perform a raw dump to pre-configured disk. This approach is especially useful in Physical memory can be discontiguous and this a scenario when root file system happens means that offset in the core file can not di- to be corrupted after the crash. rectly map to a physical address unless memory holes are filled with zeros in the core file. On For now, we stick to kernel space implemen- some architectures like IA64, holes can be big tation and other solutions (user space or early enough to deter one from taking this approach. user space) can evolve slowly to cater to wide This new approach does not fill memory holes variety of requirements. The following sections with zeros, instead it prepares one program cover implementation details. header for every contiguous memory chunk. It maintains a linked list in which each ele- ment represents one contiguous memory re- 4.5.1 Accessing Dump Image in ELF Core gion. This list is prepared during init time and Format also contains the data to map a given offset to respective physical address. This enables ELF core headers, as stored by crashed ker- /proc/vmcore to determine where to get the nel, are parsed and the dump image is ex- contents from associated with a given offset in ported to user space through /proc/vmcore. ELF core file when a read is performed. Backup region details are abstracted in ELF headers, and /proc/vmcore implementa- gdb can be directly used with tion is not even aware of the presence of the /proc/vmcore for limited debugging. backup region. The physical address of the This includes processor status at the time of start of the ELF header is passed to the cap- crash as well as analyzing linearly mapped ture kernel through the elfcorehdr= com- region memory contents. Non-linearly mapped mand line option. Stored ELF headers undergo areas like vmalloced memory regions can not a sanity check during the /proc/vmcore be directly analyzed because kernel virtual initialization and if valid headers are found addresses for these regions have not been filled then initialization process continues otherwise in ELF headers. Probably a user space utility /proc/vmcore initializaiton is aborted and can be written to read in the dump image, the vmcore file size is set to zero. determine the virtual to physical address mapping for vmalloced regions and export the CPU register states are saved in note sections modified ELF headers accordingly. by crashing kernel and one PT_NOTE type pro- gram header is created for every CPU. To be Alternatively, the /proc/vmcore interface fully compatible with ELF core format, all the can be enhanced to fill in the virtual addresses PT_NOTE program headers are merged into in exported ELF headers. Extra care needs to one during the /proc/vmcore initialization. be taken while handling it in kernel space be- Figure 5 depicts what a /proc/vmcore ex- cause determining the virtual to physical map- ported ELF core images looks like. ping shall involve accessing VM data structures 178 • Kdump, A Kexec-based Kernel Crash Dumping Mechanism of the crashed kernel, which are inherently un- 4. Build the capture kernel as follows. reliable. • Enable kernel crash dumps feature. 4.5.2 Accessing Dump Image in linear raw • The capture kernel needs to boot Format from the memory area reserved by the first kernel. Specify a suitable Physical address The dump image can also be accessed in lin- value for where kernel is loaded ear raw format through the /dev/oldmem in- . terface. This can be especially useful for the • Enable /proc/vmcore support. users who want to selectively read out portions (Optional) of the dump image without having to write 5. Boot into the first kernel with the com- out the entire dump. This implementation of mandline crashkernel=Y@X. Pass ap- /dev/oldmem does not possess any knowl- propriate values for X and Y. Y de- edge of the backup region. It’s a raw dummy notes how much memory to reserve interface that treats the old kernel’s memory for the second kernel and X denotes as high memory and accesses its contents by at what physical address the reserved stitching up a temporary page table entry for memory section starts. For example, the requested page frame. User space applica- crashkernel=32M@16M tion needs to be intelligent enough to read in the stored ELF headers first, and based on these 6. Preload the capture kernel using following headers retrieve rest of the contents. commandline.
kexec -p
• Port kdump to other platforms like x86_64 6.1 Advantages and ppc64.
• More reliable as it allows capturing the • Implement a kernel pages only filtering dump from a freshly booted kernel as mechanism. opposed to some of other methods like LKCD, where dump is saved from the con- text of crashing kernel, which is inherently unreliable. 8 Conclusions • Offers much more flexibility in terms of choosing the dump device. As dump is Kdump has made significant progress in terms captured from a newly booted kernel, vir- of overcoming some of the past limitations, and tually it can be saved to any storage media is on its way to become a mature crash dump- supported by kernel. ing solution. Reliability of the approach is fur- • Framework is flexible enough to accom- ther bolstered with the capture kernel now boot- modate filtering mechanism. User space ing from a reserved area of memory, making or kernel space based filtering solutions it safe from any DMA going on at the time can be plugged in, unlike firmware based of crash. Dump information between the two solutions. For example, a kernel pages kernels is being exchanged via ELF headers, only filter can be implemented on top of providing more flexibility and allowing kernel the existing infrastructure. skew. Usability of the solution has been fur- ther enhanced by enabling the kdump to sup- port PAE systems and discontiguous memory. 6.2 Limitations Capture kernel provides /proc/vmcore and • Devices are not shutdown/reset after a /dev/oldmem interfaces for retrieving the crash, which might result in driver initial- dump image, and more dump capturing mech- ization failure in capture kernel. anisms can evolve based on wide variety of re- • Non-disruptive dumping is not possible. quirements.
There are still issues with driver initialization in the capture kernel, which need to be looked 7 Status and TODOS into.
Kdump has been implemented for i386 and ini- tial set of patches are in -mm tree. Following are some of the TODO items. References
• Harden the device drivers to initialize [01] Hariprasad Nellitheertha, The kexec way properly in the capture kernel after a crash to lightweight reliable system crash event. dumping, Linux Kongress, 2004. 180 • Kdump, A Kexec-based Kernel Crash Dumping Mechanism
[02] The latest kexec tools patches, uously providing ideas and support. Thanks to http://www.xmission.com/ Maneesh Soni for numerous suggestions, re- ~ebiederm/files/kexec/ views and feedback. Thanks to all the others who have helped us in our efforts. [03] Initial Kdump patches, http://marc.theaimsgroup.com/ ?l=linux-kernel&m= 109274443023485&w=2 Legal Statement [04] Booting kernel from non default location patch (bzImage), Copyright c 2005 IBM. http://www.xmission.com/ ~ebiederm/files/kexec/2.6.8. This work represents the view of the author and does 1-kexec3/broken-out/ not necessarily represent the view of IBM. highbzImage.i386.patch IBM, and the IBM logo, are trademarks or reg- [05] Booting kernel from non default location istered trademarks of International Business Ma- patch (vmlinux), chines Corporation in the United States, other coun- http://www.xmission.com/ tries, or both. ~ebiederm/files/kexec/2.6.8. UNIX is a registered trademark of The Open Group 1-kexec3/broken-out/ in the United States and other countries. vmlinux-lds.i386.patch
[06] Improved Kdump patches Linux is a registered trademark of Linux Torvalds in http://marc.theaimsgroup.com/ the United States, other countries, or both. ?l=linux-kernel&m= Other company, product, and service names may be 109525293618694&w=2 trademarks or service marks of others. [07] Andy Pfiffer, Reducing System Reboot References in this publication to IBM products or http: Time with kexec, services do not imply that IBM intends to make //developer.osdl.org/rddunlap/ them available in all countries in which IBM oper- kexec/whitepaper/kexec.pdf ates. [08] Hariprasad Nellitheertha, Reboot Linux This document is provided “AS IS” with no express Faster using kexec, http://www-106. or implied warranties. Use the information in this ibm.com/developerworks/linux/ document at your own risk. library/l-kexec.html
[09] Tool Interface Standard (TIS), Executable and Linking Format (ELF) Specification (version 1.2)
Acknowledgments
The authors wish to express their sincere thanks to Suparna Bhattacharya who had been contin- Proceedings of the Linux Symposium
Volume One
July 20nd–23th, 2005 Ottawa, Ontario Canada Conference Organizers
Andrew J. Hutton, Steamballoon, Inc. C. Craig Ross, Linux Symposium Stephanie Donovan, Linux Symposium
Review Committee
Gerrit Huizenga, IBM Matthew Wilcox, HP Dirk Hohndel, Intel Val Henson, Sun Microsystems Jamal Hadi Salimi, Znyx Matt Domsch, Dell Andrew Hutton, Steamballoon, Inc.
Proceedings Formatting Team
John W. Lockhart, Red Hat, Inc.
Authors retain copyright to all submitted papers, but have granted unlimited redistribution rights to all as a condition of submission.