Object Code Hot Update System for Safe Patching
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Conventional hot update systems face challenges such as initialization of data structures, unnecessary identification of functions to be updated, and safety concerns when modifying or replacing functions being executed, especially when applying patches that require additional information from upstream analysis, leading to instability or crashes during software updates.
Innovation Solution
The object code hot update system analyzes and modifies both pre-patch and post-patch code to generate a hot update by identifying differences, providing additional initialization functionality, and optimizing patch modifications to minimize unnecessary changes, ensuring safe and efficient updates without restarting the system.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If conventional hot update systems apply patches to running programs, then software updates can be applied without restarting, but system stability deteriorates due to crashes and instability
Solution Approach 1:
The system performs preliminary analysis of the patch against the running program state before applying updates. It identifies functions that are currently executing and prepares update strategies that avoid modifying these functions during execution, thereby preventing crashes while enabling continuous operation
Solution Approach 2:
The update application process is made dynamic by continuously monitoring which functions are currently being executed and adapting the update strategy in real-time. Functions that are actively running are excluded from immediate updates, while idle functions are updated safely, allowing the system to maintain stability during hot updates
2Adaptability or versatility
If the system identifies all functions for potential updates, then comprehensive updates can be applied, but unnecessary modifications increase complexity and risk
Solution Approach 1:
The system extracts and identifies only the necessary functions that require updates by analyzing the patch content and comparing it with the running program. Functions that are not affected by the patch or are currently executing are excluded from the update set, reducing complexity while maintaining comprehensive coverage of necessary updates
Solution Approach 2:
Instead of updating all functions, the system applies partial updates only to the specific functions that are both affected by the patch and not currently executing. This selective approach reduces update complexity and risk while ensuring all necessary updates are applied
3Productivity
If the system modifies functions that are currently being executed, then updates can be applied immediately, but safety deteriorates causing potential crashes
Solution Approach 1:
Before applying updates, the system performs preliminary identification of functions that are currently executing. This preliminary analysis allows the system to plan update application timing, ensuring that no function is modified while it is being executed, thereby maintaining safety without significantly delaying updates
4Adaptability or versatility
If additional data structures are added in post-patch code, then new functionality is enabled, but initialization complexity increases causing update failures
Solution Approach 1:
The system performs preliminary analysis to identify all data structures that are added or modified by the patch. Before applying the update, it prepares initialization code that will properly set up these new data structures, ensuring that the running program can accommodate the new functionality without initialization errors
Data Source
AI summary
An object code hot update system generates hot updates for patching running programs by analyzing upstream post-patch code, augmenting the upstream post-patch code to provide augmented post-patch code with additional initialization functionality. The system further provides techniques to identify a candidate extra-change site in upstream post-patch code and modify the upstream post-patch code to generate a hot update.