Vehicle software differential diagnosis and adaptive hot repair method

By subscribing to the vehicle software status in the cloud, generating function-level differential patches and atomically redirecting the entry address, the coarse-grained and high-cost problems of traditional vehicle software repair methods are solved, achieving seamless and accurate repair, and improving repair efficiency and user experience.

CN123068162APending Publication Date: 2026-11-10DONGFENG MOTOR GRP
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
CN202611119764.1
Authority / Receiving Office
CN · China
Patent Type
Applications(China)
Current Assignee / Owner
Filing Date
2026-07-27
Publication Date
2026-11-10

AI Technical Summary

Technical Problem

Traditional vehicle software repair methods suffer from problems such as coarse repair granularity, high traffic costs, long processing time, and impact on user experience. Existing diagnostic protocols cannot support runtime mechanisms for process-level hot repair.

Method used

By subscribing to the running status of vehicle-side software entities in the cloud, collecting fault feature vectors, generating function-level differential patches, and atomically redirecting the entry address of the target function in memory, hot repair can be achieved without the user's awareness.

Benefits of technology

It achieves a closed-loop process from precise fault location to seamless runtime repair, shortening the time from fault discovery to repair, reducing network traffic and repair time, and improving user experience.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN123068162A_ABST
    Figure CN123068162A_ABST
Patent Text Reader

Abstract

The application provides a vehicle software differential diagnosis and adaptive hot repair method, and relates to the technical field of vehicle diagnosis and software repair. The method comprises the following steps: a cloud end sends a subscription instruction to a vehicle end to subscribe to the running state of a target software entity; in response to the target software entity satisfying a preset trigger condition expression, the vehicle end collects and reports a fault feature vector containing a program counter value; the cloud end locates a target function to be repaired in a software bill of materials according to the program counter value, and generates a function-level differential patch containing only the correction code of the target function; the vehicle end receives the function-level differential patch, and atomically redirects the original entry address of the target function in the memory to the address where the correction code is located, so as to complete the hot repair without interrupting the process running. The application reduces the traffic cost of OTA repair and the influence on users.
Need to check novelty before this filing date? Find Prior Art

Description

Technical Field

[0001] This invention relates to the field of vehicle diagnostics and software repair technology, specifically to a vehicle software differential diagnostics and adaptive thermal repair method based on a service-oriented vehicle diagnostic protocol. Background Technology

[0002] As automotive electronic and electrical architecture evolves towards "central computing + regional control," the AUTOSARAdaptive platform and a large number of application services run on the central domain controller (High Performance Computer). Unexpected functional failures caused by software defects and cybersecurity vulnerabilities are becoming increasingly frequent.

[0003] Traditional software repair methods rely on over-the-air (OTA) updates for the entire vehicle, which has the following drawbacks: First, the repair granularity is coarse, usually requiring the download of a complete firmware package of hundreds of megabytes to gigabytes, resulting in high data costs and long processing times; second, the repair process is highly perceptible, requiring the vehicle to be parked or locked for tens of minutes of silent installation, which seriously affects the user experience. Although existing flashing solutions based on the SOVD (Service-Oriented Vehicle Diagnostics) protocol have solved the problem of a unified flashing channel under heterogeneous multi-core architectures, their log API is only used to obtain logs after a flashing failure. They do not involve structured data collection during the fault diagnosis phase, nor do they establish a fine mapping relationship between versions and software components, and therefore cannot support a runtime mechanism for process-level hot repair.

[0004] Therefore, there is an urgent need for a software repair solution that can achieve fine-grained, seamless repair based on accurate diagnosis. Summary of the Invention

[0005] In view of the technical defects and drawbacks existing in the prior art, the present invention provides a vehicle software differential diagnosis and adaptive thermal repair method to overcome the above problems or at least partially solve the above problems, the specific solution of which is as follows;

[0006] A vehicle software differential diagnostic and adaptive thermal repair method includes:

[0007] The cloud sends a subscription command to the vehicle to subscribe to the running status of the target software entity;

[0008] In response to the target software entity's operating state meeting a preset triggering condition, the vehicle terminal collects and reports a fault feature vector containing a program counter value.

[0009] The cloud platform locates the target function to be repaired in the software bill of materials based on the program counter value, and generates a function-level differential patch that contains only the correction code for the target function.

[0010] The vehicle receives the function-level differential patch and atomically redirects the original entry address of the target function in memory to the address of the correction code corresponding to the function-level differential patch, so as to complete the hot repair without interrupting the process.

[0011] In some embodiments, the subscription instruction includes a trigger condition expression to define the operating state conditions for triggering fault acquisition; the vehicle-side acquisition and reporting of a fault feature vector containing a program counter value specifically includes:

[0012] The SOVDServlet library on the vehicle side parses the trigger condition expression in the subscription instruction, and when it determines that the running status of the target software entity satisfies the trigger condition expression, it triggers the fault collection agent to perform the collection operation.

[0013] The fault acquisition agent obtains the memory mapping information of the process in which the target software entity is located, as well as a register snapshot of at least one processor core of the process at the time of the fault by calling the underlying interface of the operating system. The register snapshot includes at least the program counter value, the stack pointer value, and the link register value.

[0014] The fault acquisition agent encapsulates the memory mapping information and the register snapshot into structured data with a predetermined JSON format to form a fault feature vector;

[0015] The fault acquisition agent transmits the fault feature vector back to the cloud via the event channel defined by the SOVD protocol.

[0016] In some embodiments, the cloud, based on the program counter value, locates the target function to be repaired in the software bill of materials and generates a function-level differential patch containing only the correction code for the target function, specifically including:

[0017] The cloud platform parses the program counter value from the fault feature vector;

[0018] The cloud obtains the software version identifier currently running on the vehicle and retrieves a software bill of materials that matches the software version identifier from local storage. The software bill of materials includes version hashes of each software component and a memory address mapping table of function entry addresses.

[0019] The cloud platform performs reverse mapping in the memory address mapping table based on the program counter value to locate the erroneous target function and its original entry address.

[0020] The cloud extracts the old version binary segment of the target function from the original binary file corresponding to the software version identifier, and extracts the new version binary segment of the target function from the repaired new version binary file;

[0021] The cloud platform runs a binary difference algorithm on the old version binary segment and the new version binary segment to generate the function-level difference patch that only contains the differences.

[0022] In some embodiments, the vehicle-side atomically redirects the original entry address of the target function in memory to the address of the correction code corresponding to the function-level differential patch, so as to complete the hot patch without interrupting process execution, specifically including:

[0023] The vehicle-side hotfix manager receives and parses the function-level differential patch, extracting the corrected function binary code from it;

[0024] The hotfix manager loads the corrected function binary code into an anonymous memory page with read and execute permissions allocated via mmap through a memory mapping system call.

[0025] The hotfix manager utilizes the dynamic linking feature of the operating system to modify the global offset table or process link table of the process containing the target software entity in an atomic manner, replacing the original entry address of the target function with the starting address of the anonymous memory page in one go, so that subsequent calls to the target function can directly jump to the corrected function binary code.

[0026] In some embodiments, before the hotfix manager loads the corrected function binary code into the anonymous memory page, the method further includes:

