Reversal update data generation

Abstract

Managing data in a computing device is disclosed, including generating a reverse delta update during an application of a forward delta update. The method includes the operations of applying forward update data to an original data object to generate an updated data object from the original data object, and generating reverse update data during the application, the reverse update data configured to reverse the effects of the forward update data and recover the original data object from the updated data object.

Description

Background Technology

[0001] Computers frequently receive data updates from the cloud during their normal use. In implementation, a data update is intended to be applied to at least one specific data object within the computer. A data update includes forward update data used to perform a forward update on the original data object. Forward update data includes data to be inserted into the original data object, as well as instructions for deleting, inserting, and / or replacing existing data in the original data object to produce an updated data object. Reversing this update can be very cumbersome and computationally intensive. Summary of the Invention

[0002] The described techniques provide implementations of systems and methods for data object recovery. More specifically, the described techniques provide implementations of systems and methods for reversing data updates.

[0003] A method for managing data in a computing device is disclosed. The method includes the following operations: applying forward update data to an original data object to generate an updated data object from the original data object; generating reverse update data during the application, the reverse update data being configured to reverse the effects of the forward update data; and restoring the original data object from the updated data object.

[0004] This summary is provided to introduce some concepts in a simplified form, which will be further described in the detailed implementation below. This summary is not intended to identify key or essential features of the claimed subject matter, nor is it intended to limit the scope of the claimed subject matter.

[0005] This article also describes and lists other implementations. Attached Figure Description

[0006] Figure 1 An example system for restoring an updated data object to its original state is shown.

[0007] Figure 2 An example system for generating reverse update data is shown.

[0008] Figure 3 Another example system for generating reverse update data is shown.

[0009] Figure 4 An example system for restoring an updated data object to its original state is shown.

[0010] Figure 5 A flowchart is shown for an example operation used to generate reverse update data.

[0011] Figure 6A flowchart is shown for an example operation to apply reversed updated data.

[0012] Figure 7 An example computing device is shown that is used to implement the features and operations of the described technology. Detailed Implementation

[0013] Systems and methods for recovering the original data object from an updated data object are disclosed. A data object is a discrete collection of data elements that form discrete conceptual units and can be retrieved and / or manipulated. A data object may include one or more data structures, such as variables, functions, data structures, tables, columns, and classes. Data objects may be stored in contiguous physical storage locations or may be referenced by referencing elements at different locations in memory where the data elements are stored. Data objects may contain instructional program code and / or non-instructional data (collectively referred to as "data"). Data objects may be updated individually or collectively, possibly during system updates and / or through direct user modifications.

[0014] In conventional systems, reversing an update to a data object can be a difficult and computationally costly task. For example, restoring an original data object to which a forward update has been applied may require storing both the updated and original versions of the data object. It may also require storing changes made to the updated data object itself, as well as subsequent computationally expensive operations to determine how to perform the reversal to restore the previous data object. Furthermore, if data is removed from the data object during the update, the deleted data may be permanently removed from the local computer's device repository. Retrieving the deleted data may require a new download and / or installation of the original data object to restore it after the forward update. The original data object may be unavailable at that time, which could impair critical computing functions. Additionally, in systems where both forward and reverse update data are stored and sent, unnecessary computational, storage, and network resources may be consumed.

[0015] According to the currently described technique, during a forward update, a reversal update generator can create reversal update data substantially simultaneously with the forward update data. This reversal update data is configured to reverse the effects of the forward update data on the original data object. The reversal update data contains reversal instructions (relative to the forward update instructions) and also includes any data deleted from the original data object during the forward update. The reversal update data may also contain instructions to delete any data inserted during the forward update. The reversal update data, primarily containing instructions and data changed from the data object during the forward update, can be 20 to 100 times smaller than the original data object, thus saving storage while still providing reversal update functionality. Furthermore, the current reversal update data provides a direct roadmap for recovering the original data object from the updated data object, rather than a computationally intensive interpretation of performing reversal operations during the reversal update. Generating reversal update data as a forward update applied to the original data object saves storage space, memory, and processing power, and preserves the computational infrastructure after potentially defective and / or otherwise irreversible forward updates are applied.

[0016] Figure 1 An example system 100 for restoring an updated data object to its original state is illustrated. The implementation of system 100 includes a cloud system 102, a computer system 104, an updater 108, a reverse update generator 190, and a data repository 160. The data repository 160 may store one or more of forward update data 120, reverse update data 140, the original data object 170, and the updated data object 180. Arrows 1, 2, and 3 are shown and indicate the transfer and / or use of data.

[0017] Cloud system 102 is a processor and memory system capable of receiving, storing, processing, and transmitting data. Computer system 104 is a processor and memory system capable of transmitting, receiving, storing, and processing data. Computer system 104 is communicatively coupled to cloud system 102. In this implementation, forward update data 120 is transmitted from cloud system 102 to computer system 104, as indicated by arrow 1 in the figure. An updater in computer system 104 receives the forward update data 120. Computer system 104 includes a processor and memory system configured to execute programs, including an updater 108 and a reverse update generator 190, and stores data in a data repository 160 in memory, including one or more of forward update data 120, reverse update data 140, original data objects 170, and updated data objects 180.

[0018] Updater 108 is a program capable of modifying data within a data object. The original data object 170 is a data object that has not yet been manipulated in a forward update, or a data object that has been recovered from a previous reverse data update. The updated data object 180 is a data object obtained by manipulating the original data object 170 in a forward update. Figure 1 As seen, updater 108 can perform a forward update using forward update data 120, which generates an updated data object 180 from the original data object 170, as seen at arrow 2. Updater 108 can perform a reverse update using reverse update data 140, in order to restore the original data object 170 from the updated data object 180, as seen at arrow 3.

