 |
Description  |
|
|
CROSS REFERENCE TO
RELATED APPLICATIONS
The present invention is related to the subject matter of U.S. Pat. No. 5,778,168 filed on even date herewith for: "Transaction Device Driver Technique For a Journaling File System to Ensure Atomicity of Write Operations to a Computer Mass
Storage Device", assigned to Sun Microsystems, Inc., Mountain View, Calif., assignee of the present invention, the disclosure of which is hereby specifically incorporated by this reference.
BACKGROUND OF THE INVENTION
The present invention relates, in general, to the field of file systems ("FS") of computer operating systems ("OS"). More particularly, the present invention relates to a single transaction technique for a journaling file system of a computer
operating system in which a journal, or log, contains sequences of file system updates grouped into atomic transactions which are committed with a single computer mass storage device write operation.
Modern UNIX.RTM. OS file systems have significantly increased overall computer system availability through the use of "journaling" in which a journal, or log, of file system operations is sequentially scanned at boot time. In this manner, a
file system can be brought on-line more quickly than implementing a relatively lengthy check-and-repair step.
Unfortunately, journaling may nevertheless serve to decrease a FS performance in synchronous operations, which type of operations are required for compliance with several operating system standards such as POSIX, SVID and NFS. Synchronous file
system operations are ones in which each operation is treated as a separate transaction and each such operation requires at least one write to an associated computer mass storage, or disk drive, per operation. Stated another way, a synchronous file
system operation is one in which all data must be written to disk, or the transaction "committed", before returning to a particular application program. As such, synchronous operations can decrease a journaling FS performance by creating a "bottleneck"
at the logging device as each synchronous operation writes its transaction into the log.
SUMMARY OF THE INVENTION
The single transaction technique for journaling file systems disclosed herein is of especial utility in overcoming the performance degradation which may be experienced in conventional journaling file systems by entering each file system operation
into the current active transaction. Consequently, each transaction is composed of a plurality of file system operations which are then simultaneously committed with a single computer mass storage device disk drive "write". In addition to increasing
overall file system performance under even light computer system operational loads, even greater performance enhancement is experienced under relatively heavy loads.
In order to effectuate the foregoing, a method is herein disclosed for writing data to a computer mass storage device in conjunction with a computer operating system having a journaling file system. The method comprises the steps of opening a
single file system transaction for accumulating a plurality of current synchronous file system operations; performing the plurality of current synchronous file system operations and then closing the single file system transaction upon completion of a
last of the current file system operations. The single file system transaction is then committed to the computer mass storage device in a single write operation.
The present invention is implemented, in part, by adding a journal, or log, to the OS file system including any System V-based UNIX.RTM. OS incorporating a UFS layer or equivalent, the IBM AIX.RTM. or Microsoft Windows NT.TM. operating
systems. The journal contains sequences of file system updates grouped into atomic transactions and is managed by a novel type of metadevice, the metatrans device. The addition of a journal to the operating system provides faster reboots and fast
synchronous writes (e.g. network file system ("NFS"), O.sub.-- SYNC and directory updates).
In the specific embodiment disclosed herein, the present invention is advantageously implemented as an extension to the UFS file system and serves to provide faster synchronous operations and faster reboots through the use of a log. File system
updates are safely recorded in the log before they are applied to the file system itself. The design may be advantageously implemented into corresponding upper and lower layers. At the upper layer, the UFS file system is modified with calls to the
lower layer that record file system updates. The lower layer consists of a pseudo-device, the metatrans device, that is responsible for managing the contents of the log.
The metatrans device is composed of two subdevices, the logging device, and the master device. The logging device contains the log of file system updates, while the master device contains the file system itself. The existence of a separate
logging device is invisible to user program code and to most of the kernel. The metatrans device presents conventional block and raw interfaces and behaves like an ordinary disk device.
Utilizing conventional OS approaches, file systems must be checked before they can be used because shutting down the system may interrupt system calls that are in progress and thereby introduce inconsistencies. Mounting a file system without
first checking it and repairing any inconsistencies can cause "panics" or data corruption. Checking is a relatively slow operation for large file systems because it requires reading and verifying the file system meta-data. Utilizing the present
invention, file systems do not have to be checked at boot time because the changes from unfinished system calls are discarded. As a result, it is ensured that on-disk file system data structures will always remain consistent, that is, that they do not
contain invalid addresses or values. The only exception is that free space may be lost temporarily if the system crashes while there are open but unlinked files without directory entries. A kernel thread eventually reclaims this space.
The present invention also improves synchronous write performance by reducing the number of write operations and eliminating disk seek time. Writes are smaller because deltas are recorded in the log rather than rewriting whole file system
blocks. Moreover, there are fewer of the blocks because related updates are grouped together into a single write operation. Disk drive seek time is significantly reduced because writes to the log are sequential.
As described herein with respect to a specific embodiment of the present invention, UFS on-disk format may be retained, no changes are required to add logging to an existing UFS file system and the log can subsequently be removed to return to
standard UFS with UFS utilities continuing to operate as before. Additionally, file systems do not have to be checked for consistency at boot time. The driver must scan the log and rebuild its internal state to reflect any completed transactions
recorded there. The time spent scanning the log depends on the size of the log device but not on the size of the file system. For reasonably foreseeable configuration choices, scan times on the average of 1-10 seconds per gigabyte of file system
capacity may be encountered.
NFS writes and writes to files opened with O.sub.-- SYNC are faster because file system updates are grouped together and written sequentially to the logging device. This means fewer writes and greatly reduced seek time. Significantly improved
speed-up may be expected at a cost of approximately 50% higher central processor unit ("CPU") overhead. Also, NFS directory operations are faster because file system updates are grouped together and written sequentially to the logging device. Local
operations are even faster because the logging of updates may optionally be delayed until sync(), fsync(), or a synchronous file system operation. If no logging device is present, directory operations may be completed synchronously, as usual.
If a power failure occurs while a write to the master or logging device is in progress, the contents of the last disk sector written is unpredictable and may even be unreadable. The log of the present invention is designed so that no file system
metadata is lost under these circumstances. That is, the file system remains consistent in the face of power failures. In the specific embodiment described in detail herein, users may set up and administer the metatrans device using standard MDD
utilities while the metainit(1 m), metaparam(1 m), and metastat(1 m) commands have small extensions. Use is therefore simplified because there are no new interfaces to learn and the master device and logging device together behave like a single disk
device. Moreover, more than one UFS file system can concurrently use the same logging device. This simplifies system administration in some situations.
In conventional UFS implementations, the file system occupies a disk partition, and the file system code performs updates by issuing read and write commands to the device driver for the disk. With the extension of the present invention, file
system information may be stored in a logical device called a metatrans device, in which case the kernel communicates with the metatrans driver instead of a disk driver. Existing UFS file systems and devices may continue to be used without change.
BRIEF DESCRIPTION OF THE DRAWINGS
The aforementioned and other features and objects of the present invention and the manner of attaining them will become more apparent and the invention itself will be best understood by reference to the following description of a preferred
embodiment taken in conjunction with the accompanying drawings, wherein:
FIG. 1 is a simplified representational drawing of a general purpose computer forming a portion of the operating environment of the present invention;
FIG. 2 is a simplified representational illustration providing an architectural overview of how selected elements of the computer program for effectuating a representative implementation of the present invention interact with the various layers
and interfaces of a computer operating system;
FIG. 3 is a more detailed representative illustration of the major functional components of the computer program of FIG. 2 showing in greater detail the components of the metatrans device and its interaction through the Vop or VFS interface of a
System V-based computer operating system in accordance with the exemplary embodiment hereinafter described;
FIG. 4 is a simplified logical block diagram illustrative of the fact that the unit structure for the metatrans devices contains the address of the logging device unit structure and vice versa;
FIG. 5 is an additional simplified logical block diagram illustrative of the fact that the logging device's unit structures are maintained on a global linked list anchored by ul.sub.-- list and that each of the metatrans unit structures for the
metatrans devices sharing a logging device are maintained on a linked list anchored by the logging device's unit structure;
FIG. 6 is a further simplified logical block diagram showing that the logmap contains a mapentry.sub.-- t for every delta in the log that needs to be rolled to the master device and the map entries are hashed by (metatrans dev, metatrans device
offset) and maintained on a linked list in the order that they should be rolled in;
FIG. 7 is a simplified logical block diagram showing that the unit structures for the metatrans device and the logging device contain the address for the logmap;
FIG. 8 is an additional simplified logical block diagram illustrative of the fact that a deltamap is associated with each metatrans device and stores the information regarding the changes that comprise a file system operation with the metatrans
device creating a mapentry for each delta which is stored in the deltamap;
FIG. 9 is a further simplified logical block diagram showing that, at the end of a transaction, the callback recorded with each map entry is called and the logmap layer stores the delta plus data in the log's write buffer and puts the map entries
into the logmap;
FIG. 10 is a simplified logical block diagram showing that the logmap is also used for read operations and, if the buffer being read does not overlap any of the entries in the logmap, then the read operation is passed down to the master device,
otherwise, the data for the buffer is a combination of data from the master device and data from the logging device;
FIG. 11 illustrates that, early in the boot process, each metatrans device records itself with the UFS function, ufs.sub.-- trans.sub.-- set, creates a ufstrans struct and links it onto a global linked list;
FIG. 12 further illustrates that, at mount time, the file system checks its dev.sub.-- t against the other dev.sub.-- t's stored in the ufstrans structs and, if there is a match, the file system stores the address of the ufstrans struct in its
file system specific per-mount struct (ufsvfs) along with its generic per-mount struct (vfs) in the ufstrans struct; and
FIG. 13 is an additional illustration of the interface between the operating system kernel and the metatrans driver shown in the preceding figures showing that the file system communicates with the driver by calling entry points in the
ufstransops struct, inclusive of the begin-operation, end-operation and record-delta functions.
DESCRIPTION OF A PREFERRED EMBODIMENT
The environment in which the present invention is used encompasses the general distributed computing system, wherein general purpose computers, workstations or personal computers are connected via communication links of various types, in a
client-server arrangement, wherein programs and data, many in the form of objects, are made available by various members of the system for execution and access by other members of the system. Some of the elements of a general purpose workstation
computer are shown in FIG. 1, wherein a processor 1 is shown, having an input/output ("I/O") section 2, a central processing unit ("CPU") 3 and a memory section 4. The I/O section 2 is connected to a keyboard 5, a display unit 6, a disk storage unit 9
and a compact disk read only memory ("CDROM") drive unit 7. The CDROM unit 7 can read a CDROM medium 8 which typically contains programs 10 and data. The computer program products containing mechanisms to effectuate the apparatus and methods of the
present invention may reside in the memory section 4, or on a disk storage unit 9 or on the CDROM 8 of such a system.
With reference now to FIG. 2, s simplified representational view of the architecture 20 for implementing the present invention is shown in conjunction with, for example, a System V-based UNIX operating system having a user (or system call) layer
22 and a kernel 24. With modifications to portions of the user layer 22 (i.e. the MDD3 and mount utilities 28) and kernel 24 (i.e. the UFS layer 30) as will be more fully described hereinafter, the present invention is implemented primarily by additions
to the metatrans layer 26 in the form of a metatrans driver 32, transaction layer 34, roll code 36, recovery code 38 and an associated log (or journal) code 40.
The MDD3 Utilities administer the metatrans driver 32 and set up, tear down and give its status. The mount utilities include a new feature ("syncdir") which disables the delayed directory updates feature. The UFS layer 30 interfaces with the
metatrans driver 32 at mount, unmount and when servicing file system calls. The primary metatrans driver 32 interfaces with the base MDD3 driver and the transaction layer 34 interfaces with the primary metatrans driver 32 and with the UFS layer 30. The
roll code 36 rolls completed transactions to the master device and also satisfies a read request by combining data from the various pieces of the metatrans driver 32. The recovery code scans the log and rebuilds the log map as will be more fully
described hereinafter while the log code presents the upper layers of the operating system with a byte stream device and detects partial disk drive write operations.
With reference additionally now to FIG. 3, the major components of the architecture of the present invention is shown in greater detail. The UFS layer 30 is entered via the VOP or VFS interface 42. The UFS layer 30 changes the file system by
altering in-core copies of the file system's data. The in-core copies are kept in the buffer or page cache 41. The changes to the in-core copies are called deltas 43. UFS tells the metatrans driver 32 which deltas 43 are important by using the
transops interface 45 to the metatrans device 32.
The UFS layer does not force a write after each delta 43. This would be a significant performance loss. Instead, the altered buffers and pages are pushed by normal system activity or by ITS at the end of the VOP or VFS interface 42 call that
caused the deltas 43. As depicted schematically, the metatrans driver 32 looks like a single disk device to the upper layers of the kernel 24. Internally, the metatrans driver 32 is composed of two disk devices, the master and log devices 44, 46.
Writes to the metatrans device 32 are either passed to the master device 44 via bdev.sub.-- strategy or, if deltas 43 have been recorded against the request via the transops interface 45, then the altered portions of the data are copied into a write
buffer 50 and assigned log space and the request is biodone'ed. The deltas 43 are moved from the delta map 48 to the log map 54 in this process.
The write buffer 50 is written to the log device 46 when ITS issues a commit (not shown) at the end of a VOP or VFS layer 42 call or when the write buffer 50 fills. Not every VOP or VFS layer 42 call issues a commit. Some transactions, such as
lookups or writes to files *not* opened O.sub.-- SYNC, simply collect in the write buffer 50 as a single transaction.
Reading the metatrans device 32 is somewhat complex because the data for the read can come from any combination of the write buffers 50, read buffers 52, master device 44, and log device 46. Rolling the data from the committed deltas 43 forward
to the master device 44 appears generally as a "read" followed by a "write" to the master device 44. The difference is that data can also come from the buffer or page caches 41. The affected deltas 43 are removed from the log map 54. The roll/read
code block 56 is coupled to the master and log devices 44, 46 as well as the write and read buffers 50, 52 and interfaces to the buffer or page drivers 58.
With reference now to FIG. 4, it can be seen that early in the boot process, the On-line: Disksuite ("ODS") state databases are scanned and the in-core state for the metadevices is re-created. Each metadevice is represented by a unit structure
and the unit structure for the metatrans devices contains the address of its logging device unit structure, and vice versa. The metatrans device 60 unit structure is mt.sub.-- unit.sub.-- t and is defined in md.sub.-- trans.h. The logging device 62
unit structure is ml.sub.-- unit.sub.-- t and is also defined in md.sub.-- trans.h.
Referring additionally now to FIG. 5, the logging device 62 unit structures are maintained on a global linked list anchored by ul.sub.-- list. Each of the metatrans device 60 unit structures for the metatrans devices 60 sharing a logging device
62 are kept on a linked list anchored by the logging device's unit structure.
With reference additionally to FIG. 6, after the unit structures are set up, a scan thread is started for each logging device 62. The scan thread is a kernel thread that scans a log device 62 and rebuilds the logmap 64 for that logging device
62. The logmap 64 is mt.sub.-- map.sub.-- t and is defined in md.sub.-- trans.h. The logmap 64 contains a mapentry.sub.-- t for every delta 43 in the log that needs to be rolled to the master device. The map entries 68 are hashed by the hash anchors
66 (metatrans device, metatrans device offset) for fast lookups during read operations. In order to enhance performance, the map entries 68 are also maintained on a linked list in the order in which they should be rolled in. As shown schematically in
FIG. 7, the unit structures for the metatrans device 60 and the logging device 62 contain the address of the logmap 64 (log map 54 in FIG. 3), which is associated with the hashed mapentries 70 and all mapentries 72.
Referring also now to FIG. 8, a deltamap 74 is associated with each metatrans device 60. The deltamap 74 stores the information about the changes that comprise a file system operation. The file system informs the metatrans device 60 about this
changes (or deltas 43) by recording the tuple (offset on master device 44, No. of bytes of data and callback) with the device. The metatrans device 60 in conjunction with hash anchors 76 creates a mapentry 78 for each delta 43 which is stored in the
deltamap 74 (delta map 48 in FIG. 3). The deltamap 74 is an mt.sub.-- map.sub.-- t like the logmap 64 (FIGS. 6-7) and has the same structure.
With reference also to FIG. 9, at the end of a transaction, the callback recorded with each map entry 68 is called in the case of "writes" involving logged data. The callback is a function in the file system that causes the data associated with
a delta 43 to be written. When this "write" appears in the metatrans driver, the driver detects an overlap between the buffer being written 80 and deltas 43 in the deltamap 74. If there is no overlap, then the write is passed on to the master device 44
(FIG. 3). If an overlap is detected, then the overlapping map entries are removed from the deltamap 74 and passed down to the logmap layer.
The logmap layer stores the delta 43+data in the log's write buffer 50 and puts the map entries into the logmap 64. It should be noted that the data for a delta 43 may have been written before the end of a transaction and, if so, the same
process is followed. Once the data is copied into log's write buffer 50, then the buffer is iodone'ed.
Among the reasons for using the mt.sub.-- map.sub.-- t architecture for the deltamap 74 is that the driver cannot user kmem.sub.-- alloc. The memory for each entry that may appear in the logmap needs to be allocated before the buffer appears in
the driver. Since there is a one-to-one correspondence between deltas 43 in the deltamap 74 and the entries in the logmap 64, it is apparent that the deltamap entries 78 should be the same as the logmap entries 68.
Referring now to FIG. 10, the analogous situation of "reads" involving logged data is illustrated. As can be seen, the logmap 64 is also used for read operations. If the buffer being read does not overlap any of the entries 68 in the logmap 64,
then the "read" is simply passed down to the master device 44. On the other hand, if the buffer does overlap entries 68 in the logmap 64, then the data for the buffer is a combination of data from the master device 44 and data from the logging device
46.
With reference to FIGS. 11 and 12, the situation at mount time is illustrated schematically. Early in the boot process, each metatrans device records itself with the UFS function, ufs.sub.-- trans.sub.-- set and creates a ufstrans struct 84 and
links it onto a global linked list. At mount time, the file system checks its dev.sub.-- t against the dev.sub.-- t's stored in the ufstrans structs 86. If there is a match, then the file system stores the address of the ufstrans struct 86 its file
system specific per-mount struct, the ufsvfs 90. The file system also stores its generic per-mount struct, the vfs 88, in the ufstrans struct 86. This activity is accomplished by mountfs() and by ufs.sub.-- trans.sub.-- get(). The address of the vfs
88 is stored in the ufstrans struct 86 due to the fact that the address is required by various of the callback functions.
The file system communicates with the metatrans driver 32 (FIGS. 2-3) by calling the entry points in the ufstransops 92 struct. These entry points include the begin-operation, end-operation and record-delta functions. Together, these three
functions perform the bulk of the work needed for transacting UFS layer 30 operations. FIG. 13 provides a summary of the data structures of the present invention as depicted in the preceding figures and as will be more fully described hereinafter.
The metatrans device, or driver 32 contains two underlying devices, a logging device 46 and a master device 44. Both of these can be disk devices or metadevices (but not metatrans devices). Both are under control of the metatrans driver and
should generally not be accessible directly by user programs or other parts of the system. The logging device 46 contains a journal, or log. The log is a sequence of records each of which describes a change to a file system (a delta 43). The set of
deltas 43 corresponding to the currently active vnode operations form a transaction. When a transaction is complete, a commit record is placed in the log. If the system crashes, any uncommitted transactions contained in the log will be discarded on
reboot. The log may also contain user data that has been written synchronously (for example, by NFS). Logging this data improves file system performance, but is not mandatory. If sufficient log space is not available user data may be written directly
to the master device 44. The master device 44 contains a UFS file system in the standard format. If a device that already contains a file system is used as the master device 44, the file system contents will be preserved, so that upgrading from
standard UFS to extension of the present invention is straightforward. The metatrans driver updates the master device 44 with completed transactions and user data. Metaclear(1 m) dissolves the metatrans device 32, so that the master device 44 can again
be used with standard UFS if desired.
The metatrans device 32 presents conventional raw and block interfaces and behaves like an ordinary disk device. A separate transaction interface allows the file system code to communicate file system updates to the driver. The contents of the
device consist of the contents of the master device 44, modified by the deltas 43 recorded in the log.
Through the transaction interface, UFS informs the driver what data is changing in the current transaction (for instance, the inode modification time) and when the transaction is finished. The driver constructs log records containing the updated
data and writes them to the log. When the log becomes sufficiently full, the driver rolls it forward. In order to reuse log space, the completed transactions recorded in the log must be applied to the master device 44. If the data modified by a
transaction is available in a page or buffer in memory, the metatrans driver simply writes it to the master device 44. Otherwise, the data must be read from the metatrans device 32. The driver reads the original data from the master device 44, then
reads the deltas 43 from the log and applies them before writing the updated data back to the master device 44. The effective caching of SunOS.TM. developed and licensed by Sun Microsystems, Inc., assignee of the present invention, makes the latter
case occur only rarely and in most instances, the log is written sequentially and is not read at all.
UFS may also cancel previous deltas 43 because a subsequent operation has nullified their effect. This canceling is necessary when a block of metadata, for instance, an allocation block, is freed and subsequently reallocated as user data.
Without canceling, updates to the old metadata might be erroneously applied to the user data.
The metatrans driver keeps track of the log's contents and manages its space. It maintains the data structures for transactions and deltas 43 and keeps a map that associates log records with locations on the master device 44. If the system
crashes, these structures are reconstructed from the log the next time the device is used (but uncommitted transactions are ignored). The log format ensures that partially written records or unused log space cannot be mistaken for valid transaction
information. A kernel thread is created to scan the log and rebuild the map on the first read or write on a metatrans device 32. Data transfers are suspended until the kernel thread completes, though driver operations not requiring I/O may proceed.
One of the principle benefits of the present invention is to protect metadata against corruption by power failure. This imposes a constraint on the contents of the log in the case when the metatrans driver is applying a delta 43 to the master
device 44 when power fails. In this case, the file system object that is being updated may be partially written or even corrupted. The entire contents of the object from the log must still be recovered. To accomplish this, the driver guarantees that a
copy of the object is in the log before the object is written to the master device 44.
The metatrans device 32 does not attempt to correct other types of media failure. For instance, a device error while writing or reading the logging device 46 puts the metatrans device 32 into an exception state. The metatrans device 32's state
is kept in the MDD database. There are different exception states based on when the error occurs and the type of error.
Metatrans device 32 configuration may be performed using standard MDD utilities. The MDD dynamic concatenation feature allows dynamic expansion of both the master and logging devices 44, 46. The device configuration and other state information
is stored in the MDD state database, which provides replication and persistence across reboots. The space required to store the information is relatively small, on the order of one disk sector per metatrans device 32.
In a particular implementation of the present invention, UFS checks whether a file system resides on a metatrans device 32 at mount time by calling ufs.sub.-- trans.sub.-- get(). If the file system is not on a metatrans device 32, this function
returns NULL; otherwise, it returns a handle that identifies the metatrans device 32. This handle is saved in the mount structure for use in subsequent transaction operations. The functions TRANS.sub.-- BEGIN() and TRANS END() indicate the beginning
and end of transactions. TRANS DELTA() identifies a change to the file system that must be logged. TRANS.sub.-- CANCEL() lets UFS indicate that previously logged deltas 43 should be canceled because a file system data structure is being recycled or
discarded.
When the file system check ("fsck") utility is run on a file system in accordance with the present invention, it checks the file system's clean flag in the superblock and queries the file system device via an ioctl command. When both the
superblock and device agree that the file system is on a metatrans device 32, and the device does not report any exception conditions, fsck is able to skip further checking. Otherwise, it checks the file system in a conventional manner.
When the "quotacheck" utility is run on a file system in accordance with the present invention, it checks the system's clean flag in the superblock and queries the file system device via an ioctl command. When both the superblock and device
agree that the file system is on a metatrans device 32, and the device does not report any exception conditions, quotacheck doesn't have to rebuild the quota file. Otherwise, it rebuilds the quota file for the file system in a conventional manner.
The logging mechanism of the present invention ensures file system consistency, with the exception of lost free space. If there were open but deleted files (that is, not referred to by any directory entry) when the system went down, the file
system resources claimed by these files will be temporarily lost. A kernel thread will reclaim these resources without interrupting service. As a performance optimization, a previously unused field in the file system's superblock, fs.sub.--
sparecon[53], indicates whether any files of this kind exist. If desired, fsck can reclaim the lost space immediately and fs.sub.-- sparecon[53] will be renamed fs.sub.-- reclaim.
Directories may be changed by a local application or by a daemon running on behalf of a remote client in a client-server computer system. In the standard UFS implementation, both remote and local directory changes are made synchronously, that
is, updates to a directory are written to the disk before the request returns to the application or daemon. Local directory operations are synchronous so that the file system can be automatically repaired at boot time. The NFS protocol requires
synchronous directory operations. Using the technique of the present invention, remote directory changes are made synchronously but local directory changes are held in memory and are not written to the log until a sync(), fsync(), or a synchronous file
system operation forces them out. As a result, local directory changes can be lost if the system crashes but the file system remains consistent. Local directory changes remain ordered.
Holding the local directory updates in memory greatly improves performance. This introduces a change in file system semantics, since completed directory operations may now disappear following a system crash. However, the old behavior is not
mandated by any standard, and it is expected that few, if any, applications would be affected by the change. This feature is implemented in conventional file systems, such as Veritas, Episode, and the log-structured file system of Ousterhout and
Mendelblum. Users can optionally revert back to synchronous local directory updates.
The MDD initialization utility, metainit(1 m), may be extended to accept the configuration lines of the following form:
______________________________________ mdNN -t master log [-n] mdNN A metadevice name that will represent the metatrans device. master The master device; a metadevice or ordinary disk device. log The log device; a metadevice or ordinary disk
device. The same log may be used in multiple metatrans devices, in which case it is shared among them. ______________________________________
Metastat may also be extended to display the status of metatrans devices, with the following format:
______________________________________ mdXX: metatrans device Master device:mdYY Logging device:mdZZ <state information> mdYY: metamirror, master device for mdXX <usual status> mdZZ: metamirror, logging device for mdXX
<usual status> ______________________________________
Fsck d | | |
