A method and device for parsing key information of device tree in the initial stage of operating system startup

Abstract

The present invention discloses a method and apparatus for parsing key device tree information during the initial startup of an operating system. The method comprises obtaining a device tree DTB file; traversing a token, searching for a struct_offset value from a header, and obtaining a tokentype from the first u32 data; calculating and offsetting the token length based on the tokentype; querying a BeginNode; traversing the attributes within the node after finding the BeginNode; querying the location of the attributes; querying the device type; determining whether the device type is memory; and if the device type is memory, extracting the attributes within the device tree and calling a closure to pass the information to the caller. The present invention has a high degree of automation and high creation accuracy.

Description

Technical Field

[0001] The present invention relates to the technical field of operating systems, and in particular discloses a method and apparatus for parsing key information of a device tree at the initial stage of operating system startup. Background Art

[0002] The device tree is a data structure that describes hardware. The bootloader uses the device tree to communicate system device information to the operating system. The device tree consists of nodes, each of which includes a name and several attributes. Node attributes consist of a name and a value. Nodes can also contain child nodes. The entire device tree is like an inverted tree, with nodes as the trunk and attributes as leaves, similar to the directory structure of a file system. The source file extension for the device tree is dts. After being compiled with dtc, dts becomes a binary dtb file. When booting the operating system, the bootloader places the dtb in a specific memory block and passes the dtb's memory address to the operating system. dts is a textual description of the device tree, allowing for intuitive viewing and modification. dtb is a binary description of the device tree, making it easier to parse code. Similarly, to facilitate access to device tree information by the operating system device driver, a device tree description format must be established in memory. This is similar to how a file system has one storage format on disk and another description format in memory. DTB (Device Tree Blob, a flat binary encoding of device tree data) is composed of several nodes. The number of nodes and the hierarchical relationship of the nodes are unknown, so it is necessary to dynamically allocate the required memory for each node when parsing the DTB. However, the system's available memory information (memory address and size) is stored in the device tree. In other words, at the beginning of the operating system startup, it is necessary to know the available memory information and use it to initialize the memory manager. However, the available memory information is stored in the DTB, and parsing the DTB requires the memory manager to allocate memory. This makes it impossible to parse the device tree file normally and the system device cannot be initialized.

[0003] Therefore, the existing technology cannot normally parse the device tree file in the early stage of operating system startup, and the system devices cannot be initialized, which is a technical problem that needs to be solved urgently. Summary of the Invention

[0004] The present invention provides a method and apparatus for parsing key information of a device tree at the initial stage of an operating system startup, aiming to solve the technical problem in the prior art that the device tree file cannot be parsed normally at the initial stage of an operating system startup and the system devices cannot be initialized.

[0005] One aspect of the present invention relates to a method for parsing key information of a device tree during an initial startup of an operating system, comprising the following steps:

[0006] Step S100: Get the device tree DTB file. The starting position of the DTB file is the Header, which is used to describe the key information of the entire DTB. The node information is stored at the struct_offset of the Header. The struct consists of several consecutive tokens. The first u32 data is used to indicate the token type. The subsequent data is related to the token type. The tokentype structure contains the node start, node end, and attribute content.

[0007] Step S200, traverse token, find struct_offset value from Header, and get tokentype from the first u32 data;

[0008] Step S300: Calculate and offset the token length according to the tokentype;

[0009] Step S400, query BeginNode;

[0010] Step S500: After finding BeginNode, traverse the attributes in the node;

[0011] Step S600: query the location of the attribute;

[0012] Step S700: query the device type device-type;

[0013] Step S800: Determine whether the device type is memory (device-type=memory);

[0014] Step S900: If the device type is identified as memory (device-type=memory), the attributes therein are retrieved, and the closure is called to pass the information to the caller.

[0015] Furthermore, step S200 includes:

[0016] S210, traverse token;

[0017] S220, query the legal tag from the token;

[0018] S230: If a legal tag is found, the current position skips the tag, node name, attributes, and attribute values, aligns to 8 bytes, obtains the next token offset value, and completes the traversal step.

[0019] Furthermore, after step S800, the following steps are included:

[0020] Step S810A: If it is determined that the device type is not memory (device-type=memory), the process returns to step S300.

