Information processing device, information processing program, and information processing method

Abstract

To quickly recover an information processing apparatus from a kernel panic.SOLUTION: An information processing apparatus includes: a kernel boot unit that reboots a kernel executing a kernel panic; a generation unit that acquires a content of a first region of a memory used by the kernel when executing the kernel panic and generates a dump file including the content; and a program boot unit that allocates a program different from the kernel to a second region different from the first region in the memory and boots the program on the rebooted kernel.SELECTED DRAWING: Figure 5

Description

[Technical field]

[0001] The present invention relates to an information processing device, an information processing program, and an information processing method. [Background technology]

[0002] When the kernel of a computer's OS (Operating System) detects a fatal error, the kernel executes a process called a kernel panic to protect the computer. For example, a kernel panic is executed when an application program references a physically corrupted memory area.

[0003] When a kernel panic occurs, the dump collection kernel included in the OS creates a memory dump file and writes it to a storage device such as a disk. The dump file contains information about the memory contents referenced by the kernel just before the kernel panic occurred, and the contents of the CPU (Central Processing Unit) registers. Administrators can analyze the dump file to identify the cause of the computer failure.

[0004] However, even if there is no failure in the computer's hardware resources, the computer cannot be restored while the dump collection kernel is generating a dump file, and the computer's hardware resources cannot be used effectively.

[0005] In addition, most of the dump file is taken up by the contents of memory that the kernel referenced, so as the kernel becomes more sophisticated and the memory area it references becomes larger, it takes a long time to generate the dump file, which means it takes a long time to restore the computer. [Prior art documents] [Patent documents]

[0006] [Patent Document 1] JP 2001-290678 A [Patent Document 2] Japanese Patent Application Publication No. 10-333944 [Patent Document 3] JP 2008-242999 A [Patent Document 4] JP 2001-290677 A [Patent Document 5] Japanese Patent Application Publication No. 8-95834 Summary of the Invention [Problem to be solved by the invention]

[0007] According to one aspect, an object of the present invention is to quickly restore an information processing device from a kernel panic. [Means for solving the problem]

[0008] According to one aspect, a system includes a kernel launching unit that restarts a kernel that has executed a kernel panic; a generating unit that acquires contents of a first area of ​​memory that was used by the kernel when the kernel panic occurred and generates a dump file including the contents; and a program launching unit that assigns a program different from the kernel to a second area in the memory that is different from the first area and launches the program on the restarted kernel. The generation unit releases the first area after acquiring the content, and the program startup unit waits for the generation unit to release the first area if the size of the second area is insufficient to start the program. An information processing device is provided. Effect of the Invention

[0009] According to one aspect, it is possible to quickly restore an information processing device from a kernel panic. [Brief description of the drawings]

[0010] [Figure 1] FIG. 1 is a schematic diagram showing the process of restarting a kernel that has executed a kernel panic. [Diagram 2] FIG. 2 is a hardware configuration diagram of the information processing device according to this embodiment. [Diagram 3] FIG. 3 is a schematic diagram of each program included in the OS according to this embodiment. [Figure 4] FIG. 4 is a schematic diagram of the memory according to the present embodiment. [Diagram 5] FIG. 5 is a functional configuration diagram of the information processing device according to this embodiment. [Figure 6] FIG. 6 is a flowchart showing the process of booting the OS in this embodiment. [Figure 7] FIG. 7 is a flowchart of the information processing method according to the present embodiment when the kernel executes a kernel panic. [Figure 8] FIG. 8 is a schematic diagram of the information processing method according to the present embodiment. [Figure 9] FIG. 9 is a schematic diagram of dump information according to the present embodiment. [Figure 10] FIG. 10 is a schematic diagram of an ELF header according to this embodiment. [Figure 11] FIG. 11 is a flowchart of firmware processing according to this embodiment. [Figure 12] FIG. 12 is a schematic diagram showing how a chunk is set to be read-only in this embodiment. [Figure 13] FIG. 13 is a flowchart of the process after the kernel is restarted in this embodiment. [Figure 14] FIG. 14 is a schematic diagram of a dump file according to the present embodiment. [Figure 15] FIG. 15 is a schematic diagram of the management table according to the present embodiment. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

[0011] Prior to describing this embodiment, basic matters will be described.