[0019] In various implementations, computer system 104 includes a reverse update generator. Reverse update generator 190 is a routine that tracks forward update instructions and data, and creates corresponding reverse update instructions and data to generate reverse update data 140 when a forward update is applied. Reverse update data 140 is data used to perform a reverse update on the updated data object 180. The reverse update data 140 may include reverse instructions relative to the forward update data 120, and may also include data deleted from the original data object 170 during the forward update. Reverse update data 140 may be stored in discrete data objects (such as files or non-file binaries). For example, the data may be a non-file binary abstraction without a discrete file identifier. Files or non-file binaries may be dedicated to reversing update data for the purpose of reversing a specific forward update applied to the original data object. Example data objects may include, but are not limited to, binary and / or non-binary databases and registries, BLOBs (Binary Large Objects), and non-file binary abstractions.

[0020] Reverse update data 140 may also include various data associations, such as associations between one or more of the original data object 170, the updated data object 180, the updater 108, the reverse update generator 190, and the forward update data 120. Reverse update data 140 may also include version data of one or more of the original data object 170 and the updated data object 180, and / or aggregated version or release data associated with a broader update containing forward update data 120. For example, a generic update release containing incremental data elements may be applied, which may be specific to a particular data object, and each incremental data update element may be associated with its own identifier relative to the overall release or package identifier. Examples of release or version identifier levels may include one or more of the following: operating system major version, operating system minor version, package major version, and package minor version. Associated and / or version data may be included in the identifiers of reverse update data 140 (e.g., headers, filenames, directory addresses, pointers, etc.). Data used to store referential associated and / or version data may include implementation-specific structures. For example, in one implementation, the association and / or version data is an Extensible Markup Language (XML) file, or part of an XML file, which specifies metadata that references the relative directory address and filename or other descriptors or tags of the forward update data 120 and / or reverse update data 140. In another implementation, a hierarchical data file (e.g., a JSON or XML file) can be used to specify how a system updating with forward update data 120 or reverse update data 140 can utilize the set of forward update data 120 or reverse update data 140 in a particular generic update release.

[0021] although Figure 1 Data repository 160 is depicted as containing forward update data 120, reverse update data 140, original data object 170, and updated data object 180; however, data repository 160 may contain only some of these elements at any given time. For example, during a forward update, original data object 170 may be manipulated to retain or not retain a buffered copy of original data object 170. That is, it is envisioned that during a forward update, original data object 170 is manipulated and becomes an implementation of updated data object 180. When the forward update is complete, forward update data 120 and original data object 170 may be redundant for the operation and may be deleted. Updated data object 180 may be stored concurrently with reverse update data 140.

[0022] Furthermore, in an implementation where reverse update data 140 is generated by reverse update generator 190 during forward update, reverse update data 140 may not exist in data repository 160 before the forward update. After the forward update, data repository 160 may store both reverse update data 140 and the updated data object 180, but not forward update data 120 or the original data object 170. After updater 108 implements the reverse update, data repository 160 may store the original data object 170, but not forward update data 120, reverse update data 140, or the updated data object 180. Additionally, if a subsequent forward update is applied to the updated data object 180, reverse update data 140 can be deleted. Alternatively, reverse update data 140 can track changes and generate reverse data across multiple updates, providing reversibility for any forward update in the history of forward updates applied to the original data object 170. Figure 1 As shown, data repository 160 illustrates example relationships and orders, and does not necessarily represent relationships and orders stored in data repository 160 at any particular time.

[0023] It should also be understood that, although computers and storage Figure 1 While presented as a single system, a distributed system with one or more of distributed processing and distributed storage can also be considered. For example, some or all of the data disclosed herein may be stored and / or processed in a distributed manner across multiple storage devices on a single computing device, in a distributed system of computing devices or servers and / or network systems, in edge devices and communicatively coupled cloud servers, or among one or more communicatively coupled client devices, edge servers / devices, and cloud servers / devices / services. The data and packets disclosed herein may be addressable and may be distributed in any way among computing devices, whether shared or not, whether consistently communicatively coupled, intermittently or periodically communicatively connected, etc.

[0024] Updater 108 executes instructions represented by data in forward update data 120 (e.g., forward update instructions) and / or reverse update data 140 (e.g., reverse update instructions). These instructions may include one or more of insertion, deletion, replacement, reordering, shifting, and other data manipulations (e.g., multiplication, addition, allocation). More complex instructions may be considered, including compiler-level instructions whose reversal is not necessarily a simple reversal (e.g., not necessarily as simple as forward deletion and its corresponding reverse insertion). The data operated on by updater 108 may include one or more of data stored in the original data object 170, data stored in the updated data object 180, data provided by forward update data 120, and / or data provided / restored by reverse update data 140. This data can be written, deleted, or replaced at any level (e.g., bit level, byte level, object level, file level, etc.). Data stored in forward update data 120 and to be inserted into the original data object 170 can be considered as added data. Data stored in reverse update data 140 that is to be inserted (or re-inserted from the perspective of the original data object 170) into updated data object 180 can be considered as restorative data.