[0027] The hotfix manager extracts a pre-execution verification list from the function-level differential patch. The pre-execution verification list contains the hash value of the entry address of the target function during the compilation stage.

[0028] The hotfix manager reads the current runtime entry address of the target function in the process where the target software entity is located, and calculates the hash value of the runtime entry address to obtain the runtime hash value;

[0029] The hotfix manager compares the runtime hash value with the entry address hash value in the execution pre-verification list;

[0030] If the two match, the verification is deemed successful, and the operation of loading the corrected function binary code into the anonymous memory page continues.

[0031] If the two are inconsistent, the verification is deemed to have failed, the function-level differential patch is rejected, and the verification failure feedback information is reported to the cloud.

[0032] In some embodiments, before the hotfix manager atomically modifies the global offset table or the process link table, the method further includes:

[0033] The hotfix manager backs up the original entry address of the target function to non-volatile memory and sets the hotfix status flag.

[0034] After the function-level differential patch is applied, if the process containing the target software entity exits abnormally, the bootloader will read the hotfix status flag bit when the system starts up again. If the hotfix status flag bit indicates that there is an incomplete rollback requirement, the corresponding entry in the global offset table or the process link table will be automatically restored to the original entry address based on the original entry address backed up in the non-volatile memory.

[0035] In some embodiments, after the vehicle receives the function-level differential patch and before redirecting the original entry address of the target function, the method further includes:

[0036] The vehicle-side hot repair manager queries the pre-stored repair strategy configuration table, determines the ASIL level of the target software entity based on its identifier, and obtains the repair execution constraints corresponding to the ASIL level. The ASIL level is a vehicle safety integrity level defined based on the ISO 26262 standard, including ASIL-D, ASIL-B, and Quality Management Level (QM), which represent the highest to lowest safety requirement levels, respectively.

[0037] The thermal repair manager subscribes to and obtains the current vehicle's operating status parameters in real time through the SOVD application programming interface.

[0038] The hot repair manager determines whether the current vehicle's operating status parameters meet the repair execution constraints.

[0039] If the conditions are met, the hotfix manager allows the operation of redirecting the original entry address of the target function to the address where the fix code is located to continue;

[0040] If the conditions are not met, the hotfix manager will add the current repair task to the delayed execution queue and continuously monitor the current vehicle's operating status parameters through the SOVD application programming interface until the current vehicle's operating status parameters meet the repair execution constraints. Then, the hotfix manager will automatically wake up the repair task from the delayed execution queue and execute the redirection operation.

[0041] The repair strategy configuration table includes at least the following repair execution constraints preset for software components of different ASIL levels:

[0042] For software components at ASIL-D level, the repair execution constraint is that the vehicle speed is zero and the gear is in park; where ASIL-D is the highest safety integrity level defined in the ISO 26262 standard, applicable to systems with the most severe consequences of failure, such as braking and steering.

[0043] For software components at ASIL-B level, the repair execution constraint is that the memory bandwidth utilization is lower than a preset threshold during the execution of the redirection operation; where ASIL-B is a medium security integrity level defined in the ISO 26262 standard, applicable to systems with moderately severe consequences of failures, such as lighting control.

[0044] For software components with a quality management level (QM), the repair execution constraints are unlimited; wherein, the quality management level (QM) is the minimum safety requirement level defined in the ISO 26262 standard, applicable to non-safety-critical systems where the consequences of failure do not affect safety.

[0045] In some embodiments, the cloud sends subscription instructions to the vehicle via an extended SOVD application programming interface POST / diagnostics / trace / subscribe.

[0046] The subscription instructions include:

[0047] The identifier of the target software entity is used to specify the diagnostic object to be monitored;

[0048] The trigger condition expression is used to define the operating state conditions that trigger fault acquisition;

[0049] The data specifications for the fault feature vector are used to indicate the register type and memory data range that the vehicle terminal needs to collect when triggered.

[0050] In some embodiments, when a vehicle contains multiple central domain controller nodes, the cloud sends a subscription instruction to the vehicle, and the vehicle collects and reports fault feature vectors, specifically including:

[0051] Each of the central domain controller nodes is equipped with a private SOVD server, and a public SOVD server provides a unified diagnostic service entry point to the outside world.

[0052] The cloud sends the subscription instruction to the public SOVD server, which then routes the subscription instruction to the private SOVD server on the target central domain controller node based on the target software entity identifier in the subscription instruction.

[0053] The fault acquisition agent on the target central domain controller node responds to the subscription instruction, acquires the fault feature vector, and submits the fault feature vector to the local private SOVD server.

[0054] The private SOVD server transmits the fault feature vector back to the cloud via the public SOVD server.

[0055] In some embodiments, the method further includes:

[0056] The vehicle-side maintains a dynamic software bill of materials tree in real time. The dynamic software bill of materials tree records the version hash, function entry address table, and dependencies between components for each software component.

[0057] In response to a version change of a software component, the vehicle-side updates the version hash and function entry address table of the corresponding software component in the dynamic software bill of materials tree;

[0058] The vehicle-mounted device synchronizes the updated dynamic software bill of materials tree to the cloud via the SOVD protocol data synchronization interface, so that the software bill of materials stored in the cloud is consistent with the current operating status of the vehicle-mounted device.

[0059] The present invention has the following beneficial effects:

[0060] This invention provides a cloud-edge collaborative method for differential diagnostics and adaptive hotfix of vehicle software, achieving a closed-loop process from precise fault location to seamless runtime repair. Specifically, this invention actively subscribes to the vehicle's software runtime status via the cloud, replacing the traditional passive waiting for fault code reports, significantly shortening the time window from fault detection to repair. The cloud uses the program counter value in the fault feature vector, combined with the software bill of materials, to precisely locate the faulty function level, rather than the entire software module, thereby generating a micro-pattern containing only the differing parts. After receiving the patch, the vehicle performs runtime repair by atomically redirecting the original entry address, without needing to restart the process or wait for the vehicle to park. For example, when an audio decoding function in the in-vehicle infotainment system crashes, the vehicle can silently repair the function while driving without entering maintenance mode or waiting for the full OTA download, with almost no noticeable impact on the user. Attached Figure Description

[0061] Figure 1This is a flowchart illustrating a vehicle software differential diagnosis and adaptive thermal repair method provided in an embodiment of the present invention.

[0062] Figure 2 A flowchart illustrating the core functional modules of the SOVDServlet library provided in this embodiment of the invention;

[0063] Figure 3 A schematic diagram of a centralized agent mode architecture for a master control ECU provided in an embodiment of the present invention;

[0064] Figure 4 This is a schematic diagram of the overall system architecture provided for an embodiment of the present invention. Detailed Implementation

[0065] To enable those skilled in the art to better understand the technical solutions of the present invention, exemplary embodiments of the present invention are described below in conjunction with the accompanying drawings, including various details of the embodiments of the present invention to aid understanding. These should be considered merely exemplary. Therefore, those skilled in the art should recognize that various changes and modifications can be made to the embodiments described herein without departing from the scope and spirit of the present invention. Similarly, for clarity and brevity, descriptions of well-known functions and structures are omitted in the following description.

[0066] Where there is no conflict, the various embodiments of the present invention and the features thereof may be combined with each other.