[0021] Furthermore, step S900 includes:

[0022] Step S910: If the device type is identified as memory (device-type=memory), then obtain the reg attribute;

[0023] Step S920: Determine whether the reg attribute is Property=usable-memory;

[0024] Step S930: If the attribute of reg is identified as Property=usable-memory, multiple memory segments in reg are scanned;

[0025] Step S940: Get size;

[0026] Step S950: calling the closure;

[0027] Step S960: pass the closure information to the caller.

[0028] Furthermore, after step S930, the following steps are included:

[0029] If it is recognized that the reg attribute is not Property=usable-memory, the scanning is exited.

[0030] Another aspect of the present invention relates to a device for parsing key information of a device tree at an early stage of operating system startup, comprising:

[0031] The acquisition module is used to obtain the device tree DTB file. The starting position of the DTB file is the Header, which is used to describe the key information of the entire DTB. The node information is stored at the struct_offset of the Header. The struct consists of several consecutive tokens. The first u32 data is used to indicate the token type. The subsequent data is related to the token type. The tokentype structure contains the node start, node end and attribute content.

[0032] The first traversal module is used to traverse the token, find the struct_offset value from the header, and get the tokentype from the first u32 data;

[0033] The calculation module is used to calculate and offset the token length according to the tokentype;

[0034] The first query module is used to query BeginNode;

[0035] The second traversal module is used to traverse the attributes within the node after finding BeginNode;

[0036] The second query module is used to query the location of the attribute;

[0037] The third query module is used to query the device type device-type;

[0038] A judgment module is used to judge whether the device type is memory (device-type=memory);

[0039] The calling module is used to retrieve the attributes in the device if the device type is recognized as memory device-type=memory, and call the closure to pass the information to the caller.

[0040] Furthermore, the first traversal module includes:

[0041] Traversal unit, used to traverse token;

[0042] Query unit, used to query legal tags from tokens;

[0043] The first acquisition unit is used to skip the tag, node name, attributes and attribute values ​​at the current position if a legal tag is found, align to 8 bytes, obtain the next token offset value, and complete the traversal step.

[0044] Furthermore, the apparatus for parsing key information of the device tree at the initial stage of the operating system startup further includes a return module, which is configured to recalculate and offset the token length when recognizing that the device type is not memory device-type=memory.

[0045] Furthermore, the calling module includes:

[0046] The second acquiring unit is configured to acquire the reg attribute if the device type is identified as memory (device-type=memory);

[0047] A judging unit, used to judge whether the reg attribute is Property = usable-memory;

[0048] The scanning unit is used to scan multiple memory segments in reg if it is recognized that the attribute of reg is Property=usable-memory;

[0049] The third obtaining unit is used to obtain the size;

[0050] Calling unit, used to call closure;

[0051] The transfer unit is used to pass the closure information to the caller.

[0052] Furthermore, the calling module also includes:

[0053] The exit unit is used to exit the scan if it is recognized that the reg attribute is not Property=usable-memory.

[0054] The beneficial effects achieved by the present invention are as follows:

[0055] The present invention provides a method and apparatus for parsing key information of a device tree at the initial stage of an operating system startup, which comprises the following steps: obtaining a device tree DTB file; traversing a token, searching for a struct_offset value from a header, and obtaining a tokentype from the first u32 data; calculating and offsetting the token length according to the tokentype; querying a BeginNode; traversing the attributes within the node after finding the BeginNode; querying the location of the attributes; querying the device type device-type; determining whether the device type is memory device-type=memory; and if the device type is identified as memory device-type=memory, extracting the attributes therein and calling a closure to pass the information to the caller. The present invention provides a method and apparatus for parsing key information of a device tree at the initial stage of an operating system startup, which can parse out the available memory information in the DTB without relying on dynamic memory allocation. The operating system then initializes the memory manager with the parsed memory information, and can create a complete DTB description format in the memory, with a high degree of automation and high creation accuracy. BRIEF DESCRIPTION OF THE DRAWINGS

[0056] Figure 1 A logical diagram for parsing DTB memory node information in a method for parsing device tree key information in the initial stage of operating system startup according to the present invention;

[0057] Figure 2 Traversing the Token node logic diagram in the method for parsing key information of the device tree in the initial stage of the operating system startup of the present invention;