[0012] FIG. 1 is a schematic diagram showing the process of restarting a kernel that has executed a kernel panic.

[0013] In this example, it is assumed that a system is implemented using multiple computers and a kernel panic occurs on one of the computers.

[0014] In this case, first, the kernel that has executed the kernel panic starts the dump collection kernel (step P1).

[0015] Next, the dump collection kernel generates a dump file including CPU core register information and memory information (step P2). The CPU core register information is the contents of the registers that the kernel referenced immediately before the kernel panic was executed. The memory information is the contents of the memory area that the kernel referenced immediately before the kernel panic was executed.

[0016] When the generation of the dump file is completed, the firmware is started (step P3), and the firmware restarts the kernel (step P4).

[0017] After that, the restarted kernel starts various service programs (P5). Such service programs include "dhcpd", a client daemon for the DHCP (Dynamic Host Configuration Protocol).

[0018] When these service programs are started, various application programs can be executed on the computer, and the system including the computer can be operated.

[0019] However, with this method, the kernel cannot be restarted in step P4 until the dump file has been generated in step P2, and it takes time before the system can resume operation.

[0020] In particular, as the kernel becomes more sophisticated and the memory area to be collected increases, it takes a long time to generate the dump file in step P2, and it takes even longer to resume system operation.

[0021] (Present embodiment) FIG. 2 is a hardware configuration diagram of the information processing device according to this embodiment.

[0022] The information processing device 10 is a computer such as a physical machine or a virtual machine, and includes a storage device 10a, a memory 10b, a CPU 10c, a communication interface 10d, and a medium reading device 10e. These components are connected to each other via a bus 10g.

[0023] Of these, the storage device 10a is a non-volatile storage such as a hard disk drive (HDD) or a solid state drive (SSD), and stores an information processing program 11 according to this embodiment. The information processing program 11 is a program including firmware 12 and an OS 13.

[0024] The information processing program 11 may be recorded on a computer-readable recording medium 10f, and the information processing program 11 may be read by the CPU 10c via the medium reader 10e.

[0025] Such recording media 10f include physically portable recording media such as CD-ROMs (Compact Disc - Read Only Memory), DVDs (Digital Versatile Discs), and USB (Universal Serial Bus) memories. Semiconductor memories such as flash memories and hard disk drives may also be used as the recording media 10f. These recording media 10f are not temporary media such as carrier waves that do not have a physical form.

[0026] Furthermore, the information processing program 11 may be stored in a device connected to a public line, the Internet, a LAN (Local Area Network), etc. In that case, the CPU 10c may read and execute the information processing program 11.

[0027] On the other hand, the memory 10b is hardware that temporarily stores data, such as a dynamic random access memory (DRAM).

[0028] The CPU 10c is a processor that controls each unit of the information processing device 10. Note that a GPU (Graphical Processing Unit) may be used instead of the CPU 10c. The CPU 10c also executes the information processing program 11 in cooperation with the memory 10b.

[0029] Furthermore, the communication interface 10d is hardware such as a network interface card (NIC) for connecting the information processing device 10 to a network such as the Internet or a LAN.

[0030] The medium reader 10e is hardware such as a CD drive, a DVD drive, or a USB interface for reading the recording medium 10f.

[0031] 3 is a schematic diagram of each program included in the OS 13. The OS 13 is, for example, Linux (registered trademark), and includes a kernel 15, a dump collection kernel 16, a service program 17, and a management program 18.

[0032] Among these, the kernel 15 is a core program of the OS 13 that has a process management function, a memory management function, a device management function, etc. The dump collection kernel 16 is a program that collects dump information when the kernel 15 executes a kernel panic.

[0033] The service programs 17 are programs different from the kernel 15 and are daemon programs such as "dhcpd" that run in the background. The management programs 18 are programs such as "systemd" that start up these service programs 17.

[0034] Fig. 4 is a schematic diagram of the memory 10b. As shown in Fig. 4, a firmware area 21, a common area 22, a kernel area 23, and a dump collection kernel area 24 are allocated to the memory 10b.

[0035] Of these, the firmware area 21 is an area allocated to the firmware 12. The common area 22 is an example of a fourth area, and is an area in which both the firmware 12 and the kernel 15 can write and read data.