[0067] As used herein, the term “and / or” includes any and all combinations of one or more related enumerated entries.

[0068] The terminology used herein is for the purpose of describing particular embodiments only and is not intended to limit the invention. As used herein, the singular forms “a” and “the” are intended to include the plural forms as well, unless the context clearly indicates otherwise. It will also be understood that when the terms “comprising” and / or “made of” are used in this specification, the presence of the stated feature, integral, step, operation, element, and / or component is specified, but the presence or addition of one or more other features, integrals, steps, operations, elements, components, and / or groups thereof is not excluded. Terms such as “connected” or “linked” are not limited to physical or mechanical connections but can include electrical connections, whether direct or indirect.

[0069] Unless otherwise specified, all terms used herein (including technical and scientific terms) have the same meaning as commonly understood by one of ordinary skill in the art. It will also be understood that terms such as those defined in commonly used dictionaries should be interpreted as having the meaning consistent with their meaning in the context of the relevant art and the invention, and will not be interpreted as having an idealized or overly formal meaning unless expressly so defined herein.

[0070] In the technical solution of this invention, the collection, storage, use, processing, transmission, provision, and disclosure of user personal information all comply with relevant laws and regulations and do not violate public order and good morals. The use of user data in this technical solution follows relevant national laws and regulations (e.g., the "Information Security Technology - Personal Information Security Specification"). For example: appropriate measures are taken for personal information access control; restrictions are imposed on the display of personal information; the purpose of using personal information does not exceed the scope of direct or reasonable association; and explicit identity targeting is eliminated when using personal information to avoid precisely locating a specific individual.

[0071] To address at least one of the technical problems existing in the aforementioned related technologies, the present invention provides a vehicle software differential diagnosis and adaptive thermal repair method. Figure 1 A flowchart illustrating a vehicle software differential diagnostic and adaptive thermal repair method provided in this embodiment of the invention includes:

[0072] S1. The cloud sends a subscription command to the vehicle to subscribe to the running status of the target software entity;

[0073] S2. In response to the target software entity's running state meeting a preset triggering condition, the vehicle terminal collects and reports a fault feature vector containing a program counter value.

[0074] S3. The cloud platform locates the target function to be repaired in the Software Bill of Materials (SBOM) based on the program counter value, and generates a function-level differential patch containing only the correction code for the target function.

[0075] S4. The vehicle receives the function-level differential patch and atomically redirects the original entry address of the target function in memory to the address of the correction code corresponding to the function-level differential patch, so as to complete the hot repair without interrupting the process.

[0076] This invention provides a cloud-edge collaborative method for differential diagnostics and adaptive hotfix of vehicle software, achieving a closed-loop process from precise fault location to seamless runtime repair. Specifically, this invention actively subscribes to the vehicle's software runtime status via the cloud, replacing the traditional passive waiting for fault code reports, significantly shortening the time window from fault detection to repair. The cloud uses the program counter value in the fault feature vector, combined with the software bill of materials, to precisely locate the faulty function level, rather than the entire software module, thereby generating a micro-pattern containing only the differing parts. After receiving the patch, the vehicle performs runtime repair by atomically redirecting the original entry address, without needing to restart the process or wait for the vehicle to park. For example, when an audio decoding function in the in-vehicle infotainment system crashes, the vehicle can silently repair the function while driving without entering maintenance mode or waiting for the full OTA download, with almost no noticeable impact on the user.

[0077] In some embodiments, the subscription instruction includes a trigger condition expression to define the operating state conditions for triggering fault acquisition; the vehicle-side acquisition and reporting of a fault feature vector containing a program counter value specifically includes:

[0078] The SOVDServlet library on the vehicle side parses the trigger condition expression in the subscription instruction, and when it determines that the running status of the target software entity satisfies the trigger condition expression, it triggers the fault collection agent to perform the collection operation.

[0079] The fault acquisition agent obtains the memory mapping information of the process in which the target software entity is located, as well as a register snapshot of at least one processor core of the process at the time of the fault by calling the underlying interface of the operating system. The register snapshot includes at least the program counter value, the stack pointer value, and the link register value.

[0080] The fault acquisition agent encapsulates the memory mapping information and the register snapshot into structured data with a predetermined JSON format to form a fault feature vector;

[0081] The fault acquisition agent transmits the fault feature vector back to the cloud via the event channel defined by the SOVD protocol.

[0082] The above embodiments achieve precise capture of fault scenarios by extending the subscription mechanism of the SOVD protocol. Specifically, the SOVDServlet library on the vehicle side parses the trigger condition expression in the subscription command sent from the cloud, triggering collection only when specific conditions are met, thus avoiding the performance overhead of continuous collection. The fault collection agent obtains the process's memory mapping information and processor core register snapshots by calling the underlying interface of the operating system, including program counter values, stack pointer values, and link register values. This data constitutes a complete fault context. After encapsulating this raw data into a JSON-formatted fault feature vector, it is transmitted back to the cloud through the SOVD event channel. For example, when a process of the autonomous driving perception module crashes due to out-of-bounds memory access, the collected program counter value can directly point to the line of code that caused the error, and the stack trace reveals the complete function call chain, providing sufficient evidence for the cloud to accurately locate the root cause.

[0083] In some embodiments, the fault feature vector is structured data in JSON format, containing at least the following fields:

[0084] The program counter value is used to identify the position of the instruction execution when the fault occurs;

[0085] The stack pointer value is used to identify the current position of the top of the stack;

[0086] The link register value is used to identify the return address of a function call;

[0087] Stack backtrace is used to record the complete call chain from the point of failure to the root calling function;

[0088] The memory mapping information is used to record the virtual address space layout of the process in which the target software entity resides.

[0089] The above embodiments further ensure the integrity and parsability of fault scene information by explicitly defining structured data fields for fault feature vectors. Specifically, the fault feature vector includes at least five core fields: program counter value, stack pointer value, link register value, stack backtrace, and memory mapping information. The program counter value directly points to the instruction address at the time of the fault, the stack backtrace reveals the complete call chain from the root function call to the fault point, and the memory mapping information reflects the virtual address space layout of the process. For example, when the autonomous driving perception module crashes due to null pointer dereferencing, the program counter value points to the dereferenced instruction, the stack backtrace shows that the function was called by the upstream perception fusion function, and the memory mapping information shows that the relevant memory segment was not mapped. Based on this, the cloud can quickly determine whether it is a memory initialization omission or an algorithm logic error, thereby generating an accurate repair patch.

[0090] refer to Figure 2The diagram shown illustrates the core functional modules of the SOVDServlet library provided in this embodiment of the invention. This library is the core business processing component for the vehicle-mounted central domain controller to receive SOVD diagnostic requests from the cloud. It is divided into six decoupled functional modules that collaboratively complete the entire process of HTTP request access, security verification, message encoding and decoding, resource addressing, diagnostic business processing, and fault site collection.

[0091] HTTP Request Router: As the entry point for request distribution, it parses the HTTP request URL path in the cloud, matches and forwards it to the corresponding business handler, thus realizing request routing and scheduling.

[0092] JSON parsing / serialization module: responsible for JSON deserialization of diagnostic request messages, structured encapsulation of response data, and conversion of data formats between the cloud and the vehicle.