[0025] Example instructions for the reverse update generator 190 may include tracking and reversing changes during a forward update of the RTM binary. For example, when updater 108 inserts bytes of added data from forward update data 120 into the original data object 170 RTM binary (to form the updated data object 180 RTM binary) during a forward update, reverse update generator 190 saves the starting address of the inserted data, the size of the inserted data, and deletion commands in reverse update data 140. When this reversal instruction is executed, it removes the data inserted into the RTM binary by updater 108 during the forward update. Another example may include a reversal instruction for deletion operations. Updater 108 may delete bytes from the RTM binary based on the data in forward update data 120 during a forward update. Reversal update generator 190 may save the starting address, size, and data (e.g., restorative data) of the bytes or other data increments deleted during the forward update into reverse update data 140. When the reversal instruction is executed, the data deleted during the forward update is restored to generate the original data object 170.

[0026] Instructions in reversing update data 140 can be effective reversals of instructions in forward update data 120, and can also be configured to be executed in reverse order. That is, the reversal instruction of the first operation in forward update data 120 can be the last instruction configured to be executed in reversing update data 140. Correspondingly, the reversal instruction of the last operation to be executed in forward update data 120 can be the first operation to be executed in reversing update data 140. Executing reversing update instructions in the reverse order of the corresponding forward update instructions helps ensure that the address where data is written and the address where data is removed are consistent when the instructions are executed. In cases where this ordering is not required (e.g., when the data locations / addresses operated on by different operations in reversing and forward updates do not affect each other), other implementations can be considered.

[0027] Updater 108 can also perform operations and updates in compiler mode. For example, compiler-mode updates can be optimized for compiler execution to efficiently render the update. Compiler-level instructions may be more complex than basic instructions, so an effective reversal instruction is not translated one-to-one into the basic instruction reversal of the forward instruction. Although example updater 108 is disclosed, it should be understood that components, subcomponents, operations, and suboperations can be characterized differently or similarly. For example, compiler optimizations for forward update data 120 or reverse update data 140 may include address translation. Such a particular translation operation can be reversed in a reverse update by binary disassembly, then address translation, and then reassembly.

[0028] Figure 2 An example system 200 for generating reverse update data is shown. The implementation of system 200 includes an original data object 270, an updated data object 280, forward update data 220, a forward insert instruction 252 with associated added data 256, a forward delete instruction 254, a reverse update generator 290, a reverse delete instruction 262, and a reverse insert instruction 264 with associated restorative data 266. Dashed arrows are shown to illustrate the relative order of the corresponding structures and instructions in each of the forward update data 220 and the reverse update data 240.

[0029] In this implementation, forward update data 220 is applied by the updater to the original data object 270 to form an updated data object 280. Forward update data 220 includes a forward insert instruction 252 and a forward delete instruction 254, whereby the forward insert instruction 252 has associated added data 256. When the forward insert instruction 252 is executed, the added data 256 is inserted into the original data object 270 to begin forming the updated data object 280. In parallel (or substantially parallel or substantially simultaneous), the reverse update generator 290 stores the corresponding reverse delete instruction 262 in the reverse update data 240. The reverse delete instruction 262 may be stored with information indicating that it should be executed in the reverse order of the forward insert instruction 252, relative to the other instructions. After the forward insert instruction 252 is executed and the added data 256 is added to the original data object 270, the updater proceeds to the next instruction, the forward delete instruction 254. Forward delete instruction 254 causes the updater to delete elements from the modified original data object 270. In parallel, reverse update generator 290 can generate corresponding reverse insert instructions 264, which have associated deleted recoverable data 266 that was deleted in the past, present, or future by executing forward delete instruction 254. Reverse insert instructions 264 are executed in the reverse order of forward delete instruction 254.

[0030] In the implementation, any data deleted from the original data object 270 during a forward update can be buffered or directly saved to the reverse update data 240 before being deleted from the original data object 270. When the term "inparallel" is used herein, it can mean one or more of the following: concurrently, while, simultaneously, during, concurrently, immediately before, substantially near to the time, just before, immediately before. For example, the reverse update generator 290 can read instructions from the forward update data 220 and, before executing the instructions from the forward update data 220, determine whether data from the original data object 270 will be deleted and save the data to be deleted as restorative data in the reverse update data 240. Furthermore, the reverse update generator 290 can generate a reverse update instruction corresponding to the loaded forward update instruction, which will be stored in the reverse update data 240 before, during, or after the forward instruction is executed. In another implementation, the original data object 270 can be buffered during the forward update, thus providing flexibility in the execution of the reverse instruction, allowing portions of the data deleted from the original data object 270 to be stored in the reverse update data 240 during the forward update, even after the original data from the original data object 270 has been deleted during the forward update. This implementation allows the reverse update generator 290 to have flexibility in the timing of the generation of the reverse update data 240 relative to the timing of the execution of the corresponding forward update data 220, and may even allow restorative data 266 to be saved after data has been deleted from the instance of the original data object 270 to which the forward update was applied.

[0031] As shown by the dashed lines and crossed arrows, forward insertion instruction 252 corresponds to reverse deletion instruction 262, and forward deletion instruction 254 corresponds to reverse insertion instruction 264. The corresponding forward and reverse instructions are shown as being able to be executed in reverse order. This reduces the possibility of data being erroneously overwritten if the relative address of the data is affected by successive steps. The reverse update generator 290 can operate on an instruction-by-instruction basis, updating the reverse update data 240 with each instruction to be executed from the forward update data 220. In different implementations, the reverse update generator 290 can lead the updater several steps ahead during the execution of the forward update.