[0036] The kernel area 23 is an area allocated to the kernel 15. And the dump collection kernel area 24 is an area allocated to the dump collection kernel 16.

[0037] Fig. 5 is a functional configuration diagram of the information processing device 10. As shown in Fig. 5, the information processing device 10 includes a control unit 31 in addition to the storage device 10a and memory 10b described above. The control unit 31 is a processing unit that is realized by the memory 10b and the CPU 10c working together to execute the information processing program 11, and controls each unit of the information processing device 10.

[0038] As an example, the control unit 31 includes a kernel startup unit 32, a generation unit 33, a service program startup unit 34, an allocation unit 35, a storage unit 36, an acquisition unit 37, a memory management unit 38, and a determination unit 39.

[0039] Among these, the kernel startup unit 32 is a processing unit realized by the firmware 12, and restarts the kernel 15 that has executed the kernel panic.

[0040] The generation unit 33 is a processing unit realized by the dump collection kernel 16, and generates a dump file 40 when the kernel 15 executes a kernel panic and stores it in the storage device 10a.

[0041] The service program starting unit 34 is a processing unit realized by the management program 18, and starts each service program 17 on the restarted kernel 15.

[0042] The allocation unit 35 is a processing unit implemented by the firmware 12, and allocates the shared area 22 in the memory 10b.

[0043] The storage unit 36 ​​is a processing unit realized by the dump collection kernel 16, and stores a dump primary information file including the address and size of the chunk of memory 10b at the time when the kernel panic was executed in the common area 22. The chunk is an area of ​​memory 10b that was being used by the kernel 15 at the time when the kernel panic was executed. For example, before executing the kernel panic, the kernel 15 secures each chunk in memory 10b by a function such as malloc.

[0044] The acquisition unit 37 is a processing unit realized by the firmware 12, and acquires the address and size of a chunk from a dump primary information file stored in the shared area 22, which will be described later.

[0045] The memory management unit 38 is a processing unit implemented by the firmware 12, and sets chunks of the memory 10b to read-only.

[0046] The determination unit 39 is a processing unit realized by the dump collection kernel 16, and determines whether or not the memory 10b has enough free space to restart the kernel 15 after executing a kernel panic.

[0047] Next, an information processing method according to this embodiment will be described.

[0048] 6 is a flowchart for starting the OS 13. First, the allocation unit 35 allocates the shared area 22 to the memory 10b (step S11).

[0049] Next, the firmware 12 stores the start address of the common area 22 in an EFI (Extensible Firmware Interface) variable (step S12). The EFI variable is a variable that is transferred between the firmware 12 and the dump collection kernel 16.

[0050] Next, the kernel starting unit 32 starts the kernel 15 (step S13). After that, the service program starting unit 34 starts each service program 17, and the start-up of the OS 13 is completed.

[0051] Next, a process flow when the kernel 15 executes a kernel panic after the OS 13 has been started in this manner will be described.

[0052] FIG. 7 is a flowchart of the information processing method according to this embodiment when the kernel 15 executes a kernel panic.

[0053] First, the kernel 15 that has executed the kernel panic starts the dump collection kernel 16 (step S21).

[0054] Next, the dump collection kernel 16 acquires the start address of the common area 22 by referring to the EFI variables held by the firmware 12 (step S22).

[0055] The following steps S23 and S24 will be described with reference to Fig. 8. Fig. 8 is a schematic diagram of the information processing method according to this embodiment.

[0056] First, in step S23, the dump collection kernel 16 reads the contents of the VMCORE 43 in the virtual memory 42 of the kernel 15 that executed the kernel panic. The VMCORE 43 is a pseudo file that can be read as a file in the ELF (Executable and Linkable Format) Core format, and is a pseudo file that stores the dump information 45.

[0057] Fig. 9 is a schematic diagram of the dump information 45. As shown in Fig. 9, the dump information 45 is information that includes an ELF header 45a, a first header 45b, and a second header 45c.

[0058] Among these, the ELF header 45a is a structure including variables that specify the architecture of the CPU 10c. The first header 45b is a pointer that points to the registers of each of the multiple cores included in the CPU 10c. Hereinafter, the information stored in the register of the i-th core will be referred to as the core[i] register information.

