RU2393530C2 - Method for formation of dump file - Google Patents

Abstract

FIELD: information technologies.

SUBSTANCE: method for formation of nucleus dump file in case of failure in program operated on computer includes the following operations: all areas of memory used by the program at the moment of failure are detected; instantaneous picture of central processor registers is taken at the moment of failure in the program; heading of dump file is formed, using data of instantaneous picture of central processor registers condition; area comprising program stack is identified in all areas of memory; value of program stack beginning indicator is identified, using instantaneous picture of processor registers; area comprising program stack is reduced in memory, at the same time initial address of this memory area is shifted multiply in direction of stack beginning indicator; reduced area of memory comprising program stack is saved; final file is formed, using it to save data of instantaneous picture of central processor register and reduced area of memory comprising program stack.

EFFECT: expansion of functional capabilities.

3 cl, 3 dwg

Description

The invention relates to computer technology, and in particular to systems and methods for generating a dump file when a program malfunctions (program terminates abnormally) in computing systems with limited resources.

During debugging and testing the program, it may crash. In the event of a program execution failure using the kernel of the computer operating system, the so-called dump information is generated: a kernel file is dumped - a snapshot of the state of the program at the time the failure occurs. The dump file helps the developer identify the source of the problem that caused the program to crash. The core dump function is primarily intended for servers and workstations that have large amounts of memory and many storage devices.

Embedded computer operating systems typically have significantly less memory and often do not have enough space to save core dump files. Under such conditions, it is impossible to create complete and serviceable core dump files.

There are various approaches to solving the problem of dump file formation.

In the method described in US patent No. 7,010,725 [1], if a program malfunction occurs, the contents of the memory (kernel) are stored in the main memory of the computer and, if the size of the dump file exceeds the size of the main memory, part of the dump file is automatically saved to additional storage A device that is permanently connected to a computer.

The disadvantage of this method is the need for an additional storage device, which increases the cost of the computer and complicates the implementation of the method.

Closest to the claimed invention is a method of generating a core file dump, proposed in US patent No. 6,681,348 [2], in which in case of a malfunction in the program, the computer operating system creates a full core file dump (dump of the entire physical memory of the computer). Then, from this file, using a special software tool, an abbreviated so-called “mini dump file" is created, which includes reference information, the structure of the stream data, the structure of the stack data (processor registers), the structure of the process data, the list of loaded modules and the information control unit computer memory. This method is selected as a prototype of the claimed invention.

The disadvantage of the prototype method is that it does not take into account the features of embedded systems of computers with limited resources, namely with a limited amount of memory, in which a complete core file cannot be completely saved in the computer’s memory, and therefore, a mini core dump file. In addition, according to the prototype method, the contents of the stacks of the program in which the failure occurred are not recorded in the mini dump file, although such data is important for analyzing the causes of the failure of the program. These shortcomings worsen the functionality of the prototype method [2].

The objective of the claimed invention is to provide a system and method for generating a dump file with reduced cost, complexity of execution and increased functionality by creating a dump file of a reduced size, while storing in it only the most important information that describes the program crash directly and not including it in the dump file of information contained in additional memory areas.

The problem is solved by creating a method of dumping the kernel file in the event of a malfunction in the program running on the computer, which includes the following operations

- determine all the areas of memory that the program uses at the time of the failure;

- create a snapshot of the state of the registers of the central processor at the time of a failure in the program;

- form the header of the dump file, while using data of a snapshot of the status of the registers of the central processor;

- determine in all areas of memory the area that contains the program stack;

- determine the value of the pointer to the beginning of the program stack, while using a snapshot of the processor registers;

- reduce the memory area that contains the program stack, while repeatedly shifting the start address of this memory area in the direction of the pointer to the beginning of the stack;

- save the reduced memory area that contains the program stack;

- form the final file, while storing in it the data of a snapshot of the status of the registers of the central processor and the reduced memory area that contains the program stack.

The system and method for creating core dump files in a system with limited resources allows you to save information about the causes of a failure in the program. The kernel, which controls the embedded system, in case of failures should save only the most important information describing the failure of the program, and not save the information contained in additional memory areas. This approach allows you to satisfy the conditions of limited free memory in embedded systems and at the same time gives developers the opportunity to debug the program.

To perform the method, it is important that the starting address of this memory area is shifted in the direction of the stack start pointer repeatedly with the maximum possible number of repetitions.

To perform the method, it is important that the resulting file is formed in the built-in storage device.

The technical result of the claimed invention is to reduce the cost, complexity of execution and increase the functionality of the method of forming a dump file.

For a better understanding of the claimed invention the following is a detailed description with the corresponding drawings.

Figure 1. Schematic of a computer with an embedded operating system represented by a kernel with a running program.

Figure 2. The scheme for generating a dump file in a computer with an embedded operating system, made according to the invention.

Figure 3. Scheme for reducing the memory area of the embedded operating system of a computer containing a stack of a program in which a failure has occurred made according to the invention.