[0032] Figure 3 Another example system 300 for generating reverse update data is shown. The implementation of system 300 includes an updater 308, a reverse update generator 390, forward update data 320 including added data 322 and forward update instructions 324, an original data object 370 including a data sequence 372, reverse update data 340 including restorative data 342 and reverse update instructions 344, and an updated data object 380 including an updated data sequence 382.

[0033] During a forward update, updater 308 can apply forward update data to the original data object 370. The original data object 370 includes a data sequence 372, presented as sequences A, B1, B2, and B3. Forward update data 320 includes a forward update instruction marked F1, which replaces element B2 of data sequence 372 with added data 322 representing elements B7 and B8 of the sequence. Before, during, or after updater 308 executes forward update instruction 324, reverse update generator 390 generates reverse update data 340 corresponding to forward update data 320. Reverse update instruction 344 corresponds to forward update instruction 324 and is the reverse of forward update instruction 324. As seen, reverse update instruction 344 replaces elements B7 and B8 of added data 322 in the updated data object 380 with restorative data 342 (B2), the corresponding data that was replaced during the forward update of the original data object 370. The updater 308 applies forward update data 320 to the original data object 370 to generate an updated data object 380. After the forward update instruction 324 is applied, the updated data object 380 includes an updated data sequence 382, ​​represented as sequence A, B1, B7, B8, B3.

[0034] This system allows for the generation of reverse update data while applying forward update data 320 to the original data object 370. It is understood that if more than one forward instruction is presented, the reverse update generator 390 can present corresponding reverse instructions that will be applied in the reverse order of the corresponding forward instructions. This allows the forward update data to be loaded only once for the purpose of both implementing the forward update and generating the reverse update data 140. Although the instructions presented for illustrative purposes are replacement instructions, these replacement instructions may include one or more more basic instructions, such as insertion, deletion, and shift. In these instances, each basic instruction step may need to be reversed relative to the corresponding forward update step in the reverse update data and placed in the reverse order, wherein any intermediate deleted data from the original data object 370 is saved to the reverse update data 340 as restorative data 342.

[0035] Figure 4 An example system 400 for restoring an updated data object to its original state is shown. The implementation of system 400 includes an updater 408, reverse update data 440 including restorative data 442 and reverse update instructions 444, an updated data object 480 including an update data sequence 482, and an original data object 470 including a data sequence 472.

[0036] Updater 408 applies reverse update data 440 to the updated data object 480 to generate a raw data object 470. This may involve applying a reverse update instruction 444 to the updated data object 480 to remove forward update data from the updated data object 480 and insert restorative data 442 into the updated data object. In this implementation, the reverse update instruction 444 (labeled R1) instructs updater 408 to replace B7 and B8 of the updated data sequence 482 with B2 of the restorative data 442. The updated data sequence 482 in this implementation is A, B1, B7, B8, B3. The resulting raw data object 470 includes the data sequence 472 of A, B1, B2, B3. The reverse update instruction 444 and other reverse update instructions stored in the reverse update data 440 can be valid reverses and can be executed in the reverse order of the corresponding forward update instructions previously applied to the original data object 470 that existed before the updater 408 applied a forward update to the original data object 470 to generate the updated data object 480. Although the presented instructions are substitution instructions, these substitution instructions can include one or more more basic operations such as insertion, deletion, transformation, and shift. More complex instructions, such as compiler-level instructions, can be considered, for which a valid reverse instruction is not converted one-to-one to the basic instruction reverse of a forward instruction.

[0037] Figure 5 A flowchart of an example operation 500 for generating reverse update data is shown. A receiving operation 502 receives forward update data. In the implementation, the computing device may receive the forward update data from a network (e.g., a cloud network). This forward update data may contain instructions to apply the forward update to the original data object.

[0038] Operation 504 applies a forward update to the original data object to create an updated data object. A computer system may include an updater that updates data objects. This updater can apply a forward update to the original data object to generate an updated data object. Forward-updating data may include one or more instructions, such as deletion, insertion, shift, replacement, reordering, and one or more other data manipulation instructions (e.g., multiplication, addition, assignment).

[0039] While forward update data is applied using operation 504, generation operation 506 generates reverse update data. In the implementation, when the updater uses forward update data to perform a forward update, the reverse update generator generates corresponding reverse update data that can reverse the effects of the corresponding forward update. Reverse update data can include any data deleted from the original data object, as well as instructions to reverse the effects of that forward update.

[0040] Instructions included in reverse update data can be the reverse of instructions executed from forward upload data. Reverse instructions in reverse update data can be configured to be applied in the reverse order relative to their corresponding forward update instructions. This may be to properly undo instructions and data manipulations executed from forward update data. Reverse ordering may be helpful if instructions executed earlier from forward update data correspond to instructions executed later from forward update data (and correspondingly, if earlier reverse instructions correspond to later reverse instructions).

[0041] When forward update data is applied, the operation of generating reverse update data can occur during the forward update and can be completed simultaneously with the forward update. When the term "in parallel" is used herein, it can mean one or more of the following: simultaneously, during, while, concurrently, immediately before, successively, substantially near to the time, just before, immediately before. For example, a reverse update generator can read instructions from the forward update data and, before executing the instructions from the forward update data, determine whether data from the original data object will be deleted and store the data to be deleted as restorative data in the reverse update data. Furthermore, the reverse update generator can generate reverse update instructions corresponding to the loaded forward update instructions, which will be stored in the reverse update data before, during, or after the execution of the forward instructions.

