ARM-based server crash event handling methods and related equipment
By using in-band interrupt requests from the MCP and I3C buses in ARM servers, combined with asynchronous communication between kernel and user modes and a hierarchical acquisition strategy, the compatibility and reliability issues of the crash dump mechanism in ARM servers are resolved, achieving efficient crash event handling and complete capture of critical data.
Patent Information
- Application Number
- CN202611220799.4
- Authority / Receiving Office
- CN · China
- Patent Type
- Patents(China)
- Current Assignee / Owner
- Filing Date
- 2026-08-12
- Publication Date
- 2026-11-17
- Estimated Expiration
- 2046-08-12
AI Technical Summary
Existing server crash dumping mechanisms based on x86 architecture have compatibility barriers and insufficient reliability in fault capture on ARM servers, and cannot be applied to the exception handling model and communication protocol of ARM architecture.
The MCP sends in-band interrupt requests to the BMC via the I3C bus. The asynchronous communication mechanism between kernel mode and user mode is used to push crash-related information to the D-Bus bus. The user-mode handler subscribes to and executes the crash dump operation. A hierarchical acquisition strategy is used to read the crash dump data and persist it.
It achieves efficient and reliable crash event capture in ARM servers, overcomes compatibility barriers, improves the success rate of fault capture and data integrity, and ensures that critical data is not lost after system crash.
Smart Images