[0093] Resource locator: Establishes a mapping relationship between software entities and the vehicle's A core, M core, and traditional ECU internal diagnostic resources to accurately locate the objects to be accessed and collected.

[0094] Security Filter: Enables end-to-end access control, completes cloud identity verification through OAuth2.0, configures hierarchical role permissions, retains all remote access audit logs, and blocks unauthorized requests.

[0095] Diagnostic Service Handler: Carries the business logic of three types of standard SOVD diagnostic interfaces, handling GET / data reading, POST / updates subscription configuration distribution, and PUT / execute diagnostic execution commands respectively.

[0096] Fault Acquisition Agent: Receives acquisition commands issued by the Handler, performs stack capture, processor register snapshot capture, and exception event-triggered acquisition, and outputs raw fault scene data.

[0097] Each module works in a sequential, collaborative manner according to the request processing chain: after cloud requests are routed, parsed, and securely verified, the diagnostic Handler executes business logic, calls the resource locator to match underlying resources as needed, calls the fault collection agent to capture fault data, and finally serializes the response and returns it to the cloud. Each module is independent and decoupled, which facilitates the individual expansion of collection rules, the addition of interfaces and security policies, providing basic software support for cloud-based subscription-based fine-grained fault collection.

[0098] In some embodiments, the cloud, based on the program counter value, locates the target function to be repaired in the software bill of materials and generates a function-level differential patch containing only the correction code for the target function, specifically including:

[0099] The cloud platform parses the program counter value from the fault feature vector;

[0100] The cloud obtains the software version identifier currently running on the vehicle and retrieves a software bill of materials that matches the software version identifier from local storage. The software bill of materials includes version hashes of each software component and a memory address mapping table of function entry addresses.

[0101] The cloud platform performs reverse mapping in the memory address mapping table based on the program counter value to locate the erroneous target function and its original entry address.

[0102] The cloud extracts the old version binary segment of the target function from the original binary file corresponding to the software version identifier, and extracts the new version binary segment of the target function from the repaired new version binary file;

[0103] The cloud platform runs a binary difference algorithm on the old version binary segment and the new version binary segment to generate the function-level difference patch that only contains the differences.

[0104] The above embodiments achieve precise function-level localization and micro-patch generation by combining fault feature vectors and software bill of materials. Specifically, the cloud first parses the program counter value from the fault feature vector, then obtains the software version identifier currently running on the vehicle, and retrieves the matching software bill of materials from local storage. The software bill of materials contains version hashes of each software component and a memory address mapping table of function entry addresses. Based on this, the cloud reverse maps the program counter value to the specific faulty function and its entry address. Subsequently, the cloud extracts the old and new version binary segments of the target function from the original binary file and the repaired new version binary file, respectively, and generates a function-level differential patch containing only the differences using a binary differential algorithm. For example, a repair task that originally required a 500MB OTA package can be reduced to a function-level patch of tens of KB using this solution, saving network traffic and significantly shortening download and installation time.

[0105] In some embodiments, the vehicle-side atomically redirects the original entry address of the target function in memory to the address of the correction code corresponding to the function-level differential patch, so as to complete the hot patch without interrupting process execution, specifically including:

[0106] The vehicle-side hotfix manager receives and parses the function-level differential patch, extracting the corrected function binary code from it;

[0107] The hotfix manager loads the corrected function binary code into an anonymous memory page with read and execute permissions allocated via mmap through a memory mapping system call.

[0108] The hotfix manager utilizes the dynamic linking feature of the operating system to modify the global offset table or process link table of the process containing the target software entity in an atomic manner, replacing the original entry address of the target function with the starting address of the anonymous memory page in one go, so that subsequent calls to the target function can directly jump to the corrected function binary code.

[0109] The above embodiments achieve seamless repair without interrupting the process or restarting the system through a runtime hot-fix method based on function pointer redirection. Specifically, the vehicle-side hot-fix manager parses the function-level differential patch, extracts the corrected function binary code, and loads it into an anonymous memory page with read and execute permissions via the mmap system call. Subsequently, leveraging the operating system's dynamic linking feature, the target process's global offset table or process link table is modified atomically, replacing the original function's entry address with the starting address of the anonymous memory page in one go. Afterward, all calls to this function will automatically jump to the corrected code, and the process itself does not need to be restarted or paused. For example, when a memory leak vulnerability exists in the TCP / IP protocol stack of the vehicle communication module, it is not necessary to restart the entire communication process; simply replacing the problematic function implementation at runtime can complete the repair without interrupting the ongoing network connection.

[0110] In some embodiments, before the hotfix manager loads the corrected function binary code into the anonymous memory page, the method further includes:

[0111] The hotfix manager extracts a pre-execution verification list from the function-level differential patch. The pre-execution verification list contains the hash value of the entry address of the target function during the compilation stage.

[0112] The hotfix manager reads the current runtime entry address of the target function in the process where the target software entity is located, and calculates the hash value of the runtime entry address to obtain the runtime hash value;

[0113] The hotfix manager compares the runtime hash value with the entry address hash value in the execution pre-verification list;

[0114] If the two match, the verification is deemed successful, and the operation of loading the corrected function binary code into the anonymous memory page continues.

[0115] If the two are inconsistent, the verification is deemed to have failed, the function-level differential patch is rejected, and the verification failure feedback information is reported to the cloud.

[0116] The above embodiments effectively prevent the misapplication of patches caused by Address Space Layout Randomization (ASLR) through a pre-patch verification mechanism, ensuring the accuracy of hotfixes. Specifically, the hotfix manager extracts a pre-execution verification list from the function-level differential patch. This list contains the hash value of the target function's entry address during the compilation phase. Before loading the patch code, the hotfix manager reads the current runtime entry address of the target function, calculates its hash value, and compares it with the hash value in the verification list. If they match, it means that the current runtime environment is consistent with the expected environment when the patch was generated, and the loading operation is allowed to continue. If they do not match, it means that ASLR or other factors have caused the function address to change. In this case, the patch is rejected, and a verification failure feedback message is reported to the cloud. For example, when a vehicle undergoes an OTA upgrade that changes the kernel address space layout, the patch generated in the cloud may no longer be applicable to the new address layout. The pre-verification mechanism can promptly intercept such mismatched patches, avoiding system crashes caused by incorrect memory address modifications.

[0117] In some embodiments, when the cloud generates the function-level difference patch, it further includes:

[0118] The cloud platform obtains the hash value of the entry address of the objective function during the compilation phase from the software bill of materials.

[0119] The cloud writes the entry address hash value into the metadata area of ​​the function-level differential patch to form a pre-execution verification list;

[0120] The cloud platform packages the pre-execution verification list and the function-level differential patch together and sends them to the vehicle terminal. This allows the vehicle terminal to verify the compatibility of the function-level differential patch with the current runtime environment by comparing the runtime entry address hash value with the entry address hash value in the pre-execution verification list before applying the function-level differential patch.