[0042] Reverse update data can be written to specific discrete data objects (such as files) by a reverse update generator. The reverse update generator can store associated data within the reverse update data to associate the reverse update data with data objects. For example, this associated data can be configured to associate the reverse update data with one or more of the forward update data, the original data object, and the updated data object. This associated data can include elements that serve as identifiers for the reverse update data objects, such as the reverse update data's header, filename, directory address, pointer, etc. The reverse update generator can also write version data into the reverse update data. Version data can include version data for one or more of the original and updated data objects, and / or aggregated version or release data associated with a broader update that includes the forward update data. Associated and / or version data can be included in one or more of the reverse update data's identifier, header, filename, directory address, pointer, etc.

[0043] Furthermore, if a subsequent forward update is applied to the updated data object, the reverse update data can be deleted. Alternatively, the reverse update data can track changes and generate reverse data across multiple updates, providing reversibility for any forward updates in the history applied to the original data object.

[0044] Deletion operation 508 deletes both the forward update data and the original data object. The reverse update data generated in generation operation 506 can provide a complete instruction set and accompanying object data to reconstruct the original data object from the updated data object in a reverse update. This may render the forward update data and the original data object redundant, unnecessarily occupying storage space and potentially consuming (volatile) memory. With the updated data object and reverse update data stored, the forward update data and the original data object can be deleted, thereby freeing up the aforementioned storage space and / or memory without the risk of future access to the original data object. In implementation, operation 508 can be omitted from operation 500. For example, the forward update data may continue to be stored on the computer system for future use, perhaps to restore the updated data object in a subsequent forward update after a reverse update has been applied.

[0045] Figure 6 A flowchart of an example operation 600 for applying reversed update data is shown. Retrieval operation 602 retrieves the reversed update data from memory in a computing device. Retrieval operation 602 can use associated data to identify the reversed update data associated with the previously updated data object.

[0046] Operation 604 applies reverse update data to a previously updated data object to generate the original data object. Reverse update data may contain reverse update instructions and restorative data. Reverse update data can be applied by the updater in a reverse update to reverse any operations performed in the forward update operation. For example, reverse update data can be applied to delete any added data from the updated data object. Reverse update data can be applied to restore restorative data removed from the original data object in the forward update. The reverse update instructions in the reverse update data can be executed in a reverse order to the corresponding forward update instructions executed during the forward update, and can be the opposite in nature to the corresponding forward update instructions (e.g., deletion is the opposite of insertion).

[0047] Deletion operation 606 deletes reverse update data. Once the reverse update is complete, the reverse update data may be redundant. Therefore, the reverse update data can be removed without any consequences. In the implementation, deletion operation 606 can be omitted. For example, the reverse update data can continue to be stored on the computer system for future use, perhaps to restore the original data object in a subsequent reverse update after a forward update has been applied.

[0048] Figure 7 An example computing device 700 for implementing the features and operations of the described technology is illustrated. The computing device 700 may be embodied as a remotely controlled device or a physically controlled device, and is an example of a network-connected and / or network-supported device, and may be a client device (such as a laptop computer, mobile device, desktop computer, tablet computer); a server / cloud device; an Internet of Things device; an electronic accessory; or other electronic device. The computing device 700 includes one or more processors 702 and a memory 704. The memory 704 typically includes both volatile memory (e.g., RAM) and non-volatile memory (e.g., flash memory). An operating system 710 resides in the memory 704 and is executed by the processor(s) 702.

[0049] like Figure 7As shown, in the example computing device 700, one or more modules or segments (such as application 750, updater, reverse update generator, forward update instruction, reverse update instruction, forward delete instruction, forward insert instruction, reverse delete instruction, reverse insert instruction, replacement instruction, workload, and module) are loaded into the operating system 710 on memory 704 and / or storage device 720 and executed by processor(s) 702. Storage device 720 may include one or more tangible storage media devices and may store forward update data, reverse update data, original data objects, updated data objects, RTM binary data, added data, recoverable data, data sequences, updated data sequences, local and globally unique identifiers, requests, responses, and other data. It may be located locally on computing device 700 or may be remotely and communicatively connected to computing device 700.

[0050] The computing device 700 includes a power supply 716, which is powered by one or more batteries or other power sources and supplies power to other components of the computing device 700. The power supply 716 may also be connected to an external power source, which may replace the internal battery or other power source or charge the internal battery or other power source.

[0051] The computing device 700 may include one or more communication transceivers 730, which may be connected to one or more antennas 732 to provide network connectivity (e.g., mobile phone networks) to one or more other server and / or client devices (e.g., mobile devices, desktop computers, or laptop computers). The computing device 700 may also include a network adapter 736, which is a computing device. The computing device 700 can use this adapter and any other type of computing device to establish connections on a wide area network (WAN) or local area network (LAN). It should be understood that the network connections shown are examples, and other computing devices and components used to establish communication links between the computing device 700 and other devices may also be used.

[0052] The computing device 700 may include one or more input devices 734 (e.g., a keyboard or mouse) allowing a user to input commands and information. These and other input devices may be coupled to a server via one or more interfaces 738 (such as a serial port interface, a parallel port, or a universal serial bus (USB)). The computing device 700 may also include a display 722 (such as a touchscreen display).