[0059] The second header 45c is a pointer to the top address of the chunk in the memory 10b that was being used by the kernel 15 at the time the kernel panic was executed.

[0060] Fig. 10 is a schematic diagram of the ELF header 45a. As shown in Fig. 10, the ELF header 45a is a structure having a variable "e_phoff" that stores the start address of the program header table 45e and a variable "e_phnum" that indicates the number of program headers 45f.

[0061] The program header table 45e is a table of a plurality of program headers 45f including a variable "p_paddr" and a variable "p_memsz." Of these, the variable "p_paddr" is a variable indicating the start address of the chunk 10y that was allocated to the kernel 15 at the time when the kernel panic was executed. The variable "p_memsz" is a variable indicating the size (bytes) of the chunk 10y. The chunk 10y is an example of the first area.

[0062] In step S23, the dump collection kernel 16 acquires the start address and size of each chunk 10y by referring to the variables “p_paddr” and “p_memsz.” Furthermore, the dump collection kernel 16 also acquires the first header 45b and the second header 45c described above.

[0063] 8 again. Next, the process proceeds to step S24, where the storage unit 36 ​​stores the dump primary information file 47 including the information acquired in step S23 in the common area 22. The dump primary information file 47 includes the first header 45b, the program header table 45e, and the ELF header 45a.

[0064] 8, the chunk 10y corresponds to a page in the virtual memory 42, and the total area of ​​the virtual memory 42 is equal to the combined area of ​​all the chunks 10y. The area in the kernel area 23 that does not belong to the chunk 10y is the free area 10x that is not used by the kernel 15.

[0065] Referring again to Fig. 7, the determination unit 39 then determines whether the continuous free space 10x required to restart the kernel 15 exists in the memory 10b (step S25).

[0066] In the example of FIG. 8, the judgment unit 39 judges whether the area having the largest size among the plurality of free areas 10x is sufficient to restart the kernel 15. As an example, the judgment unit 39 identifies the start address and size of each chunk 10y based on each variable "p_paddr" and "p_memsz" of the dump primary information file 47 in the common area 22, and identifies the size of each free area 10x that does not belong to any chunk 10y. Then, the judgment unit 39 judges whether the maximum value among the sizes of each identified free area 10x is larger than the size required to restart the kernel 15. The size required to restart the kernel 15 may be checked in advance by the user, for example, and stored in the storage device 10a.

[0067] Moreover, each of the free areas 10x is an example of a second area, and the free area 10x having the largest size among them is an example of a third area.

[0068] If the determination in step S25 is positive, the process proceeds to the processing of the firmware 12 (step S26). On the other hand, if the determination in step S25 is negative, the kernel 15 cannot be restarted until a dump file 40 including the contents of each chunk 10y is generated and each chunk 10y is released.

[0069] Therefore, if the determination in step S25 is negative, the process proceeds to step S27, where the generation unit 33 generates the dump file 40, and then the kernel startup unit 32 restarts the kernel 15, and the process ends.

[0070] According to this, in step S24, the storage unit 36 ​​stores the dump primary information file 47 in the common area 22. Therefore, in step S25, the determination unit 39 can identify the free area 10x having the maximum size based on the variables “p_paddr” and “p_memsz” of the dump primary information file 47 and determine whether the size is sufficient to restart the kernel 15.

[0071] Next, the process of the firmware 12 in step S26 will be described.

[0072] FIG. 11 is a flowchart of the process of the firmware 12 in step S26.

[0073] First, the memory management unit 38 sets all chunks 10y to read-only (step S31).

[0074] 12 is a schematic diagram of this step. In this example, the memory management unit 38 identifies the start address and size of each chunk 10y from the dump primary information file 47 stored in the common area 22. Then, the memory management unit 38 sets "EFI_MEMORY_RO" to the attribute corresponding to the chunk 10y in the EFI memory map, thereby making the chunk 10y read-only.

[0075] This makes it possible to prevent the chunk 10y from being overwritten before the dump file 40 is generated, so that the dump file 40 including the contents of the chunk 10y can be generated.

[0076] 11 again. Next, the kernel startup unit 32 restarts the kernel 15 that executed the panic without turning off the power of the information processing device 10 (step S32). With the above, the basic processing executed by the firmware 12 is completed.