A standard computer (FIG. 1), in which the claimed method can be performed, includes a central processor 1, an internal memory module 2, and an integrated operating system 3. In operating condition, the operating system 3 is loaded into the internal memory of the computer. The area of internal memory into which the operating system is loaded consists of the area into which the kernel 4 of the operating system is loaded, and the area 5-10 of the user. Moreover, the operating system 3 is configured to control the user program 11 and the ability to generate a dump file 12. The dump file 12 includes the contents of snapshots 6-10 of the user program memory and snapshots 13 of the central processor registers. The dump file creation tool 14 is part of the operating system 3. The user program 11 consists of a header 15, an executable part 6, and initialized data 7.

In the event of a failure (Figure 2) in the program 11, consisting of the header 15, the executable part 6 and the initialized data 7, under the control of the kernel 4 of the embedded operating system 3, the computer stores the following information about the state of the emergency program: images (snapshots) 13 processor registers at the time of program 11 failure, areas that include the contents of the emergency program stack 10.

The method of dumping the kernel file in the event of a malfunction in the program 11 running on a computer with an embedded operating system 3 includes the following operations (Figure 2-3). All memory areas 2 used by program 11 at the time of the failure are determined (memory areas used by the program are designated 6-10; memory areas not used by the program are indicated 5). A snapshot 13 of the state of the registers of the central processor 1 is created at the time of a failure in the program 11. A header 15 of the dump file is generated, while the data of the snapshot 13 of the status of the registers of the central processor 1 is used. In the above embodiment, the header of the dump file is generated by sequentially saving the following objects :

- service information about the number of stored memory areas (in this case, it will be one area containing the call stack of the program in question),

- a snapshot of the processor registers (in particular, containing in one form or another a pointer to the beginning of the call stack; most often, the processor provides the developer with the opportunity to read the register containing the mentioned pointer),

- other objects necessary for the software debugger, for example, the values of the variables of the kernel of the operating system.

In all memory areas, the area that contains the program stack is determined. It should be noted that in the claimed invention, by the stack is meant a stack of function calls of the program in question. In the case when the program is executed in several threads, which implies the existence of a separate stack for each thread, only the stack of the thread in which the failure occurred is considered (usually operating systems exclude the ability of the thread to access a foreign call stack).

The value of the pointer to the beginning of the program stack is determined, and an instant snapshot of the processor registers is used. As you know, most processors have a register that is used to execute commands from the instruction stack. This register is called a stack pointer. A snapshot of the processor registers contains the value of all the registers at the time of the failure and, in particular, the value of the “stack pointer” register. To determine the value of the stack pointer is to read the value of the stack pointer register from a snapshot.

Reduce in memory the region that contains the program stack, while repeatedly (with the maximum possible number of repetitions) shift the starting address of this memory region in the direction of the stack start pointer (the process of decreasing the memory region is indicated by 16 in FIG. 2 and is illustrated in detail in FIG. 3) . Save the reduced memory area 17, which contains the program stack. The resulting file 18 is formed, while the data of the snapshot 13 of the state of the registers of the central processor 1 and the reduced memory area that contains the program stack are stored in it. Moreover, the final file can be formed in the built-in storage device. It should be noted that the resulting file is a kernel dump file with limited capabilities (compared to a regular, complete dump file). In particular, the resulting dump file allows you to view only the call stack of a crash program. While a complete dump file allows you to view the values of program variables, etc.

The reduction of the memory area containing the emergency program stack 10 (FIG. 3) in the embedded operating system 3 consists in a multiple (with the maximum possible number of repetitions) shift 19 of the start address 20 in the direction of the stack start pointer 21. The program stack is designated 22. The task of reducing the area containing the call stack is considered to be solved when it is impossible to shift the starting address of the memory area in the direction of the stack pointer, without exceeding the value of the stack pointer. It is believed that the stack grows toward the final address of the memory area in which it is contained. Thus, shifting the start address of the memory area cannot damage the call stack.

In the claimed method, only the following data is stored in the dump file: data of a snapshot of the state of the registers of the central processor and a reduced memory area that contains the program stack (Figure 2). In this case, the size of the core file dump is much smaller than the amount of memory occupied by the program at the time of the crash, amounting to about 1-5% of the memory. Thus, the resource constraints of the embedded operating system of the computer are satisfied.

The claimed invention can be applied in various types of computer devices.

Although the above embodiment of the invention has been set forth to illustrate the present invention, it is clear to those skilled in the art that various modifications, additions and substitutions are possible without departing from the scope and meaning of the present invention disclosed in the attached claims.

Claims (3)

1. A method of generating a core file dump in the event of a malfunction in a program running on a computer, which includes the following operations:
determine all areas of memory that the program uses at the time of the failure;
create a snapshot of the state of the registers of the central processor at the time of a failure in the program;
form the header of the dump file, while using data of a snapshot of the status of the registers of the central processor;
define in all memory areas the region that contains the program stack;
determine the value of the pointer to the beginning of the program stack, while using a snapshot of the processor registers;
reduce in memory the area that contains the program stack, while repeatedly shifting the starting address of this memory area in the direction of the stack start pointer;
save the reduced memory area that contains the program stack;
form the final file, while storing in it the data of a snapshot of the status of the registers of the central processor and the reduced memory area that contains the program stack. 2. The method according to claim 1, characterized in that the starting address of the given memory area is shifted in the direction of the stack start pointer repeatedly with the maximum possible number of repetitions. 3. The method according to claim 1, characterized in that form the resulting file in the built-in storage device.

Images