Figure CN122733593B_ABST
Abstract
Description
Technical Field
[0001] This application relates to the field of processor technology, and in particular to a server crash event handling method and related equipment based on ARM (Advanced RISC Machine) architecture. Background Technology
[0002] When a server operating system or hardware encounters a fatal error, the critical operational data that caused the failure is automatically saved—this is known as a crash dump. Current crash dump solutions are typically deeply tied to the Intel x86 architecture and its dedicated BMC (Baseboard Management Controller) firmware ecosystem; they rely on physical triggering of hardware signals and out-of-band data acquisition. Specifically: When a serious CPU failure occurs, the cat_err_n pin level is pulled low. After the onboard Complex Programmable Logic Device (CPLD) detects this pin signal, it directly sets the relevant status registers inside the CPU. The BMC detects the register status change by periodically polling, establishes communication using the Platform Environment Control Interface (PECI), reads and persistently stores the critical register information at the time of the failure, thereby completing the memory dump.
[0003] However, the ARM architecture uses an exception and interrupt handling model based on the GIC (Generic Interrupt Controller), and there is no physical signal mechanism in the ARM architecture that corresponds to the function of the CATERR# pin. This low-level hardware triggering method cannot be applied to ARM servers (servers based on the ARM architecture).
[0004] Furthermore, the PECI that the BMC relies on to complete out-of-band memory dumps is a dedicated communication path specifically designed for the bus topology of x86 chipsets (such as Intel PCH (Platform Controller Hub)). In contrast, ARM servers generally use high-speed interconnect protocols such as CCIX (Cache Coherent Interconnect for Accelerators) and CXL (Compute Express Link), or memory-mapped I / O based on ARMSoC (ARM-based System on Chip) for peripheral access. These fundamental differences in underlying communication protocols and system topology mean that data acquisition paths based on platform environment control interfaces cannot be reused on the ARM platform.
[0005] Furthermore, crash signals often exhibit strong transient characteristics. If the signal duration is shorter than the BMC's polling cycle, or if it occurs and disappears within the interval window between two polls, the BMC will be unable to capture the crash event. This passive waiting and periodic sampling mechanism inherently carries the risk of signal loss, directly impacting the success rate of crash dump triggering.
[0006] Therefore, the aforementioned server crash dumping mechanism based on the x86 architecture suffers from serious compatibility barriers and insufficient reliability in fault capture in heterogeneous ARM servers due to its deep coupling with the x86 platform in terms of underlying hardware triggering, data communication, and signal monitoring methods. Summary of the Invention
[0007] The main purpose of this application is to provide a server crash event handling method and related equipment based on ARM architecture, aiming to solve the technical problems of serious compatibility barriers and insufficient reliability of fault capture in the current server crash dump mechanism based on x86 architecture in heterogeneous ARM servers.
[0008] To achieve the above objectives, this application proposes a server crash event handling method based on ARM architecture, the server crash event handling method based on ARM architecture comprising: After the MCP detects a system crash event of the ARM server, it sends an in-band interrupt request to the BMC via the I3C bus. The payload of the in-band interrupt request carries crash-related information. The BMC responds to the in-band interrupt request and pushes the crash-related information to the D-Bus bus through an asynchronous communication mechanism between kernel mode and user mode. The user-mode handler subscribes to and receives crash-related information on the D-Bus bus, and performs a crash dump operation based on the crash-related information.
[0009] In one embodiment, the crash-related information includes error level and error identification information; The steps of the BMC responding to the in-band interrupt request and pushing the crash-related information to the D-Bus bus through an asynchronous communication mechanism between kernel mode and user mode include: In response to the in-band interrupt request, the BMC's I3C driver parses the payload and obtains the error level and the error identification information. Set the file descriptor associated with the in-band interrupt request to a readable state; After the event loop registered in the user-space handler based on the Boost.Asio asynchronous I / O framework detects that the file descriptor is readable, it calls the pre-registered callback function to push the error level and the error identification information to the D-Bus bus.
[0010] In one embodiment, the crash-related information includes error level and error identification information; The step of performing a crash dump operation based on the crash-related information includes: Based on the error level, a hierarchical acquisition strategy corresponding to the error level is selected from a variety of preset acquisition strategies; Crash dump data is read from the hardware module of the ARM server according to the priority order defined in the hierarchical acquisition strategy. After the crash dump data is persistently stored to the persistent medium, a reset trigger command is sent to the CPLD so that the CPLD sends a reset signal to the CPU.
[0011] In one embodiment, the hierarchical acquisition strategy includes a first priority acquisition task, a second priority acquisition task, and a third priority acquisition task, which are executed sequentially from high to low priority. The first priority acquisition task is to read data from the application processor core register, the application processor random access memory, the consistency grid network status register, and the manageability control processor status register. The second priority acquisition task is to read data from the main memory controller register, the double data rate memory extension register, and the general interrupt controller status register. The third priority acquisition task is to read data from the peripheral component interconnection fast link configuration space and its extended registers, as well as the security controller status register.
[0012] In one embodiment, the step of reading crash dump data from the hardware module of the ARM server according to the priority order defined in the hierarchical acquisition strategy includes: Based on the available time window after the system crash, the first priority acquisition task will be executed first. After the first priority data collection task is completed, if there is remaining time within the available time window, the second priority data collection task will continue to be executed. After the second priority acquisition task is completed, if there is remaining time within the available time window, the third priority acquisition task will continue to be executed.
[0013] In one embodiment, the persistent medium includes an embedded multimedia storage card, and the step of sending a reset trigger command to the CPLD after persistently storing the crash dump data to the persistent medium includes: Write the crash dump data into the embedded multimedia storage card and perform a file synchronization operation to confirm that the data has been physically written into the embedded multimedia storage card. After confirming that the data has been physically written, a write completion confirmation message is generated to trigger a reset trigger command to be sent to the CPLD.
[0014] In addition, to achieve the above objectives, this application also proposes a server crash event handling system based on ARM architecture. The server crash event handling system based on ARM architecture includes MCP, BMC and I3C bus. The BMC and the MCP are connected through the I3C bus. The BMC is the I3C master device and the MCP is the I3C slave device. MCP is used to send an in-band interrupt request to BMC via the I3C bus after detecting a system crash event of the ARM server. The payload of the in-band interrupt request carries crash-related information. The BMC is used to respond to the in-band interrupt request and push the crash-related information to the D-Bus bus through an asynchronous communication mechanism between kernel mode and user mode; A user-mode processing program running in the user-mode space of the BMC is used to subscribe to and receive crash-related information on the D-Bus bus, and to perform a crash dump operation based on the crash-related information.
[0015] Furthermore, to achieve the above objectives, this application also proposes a server crash event handling device based on ARM architecture. The server crash event handling device based on ARM architecture includes: a memory, a processor, and a computer program stored in the memory and executable on the processor. The computer program is configured to implement the steps of the server crash event handling method based on ARM architecture as described above.
[0016] In addition, to achieve the above objectives, this application also proposes a storage medium, which is a computer-readable storage medium, on which a computer program is stored, and when the computer program is executed by a processor, it implements the steps of the server crash event handling method based on the ARM architecture described above.
[0017] In addition, to achieve the above objectives, this application also provides a computer program product, which includes a computer program that, when executed by a processor, implements the steps of the server crash event handling method based on the ARM architecture described above.
[0018] One or more technical solutions proposed in this application have at least the following technical effects: After the Monitoring Crash Processor (MCP) detects a system crash event on the ARM server, this application sends an in-band interrupt request to the BMC via the I3C (Improved Inter-Integrated Circuit) bus. The payload of the in-band interrupt request carries crash-related information. In response to the in-band interrupt request, the BMC pushes the crash-related information to the D-Bus (Desktop Bus) through an asynchronous communication mechanism between kernel mode and user mode. The user-mode handler subscribes to and receives the crash-related information on the D-Bus and performs a crash dump operation based on the crash-related information.
[0019] As is understood, this application uses the MCP (Manageability Control Processor) inherent in the ARM server as the main body for crash monitoring, and utilizes the in-band interrupt mechanism of the I3C bus to replace physical pins: when the MCP detects a system crash event, it immediately sends an interrupt request to the BMC via the I3C data bus, carrying crash-related information in the payload. This method does not require dedicated signal lines, is naturally compatible with the exception handling model of the ARM architecture, and because the interrupt request is issued asynchronously and proactively, the BMC can capture the event without polling, completely eliminating the risk of data loss caused by polling.
[0020] Furthermore, this application uses the universal I3C bus instead of the x86 architecture-specific PECI interface, resolving the communication path incompatibility issue. I3C is an open standard, backward compatible with I2C, and does not conflict with commonly used ARM server protocols such as memory-mapped I / O and CCIX / CXL. After responding to the interrupt request, the BMC pushes the crash information to the D-Bus bus through an asynchronous communication mechanism between kernel and user modes. This asynchronous mechanism is non-blocking and has low latency, improving response efficiency compared to polling.
[0021] In addition, the user-space handler obtains crash-related information by subscribing to the D-Bus bus and performs crash dump operations, decoupling the crash notification path from the specific dump operation. This allows the notification mechanism to be reused across different ARM platforms, thereby solving the compatibility barriers and insufficient reliability of fault capture in heterogeneous ARM servers. Attached Figure Description
[0022] The accompanying drawings, which are incorporated in and form part of this specification, illustrate embodiments consistent with this application and, together with the description, serve to explain the principles of this application.
[0023] To more clearly illustrate the technical solutions in the embodiments of this application or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, for those skilled in the art, other drawings can be obtained based on these drawings without creative effort.
[0024] Figure 1 This is a flowchart illustrating an embodiment of the server crash event handling method based on the ARM architecture of this application. Figure 2 This is a flowchart illustrating Embodiment 2 of the server crash event handling method based on ARM architecture provided in this application; Figure 3 This is a logical architecture diagram of the server crash event handling method based on ARM architecture provided in Embodiment 2 of this application; Figure 4 This is a schematic diagram of the device structure of the hardware operating environment involved in the server crash event handling method based on ARM architecture in the embodiments of this application.
[0025] The purpose, features, and advantages of this application will be further explained in conjunction with the embodiments and with reference to the accompanying drawings. Detailed Implementation
[0026] It should be understood that the specific embodiments described herein are merely illustrative of the technical solutions of this application and are not intended to limit this application.
[0027] To better understand the technical solution of this application, a detailed description will be provided below in conjunction with the accompanying drawings and specific implementation methods.
[0028] Based on this, embodiments of this application provide a server crash event handling method based on ARM architecture, referring to... Figure 1 , Figure 1 This is a flowchart illustrating the first embodiment of the server crash event handling method based on the ARM architecture of this application.
[0029] In this embodiment, the server crash event handling method based on ARM architecture includes steps S10~S30: Step S10: After the MCP detects a system crash event of the ARM server, it sends an in-band interrupt request to the BMC via the I3C bus. The payload of the in-band interrupt request carries crash-related information. In step S20, the BMC responds to the in-band interrupt request and pushes the crash-related information to the D-Bus bus through an asynchronous communication mechanism between kernel mode and user mode; Step S30: The user-mode processor subscribes to and receives crash-related information on the D-Bus bus, and performs a crash dump operation based on the crash-related information.
[0030] It should be noted that the ARM-based server crash event handling method can be applied to an ARM-based server crash event handling system. This system includes an MCP, a BMC, and an I3C bus. The BMC and MCP are connected via the I3C bus, with the BMC acting as the I3C master and the MCP as the I3C slave. The I3C bus is an improved internal integrated circuit bus, a high-speed, low-power, backward-compatible I2C serial communication bus standard that supports multi-master / multi-slave topologies and in-band interrupt functionality.
[0031] The MCP can continuously monitor the operating status of the ARM server. Specifically, it can monitor the processor core's error output signals, the correctable / uncorrectable error reporting lines of the memory controller, the timeout status of the cache coherency bus, and the overflow flag of the critical watchdog timer within the system-on-a-chip (SoC). When the MCP detects a system crash event through any of these monitoring channels, it can construct an in-band interrupt request frame conforming to the I3C protocol specification and fill the crash-related information of the system crash event into the payload field of the in-band interrupt request. As an I3C slave device, the MCP actively sends this in-band interrupt request to the BMC, which acts as the I3C master device, via the I3C bus.
[0032] Among them, system crash events are fatal exceptions that occur during the operation of ARM servers, causing the system to be unable to continue to work normally. System crash events can be unrecoverable machine check exceptions, uncorrectable memory errors, cache consistency timeouts, critical bus suspensions, etc.
[0033] By utilizing the in-band interrupt mechanism of the I3C bus instead of traditional dedicated physical interrupt pins, crash notification is completed entirely through the data bus, eliminating the need for additional signal lines on the ARM server motherboard and ensuring compatibility with the natural hardware design of the ARM architecture. The MCP actively sends the in-band interrupt request, eliminating the need for the BMC to periodically poll the register status, thus completely eliminating the risk of signal loss due to polling intervals exceeding the crash signal duration and ensuring a high success rate in crash event capture. Since the I3C bus supports transmission rates of up to tens of megabits per second and the payload can carry multiple bytes of custom data, rich crash attribute information can be transmitted to the BMC simultaneously with the interrupt, avoiding the secondary delay caused by the BMC needing to read back multiple registers after receiving the interrupt, as is common in traditional solutions.
[0034] Furthermore, upon receiving an in-band interrupt request from the MCP, the BMC's I3C controller hardware can generate a hardware interrupt signal to the BMC's processor core. The interrupt service routine of the I3C driver in the BMC operating system kernel is then triggered. This interrupt service routine reads the payload sent by the MCP from the I3C controller's data buffer and parses the crash-related information from the payload.
[0035] The I3C driver temporarily stores crash-related information in a dedicated buffer in kernel memory and notifies user space through the operating system's asynchronous notification interface. A daemon running in the BMC user space listens for this asynchronous notification via an asynchronous I / O event loop (such as epoll or Boost.Asio). When data readiness is detected, it reads the crash-related information from the dedicated buffer in kernel memory, constructs the crash-related information into a D-Bus signal message, and calls the D-Bus library's send interface to publish the message to the system's D-Bus bus.
[0036] The asynchronous communication mechanism between kernel space and user space is an operating system-level data transfer method. In this mechanism, after a driver in kernel space writes data to the kernel buffer, it notifies the user space process that the data is ready via an event notification. The user space process can read the data non-blockingly during its own scheduling, and no mutual locks are generated between the two. The D-Bus bus is a commonly used inter-process communication (IPC) mechanism in Linux systems, supporting message broadcasting, signal publishing / subscription, and remote method calls. In management firmware such as OpenBMC (Open Baseboard Management Controller Firmware), it is used as the communication hub for system services.
[0037] Through an asynchronous communication mechanism between kernel mode and user mode, the BMC's I3C driver only needs to complete the minimum necessary operations (data copying and status marking) in the interrupt context, avoiding time-consuming operations (such as complex parsing or D-Bus calls) in the interrupt handler function, thereby ensuring the real-time responsiveness and predictability of interrupt latency of the BMC system. Using asynchronous notifications instead of polling, user-mode processes do not need to periodically and actively read device files, significantly reducing CPU utilization and enabling the BMC to handle other management tasks simultaneously (such as sensor data acquisition and remote control commands). Pushing crash-related information to the D-Bus bus achieves "publish-subscribe" decoupling of crash events: any application module that needs to respond to crash events (such as the dump acquisition module, alarm module, and log recording module) can independently subscribe to the D-Bus signal without modifying the interrupt handling path, enhancing the scalability and maintainability of the software architecture.
[0038] Furthermore, during BMC startup or when the crash handling service starts, the user-mode handler initiates a subscription request to the system bus through the D-Bus client library, specifying the signal names, interfaces, and object paths of interest to the user-mode handler. The user-mode handler is an application process running in the BMC operating system's user space, distinct from kernel-mode drivers; this user-mode handler can be independently compiled, updated, and debugged, and is responsible for executing crash dump-related business logic.
[0039] When the BMC pushes crash-related information to the D-Bus bus as a signal, the D-Bus bus sends a copy of the signal to the user-mode handler based on its subscription records. Upon receiving the message copy, the user-mode handler's event loop wakes up a pre-registered callback function to extract the crash-related information from the message copy. The user-mode handler then initiates a crash dump operation based on this information.
[0040] Crash dumping can be a series of data collection and saving actions performed after a system crash in order to locate the root cause of the failure. This includes, but is not limited to, reading processor core register values, cache data, memory controller status, peripheral device configuration space, and other information, and persistently storing this information in non-volatile media.
[0041] Through a subscription / receive model, the user-mode handler is completely decoupled from the crash-related information pusher. They interact only through the interface defined by the D-Bus bus, without compile-time dependencies or direct function calls. This allows the dump logic to be independently iterated and upgraded without affecting the stability of the crash notification chain. The user-mode handler runs in non-privileged mode, so even if the dump logic itself has defects, it will not cause the BMC kernel to crash or affect the operation of other kernel drivers. Because the D-Bus bus supports multiple programs subscribing to the same signal simultaneously, it allows the system to deploy multiple different user-mode handlers in parallel (e.g., one program performs fast critical register acquisition, while another program is responsible for uploading the dump file to a remote server). This enables flexible splitting and parallel execution of crash handling tasks, maximizing the capture of valuable data within the limited time window after a system crash.
[0042] It should be noted that the crash-related information includes error level and error identification information.
[0043] In one feasible implementation, the BMC responds to the in-band interrupt request and pushes the crash-related information to the D-Bus bus via an asynchronous communication mechanism between kernel mode and user mode in the following way: In response to the in-band interrupt request, the BMC's I3C driver parses the payload to obtain the error level and the error identification information; it sets the file descriptor associated with the in-band interrupt request to a readable state; after the event loop registered in the user-mode handler based on the Boost.Asio (a C++ asynchronous input / output network programming library based on the Boost library) asynchronous I / O framework detects that the file descriptor is readable, it calls the pre-registered callback function to push the error level and the error identification information to the D-Bus bus.
[0044] Specifically, when the BMC's I3C controller hardware receives an in-band interrupt request, it triggers a CPU interrupt, and the interrupt handler function of the I3C driver in the BMC operating system kernel is called. The I3C driver first reads the I3C controller's status register to confirm that the interrupt type is an in-band interrupt request. The driver then reads the sequence of payload bytes sent by the MCP from the I3C controller's receive FIFO (First-In-First-Out) data buffer.
[0045] Furthermore, the I3C driver parses the byte sequence according to the protocol format (e.g., fixed header plus variable length field) pre-negotiated between the BMC and MCP: extracting the values of the error level field and the error identification information field, and storing the values of these two fields into kernel temporary variables respectively.
[0046] The error level represents a quantified value indicating the severity of the crash event, such as distinguishing between critical core errors, memory interruption errors, or full-source errors. Error identification information is coded information used to uniquely identify a specific error type or source of failure; it can be an error code, a register bit offset value, a fault source identifier, or a combination of these.
[0047] After the I3C driver completes the parsing of the payload and successfully obtains the error level and error identification information, it can temporarily store these information in a kernel buffer associated with a specific file descriptor. The I3C driver then calls the operating system's I / O event notification interface (such as `wake_up_interruptible`, `kill_fasync`, or directly modifies the file descriptor's status flags) to mark the file descriptor as readable. The operating system kernel's event notification subsystem can then assume that new data has arrived on the file descriptor, and any process waiting for that descriptor can be awakened.
[0048] During the initialization phase of the user-space handler (a C++ daemon written based on Boost.Asio), the user-space handler opens the device file corresponding to the I3C driver (e.g., / dev / i3c-ibi) and obtains a file descriptor. Then, the user-space handler encapsulates this file descriptor using the Boost.Asio posix::stream_descriptor class and calls the async_read_some method to register an asynchronous read operation, while providing a callback function.
[0049] When the I3C driver sets a file descriptor to readable, the io_context event loop detects that the file descriptor is ready and automatically calls the pre-registered callback function. Inside this callback function, the user-mode handler reads the error level and error flag information from the kernel buffer in the file descriptor using the read system call. Then, it uses the error level and error flag information as parameters to construct and send a signal to the D-Bus bus using the sd_bus_emit_signal or dbus_connection_send function of the D-Bus library.
[0050] In this embodiment, by utilizing MCP active monitoring and I3C in-band interrupts to replace x86 dedicated physical pins and polling mechanisms, the compatibility defects and crash signal loss risks of the ARM architecture are completely resolved. The I3C bus bandwidth is several times higher than the traditional PECI interface, allowing the MCP to carry richer crash context information in its interrupt payload. Simultaneously, during subsequent data acquisition, the BMC can obtain more critical data from the MCP via the same high-speed bus, significantly increasing the amount of effective data that can be captured before the system crash, providing a more complete chain of evidence for root cause analysis. Low latency is achieved through asynchronous communication between kernel and user modes and the D-Bus publish / subscribe model. Delayed, non-blocking crash message delivery ensures the real-time performance of BMC's own management tasks while decoupling notification and processing logic. Error level and error identification information are obtained through driver layer parsing, providing a quantitative basis for differentiated graded data collection and avoiding time window exhaustion or secondary crashes caused by blind full data collection. By using the readable state of file descriptors as a standard notification primitive and leveraging the single-threaded event loop of the Boost.Asio asynchronous I / O framework, BMC can efficiently and concurrently handle crash events and other management tasks in resource-constrained embedded environments, thereby achieving significant improvements in compatibility, reliability, real-time performance, data integrity, and system scalability.
[0051] Based on the first embodiment of this application, in the second embodiment of this application, the same or similar content as the above embodiment can be referred to the above description, and will not be repeated hereafter. Based on this, please refer to... Figure 2 Step S30 includes steps S01 to S02: Step S01: Based on the error level, select a graded acquisition strategy corresponding to the error level from a variety of preset acquisition strategies; Step S02: Read crash dump data from the hardware module of the ARM server according to the priority order defined in the hierarchical acquisition strategy; Step S03: After persistently storing the crash dump data to the persistent medium, a reset trigger command is sent to the CPLD so that the CPLD sends a reset signal to the CPU.
[0052] The preset multiple acquisition strategies are a set of different acquisition schemes pre-configured in the BMC firmware or file system. Each acquisition scheme defines which hardware modules need to be read, the reading order, and the amount of data to be read. The hierarchical acquisition strategy is a type of strategy that divides acquisition tasks according to priority. High-priority tasks collect the most critical fault location data, while low-priority tasks collect auxiliary analysis data. Different error levels correspond to different priority acquisition strategies.
[0053] The BMC's user-space handlers (such as the crash dump daemon) extract the error level field from crash-related information received from the D-Bus bus. Subsequently, these user-space handlers access locally stored configuration data (such as JSON configuration files or database tables), which maintains a mapping table from error levels to collection strategies. The user-space handlers query this mapping table based on the error level value to find the collection strategy that matches the error level, thus obtaining a tiered collection strategy.
[0054] The data collection scope is dynamically adjusted based on the severity of the crash: for the most severe crashes (such as processor core hangs), only the minimum set of critical registers is collected to complete the process before the system completely locks up; for relatively minor crashes, data from more modules can be collected. This differentiated selection avoids the drawback of traditional solutions that collect all data regardless of the crash type, effectively improving the success rate of capturing valid evidence within a limited time window.
[0055] The user-space handler executes acquisition tasks sequentially according to the selected hierarchical acquisition strategy and the priority order explicitly defined in the strategy. For each acquisition task, the user-space handler calls the corresponding hardware access interface (e.g., accessing the physical address via / dev / mem, or reading the slave device register via the I2C / SMBus driver) to send a read command to the specified ARM server hardware module, and temporarily stores the returned data in the BMC's memory buffer. The user-space handler strictly executes tasks in descending order of priority, and only starts the next level of task after all high-priority tasks have been completed.
[0056] Among them, the hardware modules of the ARM server are the physical or logical units in the ARM server that may contain fault scene information, such as application processor core registers, cache, memory controller, coherent mesh network, general interrupt controller, PCIe (Peripheral Component Interconnect Express) controller, etc.
[0057] After completing all hierarchical data acquisition tasks, the user-mode handler writes the crash dump data temporarily stored in the BMC memory to the persistent medium. Once the write is complete, the user-mode handler can output a compliant low-level reset pulse to the CPU's reset pin, and the CPU will then perform a hardware reset.
[0058] Persistent storage refers to writing crash dump data temporarily stored in BMC memory to non-volatile storage media, ensuring that the data is not lost even after a power outage. The persistent storage media is a non-volatile storage device that is locally accessible to the BMC.
[0059] Specifically, the persistent storage medium includes an embedded multimedia memory card (eMMC), NAND flash memory, SPI memory (SPI memory), or remote storage connected via a network; the method for sending a reset trigger command to the CPLD after persistently storing the crash dump data to the persistent storage medium can be as follows: The crash dump data is written to the embedded multimedia storage card, and a file synchronization operation is performed to confirm that the data has been physically written to the embedded multimedia storage card. After confirming that the data has been physically written, a write completion confirmation message is generated to trigger a reset trigger command to be sent to the CPLD.
[0060] After the BMC's user-mode handler finishes reading the crash dump data from the ARM server hardware module and temporarily storing it in a memory buffer, the user-mode handler can create a crash dump file (e.g., a .dump file named with a timestamp) in the target path of the embedded multimedia memory card. The user-mode handler then writes the data in the memory buffer into this file in chunks using the write system call.
[0061] After all data has been written, the user-mode handler calls a file synchronization operation (such as fsync) and checks its return value. If it returns successfully, it means that the operating system has forcibly flushed the file data and metadata (such as file size and modification time) from the page cache to the physical storage medium of the embedded multimedia memory card. At this time, the user-mode handler internally generates a write completion confirmation message, for example, by setting a flag dump_persisted = true. When the user-mode handler detects that this flag is true, it immediately sends a reset trigger command to the CPLD.
[0062] This avoids file loss or incompleteness caused by crash dump data remaining in the page cache during a reset operation. Because embedded multimedia storage cards are non-volatile, once the data has been physically written, the dump file can still be retained even if the system is subsequently reset or powered off, allowing maintenance personnel to analyze it later.
[0063] In one feasible implementation, refer to Figure 3 The hierarchical acquisition strategy includes a first priority acquisition task, a second priority acquisition task, and a third priority acquisition task, which are executed in descending order of priority. The first priority acquisition task is to read data from the application processor core register, application processor random access memory, coherent mesh network status register, and manageability control processor status register; the second priority acquisition task is to read data from the main memory controller register, double data rate memory extension register, and general interrupt controller status register; the third priority acquisition task is to read data from the peripheral component interconnect fast link configuration space and its extension register, as well as the security controller status register.
[0064] Specifically, the first priority acquisition task is as follows: Read the AP Core (Application Processor Core) registers to obtain the execution context at the moment of the crash, including the program counter, link register, and exception status register; read the AP RAM (Application Processor RAM, including readable areas in tightly coupled memory or L1 cache) to capture critical data being processed at the moment of the crash; read the CMN (Coherent Mesh Network) status register to record timeout or error states of cached consistency transactions; and read the MSCP (Management Controller Processor Status Register) to obtain the original error type and error vector captured by the MCP. This first priority acquisition task is executed first within the extremely short time window when the system has crashed or is about to hang, ensuring that even if the system is immediately powered off, the most critical evidence for locating the initial failure is preserved.
[0065] The second priority acquisition task is to focus on acquiring data consistency-related modules to locate crashes caused by memory bit flips, error injection, or interrupt storms. For example, reading the Memory (main memory controller register) to obtain DDR (Double Data Rate) timing parameters, error counts, and ECC (Error Correcting Code Status); reading the DDRC OEM (Double Data Rate Controller - Original Equipment Manufacturer) to obtain more detailed memory fault address and type information; and reading the GIC to analyze pending interrupt numbers, interrupt priorities, and activity status to diagnose interrupt storms or error interrupt propagation paths.
[0066] The third priority data collection task is mainly used to analyze crashes caused by PCIe link anomalies or security violations. These types of failures usually do not cause the system to lock up immediately and completely. The third priority data collection task is as follows: read PCIe and PCIe OEM (PCIe Original Equipment Manufacturer, a specific extended configuration space, i.e., manufacturer-defined PCIe extended configuration register) to obtain link health information such as link training status, MPS configuration, and ECRC error count; read SEC (Security Controller Status Register) to record security violation events, such as illegal memory access and TrustZone monitor (the core hub in the ARM TrustZone security architecture) timeout.
[0067] By employing the aforementioned three-tiered data collection strategy, the most valuable key evidence can always be prioritized within the limited survival time after a crash, ensuring that no initial fault clues are missed. When time permits, the collection scope can be expanded step by step, thereby achieving the best balance between reliability and data integrity, significantly improving the accuracy of root cause analysis, and avoiding the risk of missing critical registers due to blindly collecting all time-consuming modules (such as PCIe configuration space).
[0068] In one feasible implementation, the method of reading crash dump data from the hardware module of the ARM server according to the priority order defined in the hierarchical acquisition strategy can be: Based on the available time window after the system crash, the first priority acquisition task is executed first; after the first priority acquisition task is executed, if there is remaining time within the available time window, the second priority acquisition task is executed; after the second priority acquisition task is executed, if there is remaining time within the available time window, the third priority acquisition task is executed.
[0069] Specifically, the available time window is a limited period of time from the occurrence of a system crash to the point where the system becomes completely unresponsive or enters an unrecoverable hang. Within this available time window, the BMC can still access some hardware registers of the ARM server via out-of-band buses (such as I3C and JTAG). The length of this available time window depends on the type of crash; for example, a core processor hang typically provides only a millisecond-level window, while some peripheral failures may provide a second-level window.
[0070] Before starting the crash dump data collection, the BMC's user-mode handler first obtains the current system time as the starting point of the crash time window. The user-mode handler then executes the collection tasks sequentially in descending order of priority: first, the first-priority collection task is executed; after the first-priority collection task is completed, the user-mode handler obtains the current time again, calculates the elapsed time, and compares it with the preset total length of the available time window to determine if there is any remaining time; if there is remaining time, the second-priority collection task is executed; otherwise, the second and third-priority tasks are skipped. After the second-priority task is completed, the remaining time is checked again; if there is still remaining time, the third-priority task is executed; otherwise, the third-priority task is skipped.
[0071] This avoids the problem of key data not being collected in time due to a preset fixed timeout being too long, or resources being wasted due to a preset fixed timeout being too short, thus maximizing the effective information output rate of each crash dump.
[0072] In this embodiment, the success rate of each hardware module's acquisition and the frequency with which the hardware module is identified as key evidence of the root cause can also be recorded each time a first-priority acquisition task, a second-priority acquisition task, and a third-priority acquisition task are executed. When the frequency with which a hardware module is identified as key evidence of the root cause exceeds a first threshold within a preset period, and the module is currently assigned to a second-priority or third-priority acquisition task, the hardware module is adjusted to a first-priority acquisition task. According to the adjusted priority task assignment, the subsequent crash dump operation of the crash event is executed, thereby achieving adaptive optimization for different server operating characteristics.
[0073] In this embodiment, the method for recording the frequency with which each hardware module is identified as key evidence of the root cause can be: After each crash dump operation, the error identification information and the externally input root cause label are obtained. The root cause label is used to indicate the first faulty hardware module that caused the crash. Within a preset sliding time window, the number of times each hardware module is marked as a root cause label and the total number of times the module is collected are counted. The root cause confidence score of each hardware module is calculated. The root cause confidence score is equal to the number of times it is marked divided by the total number of times it is collected. When the root cause confidence score of a hardware module exceeds a preset second threshold and the module is currently classified as a second-priority collection task or a third-priority collection task, the collection task of the hardware module is adjusted to the first-priority collection task, and the configuration of the hierarchical collection strategy is updated.
[0074] By acquiring error identification information and externally inputted root cause labels after each crash, and calculating the root cause confidence score (the number of times it was marked as a root cause divided by the total number of times it was collected) for each hardware module within a sliding time window, it is possible to quantitatively and dynamically identify which hardware modules truly become key evidence of the initial failure in historical faults. This allows for continuous optimization of priority allocation through closed-loop feedback, giving priority to modules more likely to become root causes in subsequent crashes, thus improving the capture rate of key evidence.
[0075] In this embodiment, when the root cause confidence score of any hardware module exceeds a preset third threshold, the MCP updates the locally stored payload template and adds an extended information field corresponding to the hardware module to the payload of subsequent in-band interrupt requests. The extended information field includes at least the current value of a key register of the hardware module. When the BMC parses the payload, if it recognizes the extended information field, it directly stores the content of the field as part of the crash dump data, without needing to read the hardware module additionally via the I3C bus.
[0076] The payload format of in-band interruption requests is dynamically adjusted based on historical root cause statistics, enabling the MCP to carry more targeted key evidence at the moment of the crash, reducing reliance on the acquisition time window.
[0077] In this embodiment, a tiered data collection strategy is dynamically selected based on the error level, and the strategy is flexibly executed based on the available time window after the crash. Priority is given to collecting the only clues to locating the initial fault. If time permits, memory / interrupt related modules and PCIe / security registers are collected sequentially, ensuring that the most critical evidence is not lost under any window. After collection, the data is written to the eMMC and forced to disk via file synchronization. Only after generating confirmation information is a reset trigger command sent to the CPLD, which then performs debouncing and resets the CPU, thus completely avoiding data loss or corruption due to premature reset. This significantly improves the serviceability and root cause location success rate of the ARM server under fatal faults.
[0078] It should be noted that the above examples are only for understanding this application and do not constitute a limitation on the server crash event handling method based on the ARM architecture of this application. Any simple modifications based on this technical concept are within the protection scope of this application.
[0079] This application also provides a server crash event handling system based on ARM architecture. The server crash event handling system based on ARM architecture includes MCP, BMC and I3C bus. The BMC and the MCP are connected through the I3C bus. The BMC is the I3C master device and the MCP is the I3C slave device. MCP is used to send an in-band interrupt request to BMC via the I3C bus after detecting a system crash event of the ARM server. The payload of the in-band interrupt request carries crash-related information. The BMC is used to respond to the in-band interrupt request and push the crash-related information to the D-Bus bus through an asynchronous communication mechanism between kernel mode and user mode; A user-mode processing program running in the user-mode space of the BMC is used to subscribe to and receive crash-related information on the D-Bus bus, and to perform a crash dump operation based on the crash-related information.
[0080] The server crash event handling system based on ARM architecture provided in this application, employing the server crash event handling method based on ARM architecture described in the above embodiments, can solve the technical problems of severe compatibility barriers and insufficient reliability of fault capture in current x86 architecture-based server crash dumping mechanisms on heterogeneous ARM servers. Compared with the prior art, the beneficial effects of the server crash event handling system based on ARM architecture provided in this application are the same as those of the server crash event handling method based on ARM architecture provided in the above embodiments, and other technical features of the server crash event handling system based on ARM architecture are the same as those disclosed in the methods of the above embodiments, and will not be repeated here.
[0081] This application provides a server crash event handling device based on ARM architecture. The server crash event handling device based on ARM architecture includes: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions executable by the at least one processor, and the instructions are executed by the at least one processor to enable the at least one processor to execute the server crash event handling method based on ARM architecture in the above embodiment 1.
[0082] The following is for reference. Figure 4 This document illustrates a structural diagram of a server crash event handling device based on an ARM architecture suitable for implementing embodiments of this application. The server crash event handling device based on an ARM architecture in these embodiments may include, but is not limited to, mobile terminals such as mobile phones, tablets, laptops, digital broadcast receivers, PDAs (Personal Digital Assistants), PMPs (Portable Media Players), in-vehicle terminals (e.g., in-vehicle navigation terminals), and fixed terminals such as digital televisions and desktop computers. Figure 4 The server crash event handling device based on the ARM architecture shown is merely an example and should not impose any limitations on the functionality and scope of use of the embodiments of this application.
[0083] like Figure 4 As shown, the ARM-based server crash event handling device may include a processing system 1001 (e.g., a central processing unit, a graphics processing unit, etc.), which can perform various appropriate actions and processes according to a program stored in read-only memory (ROM) 1002 or a program loaded from storage device 1003 into random access memory (RAM) 1004. The RAM 1004 also stores various programs and data required for the operation of the ARM-based server crash event handling device. The processing system 1001, ROM 1002, and RAM 1004 are interconnected via a bus 1005. An input / output (I / O) interface 1006 is also connected to the bus. Typically, the following systems can be connected to I / O interface 1006: input devices 1007 including, for example, touchscreens, touchpads, keyboards, mice, image sensors, microphones, accelerometers, gyroscopes, etc.; output devices 1008 including, for example, liquid crystal displays (LCDs), speakers, vibrators, etc.; storage devices 1003 including, for example, magnetic tapes, hard disks, etc.; and communication devices 1009. Communication device 1009 allows the ARM-based server crash event processing device to communicate wirelessly or wiredly with other devices to exchange data. Although the figure shows an ARM-based server crash event processing device with various systems, it should be understood that it is not required to implement or have all the systems shown. More or fewer systems can be implemented alternatively.
[0084] Specifically, according to the embodiments disclosed in this application, the processes described above with reference to the flowcharts can be implemented as computer software programs. For example, embodiments disclosed in this application include a computer program product comprising a computer program carried on a computer-readable medium, the computer program containing program code for performing the methods shown in the flowcharts. In such embodiments, the computer program can be downloaded and installed from a network via a communication device, or installed from storage device 1003, or installed from ROM 1002. When the computer program is executed by processing system 1001, it performs the functions defined in the methods of the embodiments disclosed in this application.
[0085] The server crash event handling device based on ARM architecture provided in this application, employing the server crash event handling method based on ARM architecture described in the above embodiments, can solve the technical problems of severe compatibility barriers and insufficient reliability of fault capture in current x86 architecture-based server crash dumping mechanisms on heterogeneous ARM servers. Compared with the prior art, the beneficial effects of the server crash event handling device based on ARM architecture provided in this application are the same as those of the server crash event handling method based on ARM architecture provided in the above embodiments, and other technical features of this server crash event handling device based on ARM architecture are the same as those disclosed in the method of the previous embodiment, and will not be repeated here.
[0086] It should be understood that the various parts disclosed in this application can be implemented using hardware, software, firmware, or a combination thereof. In the description of the above embodiments, specific features, structures, materials, or characteristics can be combined in any suitable manner in one or more embodiments or examples.
[0087] The above description is merely a specific embodiment of this application, but the scope of protection of this application is not limited thereto. Any variations or substitutions that can be easily conceived by those skilled in the art within the scope of the technology disclosed in this application should be included within the scope of protection of this application. Therefore, the scope of protection of this application should be determined by the scope of the claims.
[0088] This application provides a computer-readable storage medium having computer-readable program instructions (i.e., a computer program) stored thereon, which are used to execute the server crash event handling method based on the ARM architecture in the above embodiments.
[0089] The computer-readable storage medium provided in this application may be, for example, a USB flash drive, but is not limited to, electrical, magnetic, optical, electromagnetic, infrared, or semiconductor systems, devices, or any combination thereof. More specific examples of computer-readable storage media may include, but are not limited to: electrical connections having one or more wires, portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination thereof. In this embodiment, the computer-readable storage medium may be any tangible medium containing or storing a program that can be used by or in conjunction with an instruction execution system, system, or device. The program code contained on the computer-readable storage medium may be transmitted using any suitable medium, including but not limited to: wires, optical cables, RF (Radio Frequency), etc., or any suitable combination thereof.
[0090] The aforementioned computer-readable storage medium may be included in an ARM-based server crash event handling device; or it may exist independently and not assembled into an ARM-based server crash event handling device.
[0091] The aforementioned computer-readable storage medium carries one or more programs, which, when executed by the ARM-based server crash event handling device, cause the ARM-based server crash event handling device to execute the aforementioned ARM-based server crash event handling method.
[0092] Computer program code for performing the operations of this application can be written in one or more programming languages or a combination thereof, including object-oriented programming languages such as Java, Smalltalk, and C++, and conventional procedural programming languages such as the "C" language or similar programming languages. The program code can be executed entirely on the user's computer, partially on the user's computer, as a standalone software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In cases involving remote computers, the remote computer can be connected to the user's computer via any type of network—including a Local Area Network (LAN) or a Wide Area Network (WAN)—or can be connected to an external computer (e.g., via the Internet using an Internet service provider).
[0093] The flowcharts and block diagrams in the accompanying drawings illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of this application. In this regard, each block in a flowchart or block diagram may represent a module, segment, or portion of code containing one or more executable instructions for implementing a specified logical function. It should also be noted that in some alternative implementations, the functions indicated in the blocks may occur in a different order than those indicated in the drawings. For example, two consecutively indicated blocks may actually be executed substantially in parallel, and they may sometimes be executed in reverse order, depending on the functions involved. It should also be noted that each block in the block diagrams and / or flowcharts, and combinations of blocks in the block diagrams and / or flowcharts, can be implemented using a dedicated hardware-based system that performs the specified function or operation, or using a combination of dedicated hardware and computer instructions.
[0094] The modules described in the embodiments of this application can be implemented in software or hardware. The names of the modules do not necessarily limit the functionality of the unit itself.
[0095] The readable storage medium provided in this application is a computer-readable storage medium that stores computer-readable program instructions (i.e., a computer program) for executing the above-described ARM-based server crash event handling method. This solves the technical problems of severe compatibility barriers and insufficient reliability of fault capture in current x86-based server crash dumping mechanisms on heterogeneous ARM servers. Compared with the prior art, the beneficial effects of the computer-readable storage medium provided in this application are the same as those of the ARM-based server crash event handling method provided in the above embodiments, and will not be repeated here.
[0096] This application also provides a computer program product, including a computer program that, when executed by a processor, implements the steps of the above-described ARM-based server crash event handling method.
[0097] The computer program product provided in this application can solve the technical problems of severe compatibility barriers and insufficient reliability of fault capture in current x86-based server crash dumping mechanisms on heterogeneous ARM servers. Compared with the prior art, the beneficial effects of the computer program product provided in this application are the same as those of the ARM-based server crash event handling method provided in the above embodiments, and will not be repeated here.
[0098] The above descriptions are merely some embodiments of this application and do not limit the scope of protection of this application. Any equivalent structural transformations made based on the technical concept of this application and the content of this specification and drawings, or direct / indirect applications in other related technical fields, are included within the scope of protection of this application. All actions involving the acquisition of signals, information, or data in this application are performed in accordance with the relevant data protection laws and policies of the country where the application is located and with authorization from the owner of the corresponding device.
Claims
1. A method for handling server crash events based on ARM architecture, characterized in that, The server crash event handling method based on ARM architecture includes: After the MCP detects a system crash event of the ARM server, it sends an in-band interrupt request to the BMC via the I3C bus. The payload of the in-band interrupt request carries crash-related information. The BMC responds to the in-band interrupt request and pushes the crash-related information to the D-Bus bus through an asynchronous communication mechanism between kernel mode and user mode. The user-mode handler subscribes to and receives crash-related information on the D-Bus bus, and performs a crash dump operation based on the crash-related information. The crash-related information includes error level and error identification information; The step of performing a crash dump operation based on the crash-related information includes: Based on the error level, a hierarchical acquisition strategy corresponding to the error level is selected from a variety of preset acquisition strategies; Crash dump data is read from the hardware module of the ARM server according to the priority order defined in the hierarchical acquisition strategy. After the crash dump data is persistently stored to the persistent medium, a reset trigger command is sent to the CPLD so that the CPLD sends a reset signal to the CPU. The tiered acquisition strategy includes a first-priority acquisition task, a second-priority acquisition task, and a third-priority acquisition task executed sequentially from high to low priority. The step of reading crash dump data from the hardware module of the ARM server according to the priority order defined in the tiered acquisition strategy includes: Based on the available time window after the system crash, the first priority acquisition task will be executed first. After the first priority data collection task is completed, if there is remaining time within the available time window, the second priority data collection task will continue to be executed. After the second priority acquisition task is completed, if there is remaining time within the available time window, the third priority acquisition task will continue to be executed. Record the success rate of hardware module acquisition and the frequency with which hardware module is identified as key evidence of the root cause during each execution of the first priority acquisition task, the second priority acquisition task, and the third priority acquisition task. When the frequency with which any hardware module is identified as key evidence of the root cause exceeds the first threshold within a preset period, and the corresponding hardware module is currently assigned to the second priority acquisition task or the third priority acquisition task, the corresponding hardware module will be adjusted to the first priority acquisition task so that subsequent crash dump operations of the crash event can be performed according to the adjusted priority task assignment.
2. The server crash event handling method based on ARM architecture as described in claim 1, characterized in that, The crash-related information includes error level and error identification information; The steps of the BMC responding to the in-band interrupt request and pushing the crash-related information to the D-Bus bus through an asynchronous communication mechanism between kernel mode and user mode include: In response to the in-band interrupt request, the BMC's I3C driver parses the payload and obtains the error level and the error identification information. Set the file descriptor associated with the in-band interrupt request to a readable state; After the event loop registered in the user-space handler based on the Boost.Asio asynchronous I / O framework detects that the file descriptor is readable, it calls the pre-registered callback function to push the error level and the error identification information to the D-Bus bus.
3. The server crash event handling method based on ARM architecture as described in claim 1, characterized in that, The first priority acquisition task is to read data from the application processor core register, application processor random access memory, consistency grid network status register, and manageability control processor status register. The second priority acquisition task is to read data from the main memory controller register, the double data rate memory extension register, and the general interrupt controller status register. The third priority acquisition task is to read data from the peripheral component interconnection fast link configuration space and its extended registers, as well as the security controller status register.
4. The server crash event handling method based on ARM architecture as described in claim 1, characterized in that, The persistent storage medium includes an embedded multimedia storage card. The step of persistently storing the crash dump data to the persistent storage medium and then sending a reset trigger command to the CPLD includes: Write the crash dump data into the embedded multimedia storage card and perform a file synchronization operation to confirm that the data has been physically written into the embedded multimedia storage card. After confirming that the data has been physically written, a write completion confirmation message is generated to trigger a reset trigger command to be sent to the CPLD.
5. A server crash event handling system based on ARM architecture, characterized in that, The server crash event handling system based on ARM architecture includes MCP, BMC and I3C bus. The BMC and the MCP are connected through the I3C bus. The BMC is the I3C master device and the MCP is the I3C slave device. MCP is used to send an in-band interrupt request to BMC via the I3C bus after detecting a system crash event of the ARM server. The payload of the in-band interrupt request carries crash-related information. The BMC is used to respond to the in-band interrupt request and push the crash-related information to the D-Bus bus through an asynchronous communication mechanism between kernel mode and user mode; A user-mode processing program running in the user-mode space of the BMC is used to subscribe to and receive crash-related information on the D-Bus bus, and to perform a crash dump operation based on the crash-related information. The crash-related information includes error level and error identification information; The user-mode processing program is also used for: Based on the error level, a hierarchical acquisition strategy corresponding to the error level is selected from a variety of preset acquisition strategies; Crash dump data is read from the hardware module of the ARM server according to the priority order defined in the hierarchical acquisition strategy. After the crash dump data is persistently stored to the persistent medium, a reset trigger command is sent to the CPLD so that the CPLD sends a reset signal to the CPU. The hierarchical acquisition strategy includes a first-priority acquisition task, a second-priority acquisition task, and a third-priority acquisition task, executed sequentially from high to low priority. The user-mode processing program is further used for: Based on the available time window after the system crash, the first priority acquisition task will be executed first. After the first priority data collection task is completed, if there is remaining time within the available time window, the second priority data collection task will continue to be executed. After the second priority acquisition task is completed, if there is remaining time within the available time window, the third priority acquisition task will continue to be executed. Record the success rate of hardware module acquisition and the frequency with which hardware module is identified as key evidence of the root cause during each execution of the first priority acquisition task, the second priority acquisition task, and the third priority acquisition task. When the frequency with which any hardware module is identified as key evidence of the root cause exceeds the first threshold within a preset period, and the corresponding hardware module is currently assigned to the second priority acquisition task or the third priority acquisition task, the corresponding hardware module will be adjusted to the first priority acquisition task so that subsequent crash dump operations of the crash event can be performed according to the adjusted priority task assignment.
6. A server crash event handling device based on ARM architecture, characterized in that, The ARM-based server crash event handling device includes: a memory, a processor, and a computer program stored in the memory and executable on the processor, the computer program being configured to implement the steps of the ARM-based server crash event handling method as described in any one of claims 1 to 4.
7. A storage medium, characterized in that, The storage medium is a computer-readable storage medium, and a computer program is stored on the storage medium. When the computer program is executed by a processor, it implements the steps of the server crash event handling method based on the ARM architecture as described in any one of claims 1 to 4.
8. A computer program product, characterized in that, The computer program product includes a computer program that, when executed by a processor, implements the steps of the server crash event handling method based on the ARM architecture as described in any one of claims 1 to 4.
Citation Information
Patent Citations
Control management system and method, electronic equipment and storage medium
CN119883823A
Server state detection method and device, electronic equipment and storage medium
CN120492263A
Hardware monitoring system and method and related equipment
CN120723573A
