Application-Defined Object Logging via File System Journal
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing methods for capturing file system operations lack atomicity between committing operations to persistent storage and recording these events, leading to inconsistencies in the event log and file system, especially in the event of a system crash, and do not allow applications to determine with certainty whether operations are committed.
Innovation Solution
Implementing application-defined object logging through a file system journal, where the file system determines if a callback function is specified for an operation, invokes it, links the object with a file system transaction, and writes it to an event log only after the transaction is committed, ensuring atomicity and crash consistency.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Loss of information
If file system operations are recorded in an event log file separately from the file system transaction, then the event log can capture file system operations, but atomicity between committing operations and recording events is lost leading to inconsistencies
Solution Approach 1:
The patent merges the event log recording operation with the file system transaction commit operation into a single atomic transaction. The event log record and the file system operation are written together in one indivisible transaction, ensuring that either both are committed or both are aborted, eliminating the inconsistency problem where the event log might record an operation that fails to commit or vice versa.
Solution Approach 2:
The patent performs preliminary validation and preparation of the event log record before committing the transaction. The callback function is invoked during the transaction execution to prepare the event log entry, and the record is staged in memory before being atomically written to persistent storage as part of the commit process, ensuring consistency without requiring separate commit operations.
2Adaptability or versatility
If applications use separate logging mechanisms outside the file system transaction, then they can capture operations, but they cannot determine with certainty whether operations are committed
Solution Approach 1:
The patent implements a feedback mechanism where the file system provides commit status information back to the application through the event log. Since the event log record is only committed atomically with the file system operation, the presence of a valid event log record serves as definitive feedback that the operation has been successfully committed. The application can query the event log to determine commit status with certainty.
Solution Approach 2:
The event log acts as an intermediary between the file system transaction and the application. It provides a reliable interface that allows the application to query and determine the commit status of file system operations. The event log translates the internal file system commit state into observable information that the application can use to make decisions with certainty about operation completion.
3Productivity
If the event log is updated before the file system operation is committed, then logging can occur, but inconsistencies may arise if the operation fails to commit
Solution Approach 1:
The patent performs preliminary preparation of the event log record in memory during the transaction execution, but the actual write to persistent storage is deferred until the atomic commit point. The callback function prepares the event log entry structure and validates it, but the enduring action of writing to the event log file occurs only when the transaction is committed, ensuring that no incomplete or failed operations are recorded.
Solution Approach 2:
The patent segments the logging process into a preparation phase (during transaction execution) and a commitment phase (at transaction commit). The event log record is constructed and validated in the first phase, then atomically persisted in the second phase. This segmentation allows efficient preparation while maintaining data integrity through the atomic commit boundary, preventing inconsistencies even if the operation fails.
Data Source
AI summary
Some examples relate to performing application-defined object logging through a file system journal. In an example, a file system may determine during execution of an operation for an application whether a callback function is specified for the operation. In response to the determination, file system may invoke the callback function. File system may receive an object defined by the application. File system may link a copy of the object with a file system transaction associated with the operation in a journal of file system. File system may determine whether file system transaction is committed. In response to the determination, file system may write a copy of the object from the journal to an event log file. File system may allow the application to determine whether file system transaction is committed by enabling access to the event log file.