[0121] Furthermore, when generating patches, the cloud writes the hash value of the target function's entry address during the compilation phase into the patch metadata area, forming a pre-execution verification list. This provides the vehicle with a reliable basis for verifying the patch's compatibility with the current runtime environment. For example, when the cloud generates a fix patch for a vehicle model's Bluetooth protocol stack, it writes the hash value of the Bluetooth pairing function's entry address during the compilation phase into the patch metadata area. If the vehicle's ASLR mechanism loads this function into a different memory address, the vehicle will detect the hash value mismatch during verification, thus rejecting the application of the patch and notifying the cloud to regenerate it, avoiding erroneous memory writes due to address mismatches.

[0122] In some embodiments, before the hotfix manager atomically modifies the global offset table or the process link table, the method further includes:

[0123] The hotfix manager backs up the original entry address of the target function to non-volatile memory and sets the hotfix status flag.

[0124] After the function-level differential patch is applied, if the process containing the target software entity exits abnormally, the bootloader will read the hotfix status flag bit when the system starts up again. If the hotfix status flag bit indicates that there is an incomplete rollback requirement, the corresponding entry in the global offset table or the process link table will be automatically restored to the original entry address based on the original entry address backed up in the non-volatile memory.

[0125] The above embodiments ensure the safety of hotfix operations through a rollback protection mechanism, preventing system startup failures due to patch compatibility issues. Specifically, before the hotfix manager modifies the global offset table or process link table, the original entry address of the target function is backed up to non-volatile memory, and a hotfix status flag is set. If the target process exits abnormally after the patch is applied, the bootloader will read the hotfix status flag upon the next system startup. If an incomplete rollback is detected, the corresponding entry in the global offset table or process link table will be automatically restored to the backed-up original entry address. For example, suppose a hotfix patch for an ASIL-B level lighting control module has a compatibility issue with the underlying driver, causing the process to crash. Upon the next vehicle power-on, the bootloader will automatically detect the anomaly and roll back the repair, restoring the lighting control function to its pre-patch usable state and preventing the vehicle from losing basic functionality due to software failure.

[0126] In some embodiments, after the vehicle receives the function-level differential patch and before redirecting the original entry address of the target function, the method further includes:

[0127] The vehicle-side hot repair manager queries the pre-stored repair strategy configuration table, determines the ASIL level of the target software entity based on its identifier, and obtains the repair execution constraints corresponding to the ASIL level. The ASIL level is a vehicle safety integrity level defined based on the ISO26262 standard, including ASIL-D, ASIL-B, and Quality Management Level (QM), which represent the highest to lowest safety requirement levels, respectively.

[0128] The thermal repair manager subscribes to and obtains the current vehicle's operating status parameters in real time through the SOVD application programming interface.

[0129] The hot repair manager determines whether the current vehicle's operating status parameters meet the repair execution constraints.

[0130] If the conditions are met, the hotfix manager allows the operation of redirecting the original entry address of the target function to the address where the fix code is located to continue;

[0131] If the conditions are not met, the hot repair manager will add the current repair task to the delayed execution queue and continuously monitor the current vehicle's operating status parameters through the SOVD application programming interface until the current vehicle's operating status parameters meet the repair execution constraints. Then, the hot repair manager will automatically wake up the repair task from the delayed execution queue and execute the redirection operation.

[0132] The repair strategy configuration table includes at least the following repair execution constraints preset for software components of different ASIL levels:

[0133] For software components at ASIL-D level, the repair execution constraint is that the vehicle speed is zero and the gear is in park.

[0134] For ASIL-B level software components, the repair execution constraint is that the memory bandwidth utilization is lower than a preset threshold during the execution of the redirection operation;

[0135] For software components at the quality management level, the repair execution constraints are unlimited.

[0136] The above embodiments introduce a functional safety constraint arbitration mechanism based on ASIL levels and pre-set differentiated repair execution constraints for software components with different ASIL levels. This achieves fine-grained matching between functional safety levels and repair strategies, ensuring that hot repair operations can be safely executed on software components with different safety levels and avoiding the introduction of new safety risks by the repair behavior itself. Specifically, the hot repair manager queries the pre-stored repair strategy configuration table, determines the ASIL level and corresponding repair execution constraints based on the identifier of the target software entity, and makes a judgment by subscribing to vehicle operating status parameters in real time through the SOVD API. If the current state meets the constraints, the repair is executed immediately; otherwise, the task is added to the delayed execution queue and continuously monitored, and automatically woken up for execution when the conditions are met. Among them, the highest safety-critical components of ASIL-D level are subject to the strictest constraints and are only allowed to be repaired when the vehicle is completely stationary; medium safety-critical components of ASIL-B level are allowed to be repaired while in motion, but memory bandwidth usage is limited to avoid affecting the execution of other real-time tasks; non-safety-critical components of Quality Management level (QM) are not subject to any restrictions and can be repaired at any time. For example, when a vehicle is traveling at high speed, the repair task of the ASIL-D braking control module will be automatically delayed until the vehicle stops, while the repair task of the QM-level infotainment system can be executed immediately. The two do not interfere with each other, ensuring driving safety without affecting the rapid recovery of non-critical functions.

[0137] In some embodiments, the cloud sends subscription instructions to the vehicle via an extended SOVD application programming interface POST / diagnostics / trace / subscribe.

[0138] The subscription instructions include:

[0139] The identifier of the target software entity is used to specify the diagnostic object to be monitored;

[0140] The trigger condition expression is used to define the operating state conditions that trigger fault acquisition;

[0141] The data specifications for the fault feature vector are used to indicate the register type and memory data range that the vehicle terminal needs to collect when triggered.

[0142] The above embodiments provide a standardized, configurable fault subscription mechanism by extending the SOVD application programming interface. Specifically, the cloud sends a subscription command through the POST / diagnostics / trace / subscribe interface. The command includes three elements: the identifier of the target software entity, the trigger condition expression, and the data collection specifications. The identifier of the target software entity allows the cloud to accurately specify the diagnostic object to be monitored, avoiding false alarms; the trigger condition expression allows the cloud to set differentiated trigger thresholds based on the fault type, such as "three consecutive heartbeat timeouts" or "CPU utilization exceeding 90%"; the data collection specifications indicate which register types and memory data ranges need to be collected by the vehicle at the time of triggering, thereby acquiring diagnostic data on demand. For example, for intermittent faults, the cloud can set a lower trigger threshold to increase the capture probability; for high-frequency faults, a higher trigger threshold can be set to reduce redundant data reporting, achieving efficient utilization of diagnostic resources.

[0143] In some embodiments, when a vehicle contains multiple central domain controller nodes, the cloud sends a subscription instruction to the vehicle, and the vehicle collects and reports fault feature vectors, specifically including:

[0144] Each of the central domain controller nodes is equipped with a private SOVD server, and a public SOVD server provides a unified diagnostic service entry point to the outside world.

[0145] The cloud sends the subscription instruction to the public SOVD server, which then routes the subscription instruction to the private SOVD server on the target central domain controller node based on the target software entity identifier in the subscription instruction.

[0146] The fault acquisition agent on the target central domain controller node responds to the subscription instruction, acquires the fault feature vector, and submits the fault feature vector to the local private SOVD server.

[0147] The private SOVD server transmits the fault feature vector back to the cloud via the public SOVD server.