[0053] Computing device 700 may include various tangible processor-readable storage media and intangible processor-readable communication signals. Tangible processor-readable storage may be implemented by any available medium accessible to computing device 700, and includes both volatile and non-volatile storage media, and both removable and non-removable storage media. Tangible processor-readable storage media does not include communication signals (e.g., the signals themselves), and includes volatile and non-volatile, removable and non-removable storage media implemented using any method or technology for storing information (such as processor-readable instructions, data structures, program modules, or other data). Tangible processor-readable storage media includes, but is not limited to, RAM, ROM, EEPROM, flash memory or other storage technologies, CDROM, digital versatile disc (DVD) or other optical disc storage, magnetic tape cassettes, magnetic tape, disk storage or other magnetic storage devices, or any other tangible medium that can be used to store desired information and is accessible to computing device 700. In contrast to tangible processor-readable storage media, intangible processor-readable communication signals may contain processor-readable instructions, data structures, program modules, or other data residing in modulated data signals, such as carrier waves or other signal transmission mechanisms. The term "modulated data signal" means a signal whose characteristics are set or altered in a way that encodes information in the signal. By way of example, and not limitation, intangible communication signals include signals that propagate through wired media (such as wired networks or direct wired connections) and wireless media (such as sound, radio frequency, infrared, and other wireless media).

[0054] The various software components described herein can be executed by one or more processors, which may include a logical machine configured to execute hardware or firmware instructions. For example, the processor may be configured to execute instructions that are part of one or more applications, services, programs, routines, libraries, objects, components, data structures, or other logical structures. These instructions may be implemented to perform tasks, implement data types, transition the state of one or more components, achieve technical effects, or otherwise achieve desired results.

[0055] Various aspects of the processor and memory can be integrated together into one or more hardware logic components. For example, such hardware logic components may include field-programmable gate arrays (FPGAs), application-specific integrated circuits (PASICs / ASICs), application-specific standard products (PSSPs / ASSPs), system-on-a-chip (SoCs), and complex programmable logic devices (CPLDs).

[0056] The terms "module," "program," and "engine" can be used to describe aspects of remotely controlled devices and / or physically controlled devices that perform specific functions. It should be understood that different modules, programs, and / or engines can be instantiated using the same applications, services, code blocks, objects, libraries, routines, APIs, functions, etc. Similarly, the same modules, programs, and / or engines can be instantiated by different applications, services, code blocks, objects, routines, APIs, functions, etc. The terms "module," "program," and "engine" can include single or groups of executable files, data files, libraries, drives, scripts, database records, etc.

[0057] It should be understood that, as used in this article, a "service" is an application that can be executed across one or more user sessions. A service is available to one or more system components, programs, and / or other services. In some implementations, a service can run on one or more server computing devices.

[0058] An example method for managing data in a computing device is provided. The method includes the operations of: applying forward update data to an original data object to generate an updated data object from the original data object, and generating reverse update data during the application, the reverse update data being configured to reverse the effects of the forward update data, and restoring the original data object from the updated data object.

[0059] Another example method is provided for any of the foregoing methods, wherein the reverse update data includes one or more of a reverse update instruction and restorative data, the restorative data being configured to be inserted into the updated data object during the reverse update, and the reverse update instruction and restorative data being configured to perform the reverse update.

[0060] Another example method is provided for any of the aforementioned methods, wherein forward update data includes added data and a forward update instruction, the added data being configured to be inserted into the original data object at the same time as the operation of applying forward update data is performed, the forward update instruction and the added data being used to perform the operation of applying forward update data.

[0061] Another example method is provided for any of the foregoing methods, wherein each reverse update instruction in the reverse update instructions corresponds to a corresponding forward update instruction and is configured to reverse the effect of the corresponding forward update instruction.

[0062] Another example method is provided for any of the foregoing methods, wherein the reverse update instructions are configured to be executed in reverse order relative to the order in which the corresponding forward update instructions were executed.

[0063] Another example method is provided for any of the aforementioned methods, wherein each element of the restorative data represents data deleted from the original data object during a forward update, the deletion being based on at least one forward update instruction in the forward update instructions.

[0064] Another example method is provided for any of the aforementioned methods, where the delete instruction of the reverse update instruction is configured to delete elements in the added data that contributed to the original data object.

[0065] Another example method is provided for any of the foregoing methods, wherein the reverse update data includes version data, which includes one or more identifiers that identify one or more of the following: the original data object, the updated data object, the forward update data, and the general update release data.

[0066] Another example method is provided for any of the aforementioned methods, which also includes operations for storing reversed update data and deleting forward update data.

[0067] Another example method provided for any of the aforementioned methods also includes an operation that applies reversed update data to an updated data object to restore the original data object.

[0068] An example system for managing data in a computer system is provided. The computer system includes one or more processors and at least one memory device communicatively coupled to the one or more processors. The one or more processors are configured to execute commands using data stored on the at least one memory device. The at least one memory device includes an updater executable by the one or more processors and configured to apply forward update data to an original data object to generate an updated data object from the original data object; and a reverse update generator executable by the one or more processors and configured to generate reverse update data substantially simultaneously with the application of the forward update data by the updater. The reverse update data is configured to reverse the effects of the forward update data and restore the original data object from the updated data object, wherein the reverse update data includes one or more of reverse update instructions and restorative data.

[0069] Another example system is provided for any of the aforementioned systems, wherein reverse update data is stored in a discrete file in at least one memory device, the discrete file storing only reverse update data used to recover the original data object from the updated data object.

[0070] Another example system is provided for any of the aforementioned systems, wherein restorative data is configured to be inserted into the updated data object during a reverse update, the reverse update instruction and the restorative data being used to perform the reverse update, and wherein the forward update data includes the added data and the forward update instruction, the added data being configured to be inserted into the original data object while the forward updater applies the forward update, the forward update instruction and the added data being configured to perform the forward update.