[0077] Next, the process after the kernel 15 is restarted in step S32 will be described.

[0078] 13 is a flowchart of the process after the kernel 15 is restarted. First, the restarted kernel 15 turns on the reversed bit corresponding to each chunk 10y among the reversed bits included in the structure that manages the memory 10b. The reversed bit is a bit that determines whether the chunk 10y is to be read-only, and turning it on makes the chunk 10y read-only.

[0079] After this, the dump collection process Q1 and the start-up process Q2 of the service program 17 are carried out in parallel.

[0080] First, the dump collection process Q1 will be described. First, the restarted kernel 15 starts the dump collection kernel 16 (step S42).

[0081] Next, the generating unit 33 judges whether or not a chunk 10y whose contents have not yet been acquired exists in the memory 10b (step S43).

[0082] If this determination is affirmative, the process proceeds to step S44. In step S44, the generation unit 33 acquires the contents of the chunk 10y. As an example, the generation unit 33 identifies the start address and size of the chunk 10y from the variables "p_paddr" and "p_memsz" included in the dump primary information file 47 in the common area 22. The generation unit 33 then accesses the identified start address in the memory 10b and acquires the contents stored in an area of ​​the identified size from the start address.

[0083] Next, the generation unit 33 turns off the Reversed bit corresponding to the chunk 10y whose contents were acquired in step S44 (step S45). This releases the chunk 10y and makes it writable. Then, the process returns to step S43.

[0084] On the other hand, if the determination in step S43 is negative, the process proceeds to step S46. In step S46, the generation unit 33 generates a dump file 40 including the contents of each of the multiple chunks 10y and the contents included in the dump primary information file 47. This ends the dump collection process Q1.

[0085] FIG. 14 is a schematic diagram of the dump file 40 generated in step S46.

[0086] As shown in FIG. 14, the dump file 40 includes the ELF header 45a, the first header 45b, and the second header 45c in the dump primary information file 47, as well as the content 52 of the chunk 10y acquired in step S44.

[0087] Furthermore, the generation unit 33 also stores in the dump file 40 CPU core register information 51, which is information stored in each register pointed to by the first header 45b.

[0088] Referring again to Figure 13, the start-up process Q2 of the service program 17 will now be described.

[0089] First, after the kernel 15 starts the management program 18, the service program starting unit 34 judges whether there are any service programs 17 that have not been started (step S47). In Linux (registered trademark), the service programs 17 that should be started after the kernel 15 is started and the order in which they should be started are defined, and in this step the service program starting unit 34 judges whether these service programs 17 have already been started.

[0090] If this determination is affirmative, the process proceeds to step S48. In step S48, the service program starting section 34 determines whether or not a free area 10x having a size necessary for starting the service program 17 exists in the memory 10b.

[0091] FIG. 15 is a schematic diagram of the management table 53 used by the service program starting unit 34 in the determination in step S48.

[0092] The management table 53 is a table that associates the start order, program names, and memory amounts required for start-up of the service programs 17. The start order and program names are predetermined in Linux (registered trademark), but the memory amounts are, for example, checked in advance by the user. The user then creates the management table 53 and stores it in advance, for example, in the storage device 10a.

[0093] The service program starting unit 34 refers to this management table 53 to determine in step S48 whether or not there is a free area 10x whose size is larger than the memory amount of the service program 17 to be started.

[0094] For example, the service program startup unit 34 acquires the start address and size of the chunk 10y from the variables “p_paddr” and “p_memsz” included in the dump primary information file 47 in the common area 22. Then, the service program startup unit 34 specifies the size of the free area 10x, which is an area that does not belong to any of the multiple chunks 10y, based on the start address and size, and compares the size with the memory amount in the management table 53.

[0095] 13 again. If the determination in step S48 is negative, the process proceeds to step S50. In step S50, the service program activation unit 34 waits for the generation unit 33 to release the chunk 10y in step S45. Then, the process returns to step S48.

[0096] On the other hand, if the determination in step S48 is positive, the service program starting unit 34 starts the service program 17 by allocating the free area 10x to the service program 17 (step S49), and the process returns to step S47.

[0097] Then, when all the service programs 17 have been started and the determination in step S47 is negative, the start-up process Q2 ends.