[0148] The above embodiments achieve unified diagnostic management and efficient routing across domain controllers through a two-tier architecture deploying a public SOVD server and a private SOVD server within a multi-central domain controller node architecture. Specifically, a private SOVD server is deployed on each central domain controller node to handle the diagnostic services for that node, while the public SOVD server provides a unified service entry point. The cloud sends subscription commands to the public SOVD server, which routes them to the private SOVD server on the target node based on the target software entity identifier; fault feature vectors are then transmitted back along the reverse path. For example, in a vehicle containing a driving domain controller and a cockpit domain controller, the cloud only needs to manage the diagnostic subscriptions of the two domain controllers uniformly through the public SOVD server, eliminating the need to interface with two separate diagnostic interfaces and simplifying the design complexity of the cloud diagnostic system.

[0149] In some embodiments, the vehicle terminal includes a central domain controller node and at least one conventional electronic control unit; the cloud sends a subscription instruction to the vehicle terminal, and the vehicle terminal collects and reports fault feature vectors, specifically including:

[0150] When the target software entity of the subscription instruction is located in the traditional electronic control unit, the SOVD2UDS adapter on the central domain controller node converts the subscription instruction from SOVD protocol format to UDS protocol format and sends it to the traditional electronic control unit through the UDS diagnostic service.

[0151] The conventional electronic control unit responds to the subscription command via the UDS protocol, collects fault data, and returns a response message in UDS format;

[0152] The SOVD2UDS adapter encapsulates the UDS-formatted response message into structured data in SOVDJSON format, forming the fault feature vector, and transmits it back to the cloud via the SOVD event channel.

[0153] The above embodiments achieve protocol conversion through the SOVD2UDS adapter, enabling older ECUs that only support the UDS protocol to access the SOVD diagnostic system without any software or hardware modifications, significantly reducing the cost of technology upgrades. Specifically, when the target software entity of the subscription command is located in a traditional ECU, the SOVD2UDS adapter on the central domain controller node converts the SOVD request into a UDS request and sends it to the traditional ECU. The UDS response returned by the traditional ECU is then encapsulated in SOVDJSON format and sent back to the cloud. For example, a vehicle may have both a new central domain controller and a traditional window control ECU (which only supports the UDS protocol). Through this solution, the cloud can use a unified SOVD protocol to perform diagnostic subscriptions and data collection for all ECUs in the vehicle, eliminating the need to develop a separate SOVD protocol stack for traditional ECUs, significantly reducing the integration cost and complexity of the vehicle diagnostic system.

[0154] refer to Figure 3 The diagram shown is an architectural schematic of a centralized agent mode for the main control ECU provided in an embodiment of the present invention. The overall structure is divided into three layers: cloud diagnostic platform, central domain controller, and traditional ECU. The central domain controller is used as the unified agent gateway for SOVD of the whole vehicle to realize unified access to the cloud, hierarchical scheduling of heterogeneous resources on the vehicle side, and compatibility and interoperability of new and old electronic control protocols.

[0155] The top layer is a cloud-based diagnostic platform that issues standardized remote diagnostic and fault subscription requests via the SOVD API (HTTP / REST). All vehicle-to-cloud interaction commands are uniformly relayed through the central domain controller, eliminating the need for separate cloud-based connections to each vehicle controller.

[0156] The central domain controller is the core of the architecture. It integrates the SOVD Public Server, serving as the unified entry point for SOVD across the entire vehicle and the main agent for fault collection. It receives all requests from the cloud and performs unified authentication and routing, connecting downwards to the underlying services via three routes:

[0157] SOVD Private Server (A core): Interacts with in-vehicle application layer software to complete the collection of application logs and business trajectory-type fault data;

[0158] SOVD Private Server (M-core): Designed for real-time operating systems, it collects hard real-time diagnostic data such as low-level hardware registers and real-time fault codes.

[0159] SOVD2UDS Adapter Protocol Converter: Responsible for bidirectional protocol conversion, translating SOVD requests into standard UDS instructions, and encapsulating the UDS data returned by the traditional ECU into SOVD format for return to the upper layer.

[0160] The underlying layer is a traditional ECU without SOVD capability, which only supports the UDS diagnostic protocol for CAN / DOIP transmission. It cannot directly connect to the cloud SOVD interface, and all diagnostic interactions rely on SOVD2UDS Adapter proxy forwarding.

[0161] This centralized agent architecture uses the central domain controller as the only external interface. The cloud only needs to maintain a single vehicle-side communication link. At the same time, it isolates the A-core application, the M-core real-time system, and existing traditional electronic controls, unifies the fault collection process, and greatly simplifies the remote diagnostic interaction logic of the whole vehicle.

[0162] In some embodiments, the method further includes:

[0163] The vehicle-side maintains a dynamic software bill of materials tree in real time. The dynamic software bill of materials tree records the version hash, function entry address table, and dependencies between components for each software component.

[0164] In response to a version change of a software component, the vehicle-side updates the version hash and function entry address table of the corresponding software component in the dynamic software bill of materials tree;

[0165] The vehicle-mounted device synchronizes the updated dynamic software bill of materials tree to the cloud via the SOVD protocol data synchronization interface, so that the software bill of materials stored in the cloud is consistent with the current operating status of the vehicle-mounted device.

[0166] The above embodiments ensure that the cloud always holds software version and function address information consistent with the current operating state of the vehicle by maintaining and synchronizing the dynamic software bill of materials (SBOM) tree in real time on the vehicle side. This provides a reliable data foundation for accurate location and patch generation. Specifically, the dynamic SBOM tree maintained on the vehicle side records the version hash, function entry address table, and dependencies between components for each software component, and automatically updates and synchronizes it to the cloud when a component version changes. For example, when the vehicle upgrades the multimedia library of the cockpit domain controller from v2.1 to v2.2 via OTA, the vehicle side automatically updates the version hash and function entry address table of the multimedia library in the SBOM tree and synchronizes it to the cloud. Subsequently, if a function in the multimedia library fails again, the cloud can perform accurate location and patch generation based on the latest SBOM data, avoiding location errors caused by using outdated SBOM data.

[0167] refer to Figure 4The diagram shown illustrates the overall architecture of a cloud-vehicle collaborative vehicle software differential diagnostic and adaptive hot repair system according to an embodiment of the present invention. It shows the deployment relationship of five layers of hardware and software components: a cloud diagnostic platform, an in-vehicle communication unit, a central domain controller, in-vehicle application software, and a traditional UDS electronic control unit. It also presents cross-layer communication protocols, data interaction links, SOVD diagnostic service layered scheduling logic, and the entire business process of remote subscription-based fault acquisition, cross-core data interaction, SOVD and UDS protocol interoperability, and cloud-based diagnostic analysis and repair distribution. The following sections provide a detailed description of the architecture composition, module functions, and data flow and interaction relationships, layer by layer:

[0168] (1) Top layer: Cloud diagnostic platform layer

[0169] The cloud-based diagnostic platform is the core server for remote vehicle diagnostics, fault analysis, and repair package generation. Externally, it provides an encrypted RESTful interface based on SOVDAPI (HTTP / 2overTLS) and establishes secure two-way communication with the vehicle via a JSON payload. Internally, it comprises four core functional components:

[0170] Subscription Manager: Provides visual subscription configuration capabilities for vehicle maintenance personnel, supporting customized fault subscription rules for specific vehicle application software, central domain controller A / M core resources, traditional ECU DID data, and fault code DTCs; it can configure collection parameters such as trigger thresholds, trace collection depth, register snapshots, and stack capture, generate standardized JSON subscription instructions to be sent to vehicles, and maintain subscription sessions for all vehicles in the network, manage subscription validity and subscription cancellation operations.

[0171] Differential analysis engine: Receives fault trace logs, register snapshots, process running data, and UDS fault information transmitted from the vehicle, compares them with the vehicle's historical baseline software version running data, automatically identifies newly added abnormal function calls, memory out-of-bounds errors, timing anomalies, and software / hardware DTC deviations, and outputs accurate software fault differential location results, distinguishing between occasional transient faults and permanent underlying defects.

[0172] Patch Generator: Based on the fault location conclusions output by the differential analysis engine, it matches the corresponding software version source code / binary resources and automatically generates a lightweight hotfix differential patch package. The patch package carries the target deployment kernel (A core / M core), target ECU identifier, checksum, and hotfix execution permission configuration.

[0173] Repair decision engine: Makes distribution decisions based on comprehensive factors such as fault severity, vehicle operating conditions, patch resource usage, and overall vehicle safety constraints; automatically issues overheat repair patches for minor non-safety-related faults, and only pushes fault alarms for high-safety-level faults such as power and braking, prohibiting remote online hot repair to ensure overall vehicle functional safety.

[0174] (2) Transmission layer: vehicle-mounted 4G / 5G / Wi-Fi module

[0175] As a wireless communication relay hardware unit between the cloud and the vehicle's central domain controller, it receives encrypted SOVD request messages from the cloud and forwards the data to the central domain controller via the vehicle's Ethernet wired link. Simultaneously, it receives fault-collected JSON data and software operation logs from the central domain controller, encapsulates and encrypts them, and uploads them to the cloud diagnostic platform. The module carries TLS encrypted message pass-through throughout the process, achieving vehicle-cloud data isolation transmission, and provides network disconnection caching and link reconnection retry capabilities to prevent the loss of fault-collected data.

[0176] (3) Core hardware layer: Central domain controller (A-core + M-core heterogeneous architecture)

[0177] The central domain controller is the core carrier of the vehicle-side diagnostic service of this invention. It adopts a heterogeneous dual-core architecture, and its internal software is divided into two major software layers: the SOVDPpublicServer unified external entry layer and the underlying private service / protocol adaptation layer. The sub-modules are decoupled and have distinct functions. Internal data distribution is completed through internal APIs and in-vehicle Ethernet. Specifically, it includes:

[0178] SOVDPublicServer (Unified External Entry Point)

[0179] As the sole gateway for receiving SOVD requests from the cloud on the vehicle side, it integrates three fundamental support modules to uniformly complete access authentication, message encoding / decoding, and communication stack management, including:

[0180] SOVDServlet library: as mentioned above Figure 2 The corresponding core functional components are responsible for parsing the URL path of the HTTP request sent from the cloud and routing the request to the corresponding processing Handler; completing the JSON request body parsing and response body serialization; and realizing business resource location, mapping the cloud request to the diagnostic resources corresponding to the A core, M core or protocol adapter inside the central domain controller. It has built-in fault collection agent, security verification and multi-type diagnostic interface processing logic.

[0181] Security Manager: Enables end-to-end security control, performs cloud access identity verification based on OAuth2.0, configures role-based hierarchical access control, and records all remote access audit logs; in conjunction with TLS communication encryption, it intercepts unauthorized and illegally tampered diagnostic subscription requests, ensuring that in-vehicle software resources are not accessed illegally.

[0182] Communication Manager: Built-in standardized HTTP / 2 protocol stack, it carries the management of long-connection and asynchronous event reporting channels of SOVDAPI between vehicle and cloud, and is responsible for request message sending and receiving, connection maintenance, and flow control, providing underlying communication capability support for Servlet library.

[0183] After the subscription / diagnosis request sent from the cloud is processed and verified by the PublicServer, it will be sent to the three types of underlying private service components in three ways according to the type of accessed resource: A-core private service, M-core private service, and SOVD2UDS protocol adapter.

[0184] The underlying private services and protocol adaptation components include:

[0185] SOVDPrivateServer (A core) runs on the application operating system A core and has a built-in fault collection agent that is specifically designed to interface with upper-layer vehicle application software. It receives application-layer fault subscription commands forwarded by PublicServer and completes application process log capture, function trace collection, runtime memory snapshot, and program stack capture. The collected raw fault data is sent back to the upper-layer SOVDPublicServer through the internal API, encapsulated into a standard JSON message, and then uploaded to the cloud.

[0186] SOVDPrivateServer (M-core) runs on the real-time operating system M-core, focusing on underlying hardware and driver-related diagnostic capabilities. It supports hardware DTC fault code reading and writing, underlying register data, and real-time control cycle data acquisition. For subscription requests to hard real-time control resources such as power and chassis, the M-core's private service completes non-blocking high-speed data acquisition, ensuring that real-time performance is not interfered with by application layer tasks.

[0187] The SOVD2UDSAdapter protocol converter, acting as a heterogeneous protocol interoperability middleware, enables bidirectional conversion between the SOVD diagnostic protocol and the traditional vehicle UDS diagnostic protocol: after receiving the subscription command for the traditional ECU, it maps the SOVDJSON parameters to ISO14229 standard DID and DTC to read the UDS service; it sends UDS diagnostic requests to the traditional ECU through the CAN / DOIP vehicle bus, and reverse-encapsulates the original UDS fault data returned by the ECU into the SOVD standard JSON format, and sends it back to the PublicServer for unified cloud upload, realizing a cloud SOVD interface compatible with new domain control software and existing traditional electronic control units.

[0188] (4) Low-level execution layer: vehicle application software & traditional ECU

[0189] The application software is deployed within the application operating system of the central domain controller A core, exposing internal APIs to the A core SOVD private service, allowing the fault collection agent to read process running status, business logs, and function call chains, and respond to cloud-based subscription-based fault collection needs.

[0190] Traditional ECUs are existing distributed electronic control units that only support the UDS diagnostic protocol transmitted via CAN / DOIP. They cannot directly parse SOVDHTTP messages. They rely on the SOVD2UDS adapter to complete the protocol translation, receive fault reading commands, and feed back hardware fault codes and raw sensor data.

[0191] Example embodiments have been disclosed herein, and while specific terminology has been used, it is for illustrative purposes only and should be construed as such, and is not intended to be limiting. In some instances, it will be apparent to those skilled in the art that features, characteristics, and / or elements described in conjunction with particular embodiments may be used alone, or in combination with features, characteristics, and / or elements described in conjunction with other embodiments, unless otherwise expressly indicated. Therefore, those skilled in the art will understand that various changes in form and detail may be made without departing from the scope of the invention as set forth in the appended claims.

Claims

1. A method for differential diagnosis and adaptive thermal repair of vehicle software, characterized in that, include: The cloud sends a subscription command to the vehicle to subscribe to the running status of the target software entity; In response to the target software entity's operating state meeting a preset triggering condition, the vehicle terminal collects and reports a fault feature vector containing a program counter value. The cloud platform locates the target function to be repaired in the software bill of materials based on the program counter value, and generates a function-level differential patch that contains only the correction code for the target function. The vehicle receives the function-level differential patch and atomically redirects the original entry address of the target function in memory to the address of the correction code corresponding to the function-level differential patch, so as to complete the hot repair without interrupting the process.