[0071] Another example system is provided for any of the aforementioned systems, wherein each reverse update instruction in the reverse update instructions corresponds to a corresponding forward update instruction and is configured to reverse the effect of the corresponding forward update instruction, and wherein the reverse update instructions are configured to be executed in a reverse order relative to the execution order of the corresponding forward update instructions.

[0072] Another example system is provided for any of the aforementioned systems, where each element of the restorative data represents data deleted from the original data object during a forward update, the deletion being based on at least one forward update instruction in the forward update instructions.

[0073] One or more example tangible processor-readable storage media devices are provided, encoded with processor-executable instructions for performing a process of managing data on an electronic computing device. The process includes applying forward update data to an original data object to generate an updated data object from the original data object, and generating reverse update data during the application, the reverse update data being configured to reverse the effect of the forward update data.

[0074] One or more other examples of tangible processor-readable storage media devices of any of the aforementioned media devices, wherein the reverse update data includes one or more of a reverse update instruction and restorative data configured to be inserted into an updated data object during a reverse update, the reverse update instruction and restorative data being used to perform a reverse update, and wherein the forward update data includes added data and a forward update instruction configured to be inserted into an original data object during a forward update, the forward update instruction and added data being configured to perform a forward update.

[0075] One or more other examples of tangible processor-readable storage media devices for any of the aforementioned media devices, wherein the reverse update instructions are configured to be executed in reverse order relative to the order in which the corresponding forward update instructions were executed.

[0076] One or more other examples of tangible processor-readable storage media devices of any of the aforementioned media devices, wherein each reverse update instruction in the reverse update instructions corresponds to a forward update instruction and is a reverse of the corresponding forward update instruction, and wherein each element of the restorative data represents data deleted from the original data object during the operation of applying the forward update data, the deletion being based on at least one forward update instruction in the forward update instructions.

[0077] One or more other examples of tangible processor-readable storage media devices of any of the aforementioned media devices, wherein the reverse update data includes version data, which includes one or more identifiers that identify one or more of the following: the original data object, the updated data object, the forward update data, and the general update release data.

[0078] An example system for managing data in a computing device is provided. The system includes components for applying forward update data to an original data object to generate an updated data object from the original data object, and components for generating reverse update data during the application of the forward update data, the reverse update data being configured to reverse the effects of the forward update data and restore the original data object from the updated data object.

[0079] Another example system is provided for any of the aforementioned example systems, wherein the reverse update data includes one or more of a reverse update instruction and restorative data, the restorative data being configured to be inserted into the updated data object during a reverse update, and the reverse update instruction and restorative data being configured to perform a reverse update.

[0080] Another example system is provided for any of the aforementioned example systems, wherein forward update data includes added data and a forward update instruction, the added data being configured to be inserted into the original data object simultaneously with the application of the forward update data, and the forward update instruction and the added data being configured to perform the operation of applying the forward update data.

[0081] Another example system is provided for any of the aforementioned example systems, wherein each reverse update instruction corresponds to a corresponding forward update instruction and is configured to reverse the effect of the corresponding forward update instruction.

[0082] Another example system is provided for any of the aforementioned example systems, wherein the reverse update instructions are configured to be executed in reverse order relative to the order in which the corresponding forward update instructions are executed.

[0083] Another example system is provided for any of the aforementioned example systems, where each element of the recoverable data represents data deleted from the original data object during a forward update, the deletion being based on at least one forward update instruction in the forward update instructions.

[0084] Another example system of any of the aforementioned example systems, where the delete instruction of the reverse update instruction is configured to delete elements in the added data that contributed to the original data object.

[0085] Another example system is provided for any of the aforementioned example systems, wherein the reverse update data includes version data, which includes one or more identifiers configured to identify one or more of the following: the original data object, the updated data object, the forward update data, and the general update release data.

[0086] Another example method provided for any of the aforementioned example methods also includes components for storing reverse update data and components for deleting forward update data.

[0087] Another example method provided for any of the aforementioned example methods also includes a component for applying reversed update data to an updated data object to restore the original data object.

[0088] Although this specification contains numerous specific implementation details, these details should not be construed as limiting any invention or potentially claimed scope, but rather as descriptions of specific features of specific embodiments of the particular described technology. Certain features described in the context of individual embodiments may also be implemented in combination in a single embodiment. Conversely, various features described in the context of a single embodiment may also be implemented individually in multiple embodiments, or in any suitable sub-combination. Furthermore, although the foregoing features may be described as functioning in a particular combination, or even initially claimed in this way, in some cases one or more features of the claimed combination may be removed from that combination, and the claimed combination may be for sub-combinations or variations thereof.

[0089] Similarly, although the operations are depicted in a specific order in the figures, this should not be construed as requiring such operations to be performed in the specific order shown or in a sequential order, or requiring all shown operations to be performed to achieve the desired result. In some cases, multitasking and parallel processing may be advantageous. Furthermore, the separation of the various system components in the above embodiments should not be construed as requiring such separation in all embodiments, and it should be understood that the program components and systems can generally be integrated together in a single software product or packaged into multiple software products.

[0090] Therefore, specific embodiments of the subject matter have been described. Other embodiments are within the scope of the following claims. In some cases, the actions described in the claims can be performed in a different order and the desired result can still be obtained. Furthermore, the processes depicted in the drawings do not necessarily require the specific order or sequential order shown to achieve the desired result. Multitasking and parallel processing may be advantageous.

[0091] Various implementations of the technology have been described. However, it should be understood that various modifications can be made without departing from the spirit and scope of the claims.

Claims