[0098] This completes the basic processing of the dump collection process Q1 and the service program startup process Q2.

[0099] According to the present embodiment described above, in step S49, the service program starting unit 34 allocates the service program 17 to a free area 10x that is different from the chunk 10y that the kernel 15 has been using, and starts the service program 17.

[0100] Therefore, the dump collection process Q1 for acquiring the contents of the chunk 10y and the startup process Q2 for the service program 17 can be performed in parallel. This makes it possible to shorten the time from when the kernel 15 executes a kernel panic to when all the service programs 17 are started, compared to when the startup process Q2 is executed after the dump collection process Q1 is completed. As a result, even if the kernel 15 executes a kernel panic, the information processing device 10 can be quickly restored, and the user can immediately use the system including the information processing device 10.

[0101] In this example, the service program starting unit 34 waits for the chunk 10y to be released in step S50. Therefore, the service program starting unit 34 allocates the free area 10x that is generated by releasing the chunk 10y to the service programs 17, and the service programs 17 can be started sequentially in step S49.

[0102] Furthermore, if the memory 10b does not have the continuous free space 10x required to restart the kernel 15, the dump collection process Q1 and the startup process Q2 are not executed in parallel, and the kernel 15 is restarted after the dump file 40 is generated (step S27). This makes it possible to generate the dump file 40 regardless of whether the memory 10b has the continuous free space 10x required to restart the kernel 15. [Explanation of symbols]

[0103] 10...information processing device, 10a...storage device, 10b...memory, 10d...communication interface, 10e...media reader, 10f...recording medium, 10g...bus, 10x...free area, 10y...chunk, 11...information processing program, 12...firmware, 15...kernel, 16...dump collection kernel, 17...service program, 18...management program, 21...firmware area, 22...common area, 23...kernel area, 24...dump collection kernel area, 31...control control unit, 32...kernel startup unit, 33...generation unit, 34...service program startup unit, 35...allocation unit, 36...storage unit, 37...acquisition unit, 38...memory management unit, 39...judgment unit, 40...dump file, 42...virtual memory, 45...dump information, 45a...ELF header, 45b...first header, 45c...second header, 45e...program header table, 45f...program header, 47...dump primary information file, 51...CPU core register information, 53...management table.

Claims

1. A kernel startup part that restarts the kernel that executed the kernel panic; a generator that acquires contents of a first area of ​​memory that was used by the kernel when the kernel panic occurred and generates a dump file including the contents; a program launching unit that allocates a program different from the kernel to a second area in the memory different from the first area and launches the program on the restarted kernel; having The generation unit releases the first area after acquiring the content, The information processing device according to claim 1, wherein the program startup unit waits for the generation unit to release the first area when the size of the second area is insufficient to start the program.

2. 2 . The information processing apparatus according to claim 1 , wherein the program starting section starts the program in parallel with the generation of the dump file.

3. if a third area having a size necessary for restarting the kernel does not exist in the memory, the generating unit generates the dump file and releases the first area; 2 . The information processing apparatus according to claim 1 , wherein the kernel startup unit restarts the kernel after releasing the first area.

4. a storage unit that stores a size and a leading address of the first area in a fourth area of ​​the memory that is different from each of the first area and the second area; 4. The information processing apparatus according to claim 3, further comprising a determination unit that determines whether the third area exists in the memory based on the size and the top address stored in the fourth area.

5. 2. The information processing apparatus according to claim 1, further comprising a memory management section for making the first area read-only.

6. Reboot the kernel that caused the kernel panic, obtaining contents of a first region of memory that was in use by the kernel when the kernel panic occurred and generating a dump file including said contents; allocating a program different from the kernel to a second area different from the first area in the memory, and starting the program on the restarted kernel; Releasing the first area after obtaining the content; If the size of the second area is insufficient to start the program, the program waits for the first area to be released. An information processing program for causing a computer to execute processing.

7. The computer Reboot the kernel that caused the kernel panic, obtaining contents of a first region of memory that was in use by the kernel when the kernel panic occurred and generating a dump file including said contents; allocating a program different from the kernel to a second area different from the first area in the memory, and starting the program on the restarted kernel; Releasing the first area after obtaining the content; If the size of the second area is insufficient to start the program, the program waits for the first area to be released.

2. An information processing method comprising:

Images