[0058] Figure 3 The invention provides a logic diagram for obtaining memory information in a method for parsing key information of a device tree during an initial startup of an operating system. DETAILED DESCRIPTION

[0059] In order to better understand the above technical solution, the above technical solution will be described in detail below with reference to the accompanying drawings and specific implementation methods.

[0060] like Figure 1 and Figure 2 As shown, the first embodiment of the present invention provides a method for parsing key information of a device tree during the initial startup of an operating system, comprising the following steps:

[0061] Step S100, obtain the device tree DTB file. The starting position of the DTB file is the Header, which is used to describe the key information of the entire DTB; the node information is saved at the struct_offset of the Header. The struct consists of several consecutively stored tokens. The first u32 data is used to represent the token type. The subsequent data is related to the token type. The tokentype structure contains the node start, node end and attribute content.

[0062] Get the device tree DTB file. The starting position of the DTB file is the Header. The Header is used to describe the key information of the entire DTB. The data structure of the Header is as follows:

[0063] #[repr(C)]

[0064] pub struct Header{

[0065] pub magic:u32, / / magic number

[0066] pub total_size:u32, / / DTB size

[0067] pub struct_offset:u32, / / struct offset

[0068] pub strings_offset:u32, / / string table offset

[0069] pub reserved_mem_offset:u32, / / Reserved memory offset

[0070] pub version:u32, / / format version

[0071] pub last_comp_version:u32, / / Last compatible version

[0072] pub boot_cpuid_phys:u32, / / CPU ID to start

[0073] pub strings_size:u32, / / string table length

[0074] pub struct_size:u32, / / struct length

[0075] }

[0076] The parameter struct_offset stores node information. These nodes are composed of several consecutively stored tokens. The first u32 data is used to indicate the token type, and subsequent data is related to the token type. The data structure of TokenType is as follows:

[0077] #[derive(Clone,Copy,Debug,PartialEq)]

[0078] #[repr(u32)]

[0079] pub enum TokenType{

[0080] BeginNode=0x1, / / node start

[0081] EndNode=0x2, / / End of node

[0082] Property=0x3, / / property

[0083] Nop=0x4, / / empty

[0084] End = 0x9, / / End, no more tokens

[0085] }

[0086] Step S200: traverse token, find the struct_offset value from the Header, and obtain tokentype from the first u32 data.

[0087] Step S300: Calculate and offset the token length according to tokentype.

[0088] According to the token type, the token length is calculated to obtain the starting position of the next token, thus realizing the function of traversing tokens.

[0089] Step S400: Query BeginNode.

[0090] If the token type found is BeginNode, the node location is returned.

[0091] Step S500: After finding BeginNode, traverse the attributes in the node.

[0092] The traversal method is to traverse the token. If the token type is Property, the location of the property is returned.

[0093] Step S600: Query the location of the attribute.

[0094] Step S700: Query the device type device-type.

[0095] Step S800: Determine whether the device type is memory (device-type=memory).

[0096] The memory node processing function determines whether the "device_type = memory" attribute exists.

[0097] Step S900: If the device type is identified as memory (device-type=memory), the attributes therein are retrieved, and the closure is called to pass the information to the caller.

[0098] If the attribute "device-type = memory" exists, it indicates that this is a node used to describe available memory. The attributes inside are retrieved, and the closure is called to pass the information to the caller. The caller can then obtain the memory information and initialize the memory.

[0099] Further, see Figures 1 to 3 The method for parsing key information of the device tree during the initial startup of the operating system proposed in this embodiment includes step S200:

[0100] S210. Traverse token.

[0101] S220: Query the legal tag from the token.

[0102] First, a valid tag is found. The logic then returns the token type at the start_offset and calculates the next token position, saving it in next_offset. If there is no valid tag at the start position, an error is returned, terminating the traversal.

[0103] S230: If a legal tag is found, the current position skips the tag, node name, attributes, and attribute values, aligns to 8 bytes, obtains the next token offset value, and completes the traversal step.

[0104] If the tag is valid, the current position skips the tag, node name, attributes, and attribute values, aligning to 8 bytes to complete the traversal. If the tokey type is BeginNode, the node position is returned.