1. A method for managing data in a computing device, comprising: The computing device receives an operating system update release from the network, which includes forward update data, the forward update data including forward update instructions that apply forward updates to the original data objects, wherein the forward update instructions include compiler-level instructions; The computing device applies the positive update data to the original data object to generate an updated data object from the original data object; as well as The computing device generates reverse update data during the application, the reverse update data including reverse update instructions configured to reverse the effects of the forward update data and restore the original data object from the updated data object, wherein the reverse update instructions for the compiler-level instructions include operations of reversing the update through binary disassembly, address translation, and subsequent reassembly.

2. The method of claim 1, wherein the reverse update data further includes restorative data configured to be inserted into the updated data object during the reverse update, and the reverse update instruction and the restorative data are configured to perform the reverse update.

3. The method of claim 2, wherein the forward update data includes added data, the added data being configured to be inserted into the original data object simultaneously with the operation of applying the forward update data, and the forward update instruction and the added data being configured to perform the operation of applying the forward update data.

4. The method of claim 3, wherein each of the reverse update instructions corresponds to a corresponding forward update instruction and is configured to reverse the effect of the corresponding forward update instruction.

5. The method of claim 3, wherein the reverse update instructions are configured to be executed in a reverse order relative to the execution order of the corresponding forward update instructions.

6. The method according to claim 3, wherein, Each element of the restorative data represents data deleted from the original data object during the forward update, the deletion being based on at least one of the forward update instructions.

7. The method of claim 3, wherein the deletion instruction of the reverse update instruction is configured to delete elements from the added data that contribute to the original data object.

8. The method according to claim 1, wherein, The reverse update data includes version data, which includes one or more identifiers that identify one or more of the following: the original data object, the updated data object, the forward update data, and the general update release data.

9. The method according to claim 1, further comprising: Store the reversed update data; as well as Delete the positive update data.

10. The method according to claim 1, further comprising: The reverse update data is applied to the updated data object to restore the original data object.

11. A system for managing data in a computer system, comprising one or more processors and at least one memory device communicatively coupled to the one or more processors, the one or more processors being configured to execute commands using data stored on the memory device, the memory device comprising: A forward updater, executable by the one or more processors, and configured to: The system updates received from the network include forward update data, which includes forward update instructions for modifying data in the original data object, wherein the forward update instructions are compiler-level instructions. The forward update data is applied to the original data object to generate an updated data object from the original data object, wherein applying the forward update includes: loading the forward update instruction; and A local reverse update generator, executable by the one or more processors, and configured to generate reverse update data when the forward update instruction is loaded, the reverse update data being configured to reverse the effects of the forward update data and restore the original data object from the updated data object, wherein generating the reverse update data includes: Reversal update instructions are generated based on the loaded instructions, wherein the reversal update instructions for the compiler-level instructions include operations of reversal update via binary disassembly, address translation, and subsequent reassembly; and Generate restorative data corresponding to the data to be modified by the positive update instruction.

12. The system according to claim 11, wherein, The reverse update data, including the reverse update instruction and the forward update instruction, is stored in a discrete file in the at least one memory device, the discrete file storing only the reverse update data used to recover the original data object from the updated data object.

13. The system of claim 11, wherein the recoverable data is configured to be inserted into the updated data object during the reverse update, the reverse update instruction and the recoverable data are used to perform the reverse update, and wherein, The forward update data includes added data and a forward update instruction. The added data is configured to be inserted into the original data object while the forward updater applies a forward update. The forward update instruction and the added data are configured to execute the forward update.

14. The system of claim 13, wherein each of the reversal update instructions corresponds to a corresponding forward update instruction and is configured to reverse the effect of the corresponding forward update instruction, and wherein, The reverse update instruction is configured to be executed in reverse order of the execution of the corresponding forward update instruction.

15. The system of claim 13, wherein the reverse update instruction and the restorative data are generated before the data in the original data object is modified.

16. One or more tangible processor-readable storage media devices, encoded with processor-executable instructions for performing a process of managing data on an electronic computing device, the process comprising: The electronic computing device receives a system update from the network, which includes forward update data, the forward update data including forward update instructions that apply forward updates to the original data object, wherein the forward update instructions include compiler-level instructions; The positive update data is applied to the original data object to generate an updated data object from the original data object; as well as The electronic computing device generates reverse update data during the application, the reverse update data including reverse update instructions configured to reverse the effects of the forward update data, and wherein the reverse update instructions for the compiler-level instructions include operations of reversing the update through binary disassembly, address translation, and subsequent reassembly.

17. One or more tangible processor-readable storage media devices of claim 16, wherein the reverse update data further includes recoverable data configured to be inserted into the updated data object during a reverse update, the reverse update instruction and the recoverable data being used to perform the reverse update, wherein the forward update data includes added data configured to be inserted into the original data object during the forward update, the forward update instruction and the added data being used to perform the forward update.

18. One or more tangible processor-readable storage media devices according to claim 16, wherein the reverse update instruction is configured to be executed in reverse order relative to the corresponding forward update instruction.

19. The one or more tangible processor-readable storage medium devices of claim 17, wherein each of the reverse update instructions corresponds to and is a reverse of the corresponding forward update instruction, and wherein each element of the recoverable data represents data deleted from the original data object during an operation applying the forward update data, the deletion being based on at least one of the forward update instructions.

20. The one or more tangible processor-readable storage media devices of claim 16, wherein the reverse update data includes version data, the version data including one or more identifiers, the one or more identifiers identifying one or more of the following: the original data object, the updated data object, the forward update data, and general update release data.

Images