2. The method according to claim 1, characterized in that, The subscription instruction includes a trigger condition expression, which defines the operating state conditions for triggering fault acquisition; the vehicle-side acquisition and reporting of a fault feature vector containing a program counter value specifically includes: The SOVDServlet library on the vehicle side parses the trigger condition expression in the subscription instruction, and when it determines that the running status of the target software entity satisfies the trigger condition expression, it triggers the fault collection agent to perform the collection operation. The fault acquisition agent obtains the memory mapping information of the process in which the target software entity is located, as well as a register snapshot of at least one processor core of the process at the time of the fault by calling the underlying interface of the operating system. The register snapshot includes at least the program counter value, the stack pointer value, and the link register value. The fault acquisition agent encapsulates the memory mapping information and the register snapshot into structured data with a predetermined JSON format to form a fault feature vector; The fault acquisition agent transmits the fault feature vector back to the cloud via the event channel defined by the SOVD protocol.

3. The method according to claim 1, characterized in that, The cloud-based system locates the target function to be repaired in the software bill of materials based on the program counter value, and generates a function-level differential patch containing only the correction code for the target function, specifically including: The cloud platform parses the program counter value from the fault feature vector; The cloud obtains the software version identifier currently running on the vehicle and retrieves a software bill of materials that matches the software version identifier from local storage. The software bill of materials includes version hashes of each software component and a memory address mapping table of function entry addresses. The cloud platform performs reverse mapping in the memory address mapping table based on the program counter value to locate the erroneous target function and its original entry address. The cloud extracts the old version binary segment of the target function from the original binary file corresponding to the software version identifier, and extracts the new version binary segment of the target function from the repaired new version binary file; The cloud platform runs a binary difference algorithm on the old version binary segment and the new version binary segment to generate the function-level difference patch that only contains the differences.

4. The method according to claim 1, characterized in that, The vehicle-side atomically redirects the original entry address of the target function in memory to the address of the correction code corresponding to the function-level differential patch, so as to complete the hot patch without interrupting the process. Specifically, this includes: The vehicle-side hotfix manager receives and parses the function-level differential patch, extracting the corrected function binary code from it; The hotfix manager loads the corrected function binary code into an anonymous memory page with read and execute permissions allocated via mmap through a memory mapping system call. The hotfix manager utilizes the dynamic linking feature of the operating system to modify the global offset table or process link table of the process containing the target software entity in an atomic manner, replacing the original entry address of the target function with the starting address of the anonymous memory page in one go, so that subsequent calls to the target function can directly jump to the corrected function binary code.

5. The method according to claim 4, characterized in that, Before the hotfix manager loads the corrected function binary into the anonymous memory page, the method further includes: The hotfix manager extracts a pre-execution verification list from the function-level differential patch. The pre-execution verification list contains the hash value of the entry address of the target function during the compilation stage. The hotfix manager reads the current runtime entry address of the target function in the process where the target software entity is located, and calculates the hash value of the runtime entry address to obtain the runtime hash value; The hotfix manager compares the runtime hash value with the entry address hash value in the execution pre-verification list; If the two match, the verification is deemed successful, and the operation of loading the corrected function binary code into the anonymous memory page continues. If the two are inconsistent, the verification is deemed to have failed, the function-level differential patch is rejected, and the verification failure feedback information is reported to the cloud.

6. The method according to claim 4, characterized in that, Before the hotfix manager modifies the global offset table or the process link table in an atomic manner, the following is also included: The hotfix manager backs up the original entry address of the target function to non-volatile memory and sets the hotfix status flag. After the function-level differential patch is applied, if the process containing the target software entity exits abnormally, the bootloader will read the hotfix status flag bit when the system starts up again. If the hotfix status flag bit indicates that there is an incomplete rollback requirement, the corresponding entry in the global offset table or the process link table will be automatically restored to the original entry address based on the original entry address backed up in the non-volatile memory.

7. The method according to claim 4, characterized in that, After the vehicle receives the function-level differential patch, and before redirecting the original entry address of the target function, the method further includes: The vehicle-side hot repair manager queries the pre-stored repair strategy configuration table, determines the ASIL level of the target software entity based on its identifier, and obtains the repair execution constraints corresponding to the ASIL level. The thermal repair manager subscribes to and obtains the current vehicle's operating status parameters in real time through the SOVD application programming interface. The hot repair manager determines whether the current vehicle's operating status parameters meet the repair execution constraints. If the conditions are met, the hotfix manager allows the operation of redirecting the original entry address of the target function to the address where the fix code is located to continue; If the conditions are not met, the hotfix manager will add the current repair task to the delayed execution queue and continuously monitor the current vehicle's operating status parameters through the SOVD application programming interface until the current vehicle's operating status parameters meet the repair execution constraints. Then, the hotfix manager will automatically wake up the repair task from the delayed execution queue and execute the redirection operation. The repair strategy configuration table includes at least the following repair execution constraints preset for software components of different ASIL levels: For software components at ASIL-D level, the repair execution constraint is that the vehicle speed is zero and the gear is in park. For ASIL-B level software components, the repair execution constraint is that the memory bandwidth utilization is lower than a preset threshold during the execution of the redirection operation; For software components at the quality management level, the repair execution constraints are unlimited.

8. The method according to claim 1, characterized in that, The cloud sends subscription instructions to the vehicle through the extended SOVD application programming interface POST / diagnostics / trace / subscribe. The subscription instructions include: The identifier of the target software entity is used to specify the diagnostic object to be monitored; The trigger condition expression is used to define the operating state conditions that trigger fault acquisition; The data specifications for the fault feature vector are used to indicate the register type and memory data range that the vehicle terminal needs to collect when triggered.

9. The method according to claim 1, characterized in that, When a vehicle contains multiple central domain controller nodes, the cloud sends a subscription command to the vehicle, and the vehicle collects and reports fault feature vectors, specifically including: Each of the central domain controller nodes is equipped with a private SOVD server, and a public SOVD server provides a unified diagnostic service entry point to the outside world. The cloud sends the subscription instruction to the public SOVD server, which then routes the subscription instruction to the private SOVD server on the target central domain controller node based on the target software entity identifier in the subscription instruction. The fault acquisition agent on the target central domain controller node responds to the subscription instruction, acquires the fault feature vector, and submits the fault feature vector to the local private SOVD server. The private SOVD server transmits the fault feature vector back to the cloud via the public SOVD server.

10. The method according to claim 1, characterized in that, The method further includes: The vehicle-side maintains a dynamic software bill of materials tree in real time. The dynamic software bill of materials tree records the version hash, function entry address table, and dependencies between components for each software component. In response to a version change of a software component, the vehicle-side updates the version hash and function entry address table of the corresponding software component in the dynamic software bill of materials tree; The vehicle-mounted device synchronizes the updated dynamic software bill of materials tree to the cloud via the SOVD protocol data synchronization interface, so that the software bill of materials stored in the cloud is consistent with the current operating status of the vehicle-mounted device.