[0105] Preferably, see Figures 1 to 3 The method for parsing key information of the device tree during the initial startup of the operating system proposed in this embodiment includes the following steps after step S800:

[0106] Step S810A: If it is determined that the device type is not memory (device-type=memory), the process returns to step S300.

[0107] The memory node processing function determines whether the "device_type=memory" attribute exists. If not, it returns to traverse the next node until the memory node is traversed.

[0108] Further, see Figures 1 to 3 The method for parsing key information of the device tree during the initial startup of the operating system proposed in this embodiment includes step S900:

[0109] Step S910: If the device type is identified as memory (device-type=memory), the reg attribute is obtained.

[0110] Step S920: Determine whether the reg attribute is Property=usable-memory.

[0111] Step S930: If it is identified that the attribute of reg is Property=usable-memory, multiple memory segments in reg are scanned.

[0112] Determine whether the reg attribute is memory. If it exists, it means that this is a node used to describe available memory. Take out the attributes inside and call the closure to pass the information to the caller.

[0113] Step S940: Get the size.

[0114] Step S950: call the closure.

[0115] Step S960: pass the closure information to the caller.

[0116] Preferably, see Figures 1 to 3 The method for parsing key device tree information at the initial stage of operating system startup proposed in this embodiment includes the following steps after step S930:

[0117] If it is recognized that the reg attribute is not Property=usable-memory, the scanning is exited.

[0118] In this embodiment, it is determined whether the attribute reg is memory, and if not, the scanning is exited.

[0119] The present invention relates to a device for parsing key information of a device tree in the early stage of an operating system startup, comprising an acquisition module, a first traversal module, a calculation module, a first query module, a second traversal module, a second query module, a third query module, a judgment module and a calling module, wherein the acquisition module is used to acquire a device tree DTB file, the starting position of the DTB file is a header, and the header is used to describe key information of the entire DTB; the node information is stored at the struct_offset of the header, the struct is composed of a number of continuously stored tokens, the first u32 data is used to represent the token type, and the subsequent data is related to the token type, and the tokentype structure contains the node start, the node end and the attribute content; the first traversal module is used to traverse the token n, find the struct_offset value from the Header, and get the tokentype from the first u32 data; the calculation module is used to calculate and offset the token length according to the tokentype; the first query module is used to query BeginNode; the second traversal module is used to traverse the attributes in the node after finding BeginNode; the second query module is used to query the location of the attribute; the third query module is used to query the device type device-type; the judgment module is used to judge whether the device type is memory device-type=memory; the calling module is used to take out the attributes inside if it is identified as memory device-type=memory, and call the closure to pass the information to the caller.

[0120] The acquisition module obtains the device tree DTB file. The starting position of the DTB file is the Header. The Header is used to describe the key information of the entire DTB. The data structure of the Header is as follows:

[0121] #[repr(C)]

[0122] pub struct Header{

[0123] pub magic:u32, / / magic number

[0124] pub total_size:u32, / / DTB size

[0125] pub struct_offset:u32, / / struct offset

[0126] pub strings_offset:u32, / / string table offset

[0127] pub reserved_mem_offset:u32, / / Reserved memory offset

[0128] pub version:u32, / / format version

[0129] pub last_comp_version:u32, / / Last compatible version

[0130] pub boot_cpuid_phys:u32, / / CPU ID to start

[0131] pub strings_size:u32, / / string table length

[0132] pub struct_size:u32, / / struct length

[0133] }

[0134] The parameter struct_offset stores node information. These nodes are composed of several consecutively stored tokens. The first u32 data is used to indicate the token type, and subsequent data is related to the token type. The data structure of TokenType is as follows:

[0135] #[derive(Clone,Copy,Debug,PartialEq)]

[0136] #[repr(u32)]

[0137] pub enum TokenType{

[0138] BeginNode=0x1, / / node start

[0139] EndNode=0x2, / / End of node

[0140] Property=0x3, / / property

[0141] Nop=0x4, / / empty

[0142] End = 0x9, / / End, no more tokens

[0143] }

[0144] The calculation module calculates the token length according to the token type, thereby obtaining the starting position of the next token and realizing the function of traversing tokens.

[0145] If the first query module finds that the token type is BeginNode, it returns the location of the node.

[0146] The calling module is used to, if it recognizes that the attribute has memory device-type = memory, it means that this is a node used to describe available memory, extract the attributes inside, and call the closure to pass the information to the caller. The caller can then obtain the memory information to initialize the memory.

[0147] Furthermore, the present embodiment provides an apparatus for parsing key information of a device tree in the initial stage of operating system startup, wherein the first traversal module includes a traversal unit, a query unit, and a first acquisition unit, wherein the traversal unit is used to traverse the token; the query unit is used to query a legal tag from the token; the first acquisition unit is used to skip the tag, the node name, the attributes, and the attribute value at the current position if a legal tag is queried, align to 8 bytes, obtain the next token offset value, and complete the traversal step.

[0148] The query unit first searches for a valid tag. The judgment logic needs to return the token type at the start_offset and calculate the position of the next token, saving it in next_offset. If there is no valid tag at the starting position, the traversal is terminated by returning Err.

[0149] If the first acquisition unit recognizes that the tag is valid, it skips the tag, node name, attributes, and attribute values ​​at the current position, aligning them to 8 bytes to complete the traversal step. If the tokey type is BeginNode, it returns the node location.

[0150] Preferably, the device for parsing key information of the device tree in the early stage of operating system startup provided in this embodiment also includes a return module, which is used to recalculate and offset the token length when it recognizes that the device type is not memory device-type=memory.

[0151] The return module determines whether the "device_type=memory" attribute exists. If not, it returns to traverse the next node until the memory node is traversed.

[0152] Furthermore, the present embodiment provides an apparatus for parsing key device tree information during the initial startup of an operating system. The calling module includes a second acquisition unit, a judgment unit, a scanning unit, a third acquisition unit, a calling unit, and a transmission unit. The second acquisition unit is configured to acquire the reg attribute if the device type is identified as memory (device-type=memory); the judgment unit is configured to determine whether the reg attribute is Property=usable-memory; the scanning unit is configured to scan multiple memory segments in reg if the reg attribute is identified as Property=usable-memory; the third acquisition unit is configured to acquire the size; the calling unit is configured to call a closure; and the transmission unit is configured to pass the closure information to the caller. The scanning unit determines whether the reg attribute is memory. If so, it indicates that this is a node describing available memory, extracts the attributes within it, and calls the closure to pass the information to the caller.

[0153] Preferably, the apparatus for parsing key information of a device tree at the initial stage of operating system startup provided by this embodiment, the calling module further includes an exit unit, the exit unit being configured to exit scanning if it is recognized that the reg attribute is not Property=usable-memory.

[0154] The exit unit determines whether the reg attribute is memory. If not, the scan is exited.

[0155] The method and apparatus for parsing key information of the device tree at the initial startup of the operating system provided in this embodiment, compared with the existing technology, obtains the device tree DTB file; traverses the token, searches for the struct_offset value from the Header, and obtains the tokentype from the first u32 data; calculates and offsets the token length according to the tokentype; queries BeginNode; traverses the attributes within the node after finding BeginNode; queries the location of the attributes; queries the device type device-type; determines whether the device type is memory device-type=memory; if the device type is identified as memory device-type=memory, the attributes inside are taken out, and the closure is called to pass the information to the caller. The method and apparatus for parsing key information of the device tree at the initial startup of the operating system provided in this embodiment can parse the available memory information in the DTB without relying on dynamic memory allocation. The operating system then initializes the memory manager with the parsed memory information, and can create a complete DTB description format in the memory, with a high degree of automation and high creation accuracy.

[0156] Although preferred embodiments of the present invention have been described, those skilled in the art may make additional changes and modifications to these embodiments once they are aware of the basic inventive concepts. Therefore, the appended claims are intended to be interpreted as including the preferred embodiments and all changes and modifications that fall within the scope of the invention. Obviously, those skilled in the art may make various changes and modifications to the present invention without departing from the spirit and scope of the invention. Thus, the present invention is intended to include such changes and modifications as fall within the scope of the claims and their equivalents.

Claims

1. A method for parsing key information of a device tree during the initial startup of an operating system, characterized in that: The following steps are involved: Step S100: Obtain the device tree DTB file. The starting position of the DTB file is the Header, which is used to describe the key information of the entire DTB. The node information is stored at the struct_offset of the Header. The struct consists of several consecutive tokens. The first u32 data is used to represent the tokentype. The subsequent data is related to the tokentype. The tokentype structure contains the node start, node end and attribute content. Step S200, traverse token, find the struct_offset value from the header, and obtain tokentype from the first u32 data; the specific traversal process is as follows: Step S300-Step S900: Step S300: Calculate and offset the token length according to the tokentype; Step S400, query BeginNode; Step S500: After finding the BeginNode, traverse the properties in the node; Step S600: query the location of the attribute Property; Step S700: query the device type device-type; Step S800: Determine whether the device type is memory (device-type=memory); Step S900: If the device type is identified as memory (device-type=memory), then the attributes are retrieved and the closure is called to pass the information to the caller. Step S900 includes: Step S910: If the device type is identified as memory (device-type=memory), then obtain the reg attribute; Step S920: Determine whether the reg attribute is Property=usable-memory; Step S930: If it is identified that the attribute of reg is Property=usable-memory, multiple memory segments in the reg are scanned; Step S940: Get size; Step S950: calling the closure; Step S960: pass the closure information to the caller.

2. The method for parsing key information of the device tree during the initial startup of an operating system according to claim 1, wherein: The step S200 includes: S210, traverse token; S220, querying a legal tag from the token; S230: If a legal tag is found, the current position skips the tag, node name, attributes, and attribute values, aligns to 8 bytes, obtains the next token offset value, and completes the traversal step.

3. The method for parsing key information of the device tree during the initial startup of an operating system according to claim 1, wherein: The step S800 includes: Step S810A: If it is determined that the device type is not memory (device-type=memory), the process returns to step S300.

4. The method for parsing key device tree information during an initial startup of an operating system according to claim 1, wherein after step S930, the method further comprises: If it is recognized that the reg attribute is not Property=usable-memory, the scanning is exited.

5. A device for parsing key information of a device tree during the initial startup of an operating system, comprising: The acquisition module is used to obtain the device tree DTB file. The starting position of the DTB file is the Header, which is used to describe the key information of the entire DTB. The node information is stored at the struct_offset of the Header. The struct consists of several consecutive tokens. The first u32 data is used to represent the tokentype. The subsequent data is related to the tokentype. The tokentype structure contains the node start, node end and attribute content. The first traversal module is used to traverse the token, find the struct_offset value from the header, and obtain the tokentype from the first u32 data. The first traversal module includes: A calculation module, configured to calculate and offset the token length according to the tokentype; The first query module is used to query BeginNode; The second traversal module is used to find the BeginNode and then traverse the properties in the node; The second query module is used to query the location of the attribute Property; The third query module is used to query the device type device-type; A judgment module is used to judge whether the device type is memory device-type = memory; The calling module is used to retrieve the attributes in the device if the device type is identified as memory (device-type=memory), and call the closure to pass the information to the caller, wherein the calling module includes: The second acquiring unit is configured to acquire the reg attribute if the device type is identified as memory (device-type=memory); A judging unit, used to judge whether the reg attribute is Property = usable-memory; A scanning unit, configured to scan multiple memory segments in the reg if it is recognized that the reg attribute is Property=usable-memory; The third obtaining unit is used to obtain the size; Calling unit, used to call closure; The transfer unit is used to pass the closure information to the caller.

6. The device for parsing key information of a device tree at an early stage of operating system startup according to claim 5, characterized in that: The first traversal module includes: Traversal unit, used to traverse token; A query unit, configured to query a legal tag from the token; The first acquisition unit is used to skip the tag, node name, attributes and attribute values ​​at the current position if a legal tag is found, align to 8 bytes, obtain the next token offset value, and complete the traversal step.

7. The device for parsing key information of a device tree at an early stage of operating system startup according to claim 5, characterized in that: The apparatus for parsing key information of the device tree at the initial stage of operating system startup further comprises a return module, wherein the return module is configured to recalculate and offset the token length when recognizing that the device type is not memory device-type=memory.

8. The device for parsing key information of a device tree at an early stage of operating system startup according to claim 5, characterized in that: The calling module also includes: The exit unit is used to exit the scan if it is recognized that the reg attribute is not Property=usable-memory.

Images