Computer system for archiving open files

The subject of the invention is a method of managing a computer system based on a microprocessor, and in particular a method of archiving data stored in a device with a memory to protect against possible damage to the device with memory or against data corruption, data loss, infection by a virus. In particular, the invention relates to archiving in personal computers.

A single computer system with one user typically contains memory in the form of a hard disk or a fixed disk. In such a system, only one application program has access to memory at any given point in time. The task of archiving data stored in the memory is performed by an application program which during the archiving operation has exclusive access to the device with memory until the archiving application is finished.

With the introduction of multitasking environments that allow multiple applications to run simultaneously and network systems that allow multiple users to use the same software, it has become possible for more than one application to access the same memory simultaneously. The emergence of such a situation raises the possibility of conflict between applications. For example, one application may modify or delete a file currently in use by another application. This can lead to confusion and damage to the memory device with consequent data loss.

Methods known as file locking or record locking were introduced into operating systems to avoid more than one

183 365 application writing to a file, and in the case of blocking a record, two applications modifying the same area of ​​a given file. Both of these methods are modern enough for most applications, especially when each application only makes relatively minor changes to files that are common and therefore does not significantly delay other applications requesting access to a file or record that is locked. Nevertheless, applications for periodic data archiving in computer systems are a special case.

The smallest unit of data that can be archived is a single file, as neither the archiving application nor the operating system knows about the internal structure of the file, as this could be related to any application program.

Additionally, the file backup must be an exact replication of the original at a particular point in time. However, copying a file is not an immediate process and the duration of the copy will depend on the size of the file and the speed of the copy operation. This can cause problems if another application can modify the file while the backup application is running.

To copy a file, the backup application allocates an area of ​​random access memory (RAM) as the transfer buffer and proceeds alternately by reading blocks of the source file into the buffer and then writing the contents of the buffer to auxiliary memory. If the file is not small enough, the transfer buffer will be filled several times and the copy operation will require reading and writing several times to make a complete copy of the file.

The potential problem caused by allowing a file to be modified during the copying process can be illustrated by an example where a file is copied as a series of 10 blocks. If the file were to be modified by a transaction that requires file changes in blocks 3 and 8, after blocks 1 through 5 have already been copied, the copying process will only take into account the change in block 8 but not the change in block 3 because block 3 has already been copied. copied before the transaction took place. Therefore, the backup will only contain some changes, which may make it completely useless as the application that has it will probably consider the file corrupted.

Our US Patent No. 5,086,502 discloses a method of making copies of each write operation as it is performed by performing a secondary write operation to an auxiliary memory. This approach is complemented by two other ways of backing up files on a shared memory computer system.

The first is to lock the file during archiving. This prevents other users from modifying the file by denying them write access. If another user has already gained write access, the backup application must either skip that file or wait until exclusive write access is obtained.

The second is file modification detection. After the file is copied, the backup application can use the operating system to check if any modification has been made while the copy is in progress. If such modification has been made, the copy must be repeated or the file skipped.

Neither of the latter two methods provides a suitable solution as many files (especially database files) are still in use. Moreover, these methods require blocking users during archiving.

Additionally, only a few auxiliary memory devices and operating systems are capable of carrying out long transmissions at rates greater than 15 megabytes (Mb) per minute and therefore the time required to copy a large file is significant. Only a few utilities have solved this problem by providing methods to safely copy their own files in a shared environment, but the procedure is different for each application.

To back up all memory, the backup application needs to know how a particular inline procedure works, or it must rely on manual intervention at the right moment. So, because the backup application needs to copy

183 365 the entire file and since this file cannot be modified by another application during the copying process, the use of methods known so far will introduce a delay in the computer system in which there is a shared memory. This is especially important when copying large files.

U.S. Patent No. 5,163,148 to WallsOwi discloses an archiving system in which a file is brought into a conforming state before archiving begins: for example, if multiple operations are required in connection with a transaction, all operations are complete. If part of an archived file needs to be updated, this part of the original file is copied to a separate part of the disk before archiving takes place. The archiver program backs up files by replacing those parts that have been updated with the original parts that have been copied and saved somewhere on disk. The extended disk map, which normally lists the tracks and sectors on the disk occupied by this file, is extended to contain a concordance associating the path and sector addresses of the copied original parts of the file with the path and sector address of the updated part that occupy the area from which they were copied.

Our International Patent Application No. PCT / GB94 / 01581, published on July 20, 1995 in Publication No. W095 / 19599, discloses a method of managing a computer with a memory device shared by several application programs, which also includes an archiving process that includes a maintenance process. a record of data changes made in the memory device while the archiving process is running. The use of this record ensures that the data seen by the archiving process will not be changed while it is running, and at the same time allows other processes to continue updating memory normally, avoiding the delays associated with the file locking technique. Additional operations are performed at the interface level of the microcomputer's operating system in such a way that they do not affect the normal use of the computer. In this method, the archiving process may send a start signal and a stop signal and perform at least one read operation in the archiving process to read original data from a storage device, e.g. a hard disk. Periodically, the CPU performs at least one normal operation to write data to the first stage memory area and at least one normal operation to read data from the memory device.

Upon receipt of the start signal, an intercept operation is performed to intercept the write operation and write the data to the auxiliary memory area, so as to preserve the original data which would otherwise be overwritten. A record is kept containing information about the parts of the file stored in the auxiliary memory and when performing one of the operations: archiving or standard reading operation, this record is called to read data from one of the first stage memory or auxiliary memory areas according to the record. In this way, the archiving process is carried out with the original data in the condition that it was in immediately before sending the start signal. At the moment, the record defines parts of a file by file records rather than by path and sector addresses on the disk. This has some advantages and thus avoids the problem that can arise when the record is for an address of a location on a disk, ie, path and sector.

Preferably, the record comprises a delta region in which the master data is stored and a reference map between the actual master data location and its predicted location. Alternatively, the assistance data may be written in the delta area and other applications may continue writing to the predicted memory locations.

Preferably the delta area is another area of ​​the same device, e.g. hard disk. The additional required operations are preferably stored and run at the operating system interface level of the computer system. If the software is stored at the operating system level, it may be invisible to the user so as not to affect the application software.

183 365

The archiving record can be stored on various recording media, e.g. tape, optical disk or other area of ​​the primary storage medium. After the backup is done, you can restore the file as usual.

The technique of locating an environment string and deriving a program name from it is fully described in the Undocumented DOS manual by Andrew Schulman et al., Addison-Wesley, 2nd Ed. 1993, ISBN 0-201-63287-Χ, Chapter 7, especially pages 356-359.

A method of managing a microprocessor-based computer system having a memory for storing orders, a central processing unit of a computer and a storage device in which an archiving process is established in successive steps, run on a computer system adapted to send a start signal and a stop signal and send at least one associated with archiving a reading order, first memory stored instructions are provided to the computer CPU and the computer CPU is caused to execute at least one standard memory data reading operation. a record of data written to the memory device is maintained and a relationship is established between the respective areas in the first stage memory area and in the auxiliary memory area of ​​said memory device it is determined, after receiving a start signal and receiving a read command, whether the read command relates to a read operation related to archiving or standard reading and one of the reading operations is performed either for archiving or standard reading, reviewing a record and reading data from the first stage memory or auxiliary memory according to said record, and when performing the second of said reading operations related to archiving or standard reading, data is read from the first stage memory according to the invention, characterized in that the memory area is kept track of from which the read command is derived and identifies the program that initiated said read command while determining, whether the read order is for an archive read operation or a standard read operation. When tracing memory, it is preferable to browse the stack and designate the addresses placed on the stack and look at these addresses.

Preferably, in tracing the memory, the code in the vicinity of said addresses is compared with the code expected for the archiving program.

In tracing the memory, the Program Segment Prefix and Program Environment String are preferably specified at said addresses and the name of the program determined using said Environment Description String.

A method of managing a microprocessor-based computer system having a memory for storing orders, a central processing unit of a computer and a storage device in which an archiving process is established in successive steps, run on a computer system adapted to send a start signal and a stop signal and send at least one associated with archiving a reading order, first memory stored instructions are provided to the computer CPU and the computer CPU is caused to execute at least one standard memory data reading operation. a record of data written to the memory device is maintained and a relationship is established between the respective areas in the first stage memory area and in the auxiliary memory area of ​​said memory device it is determined, after receiving a start signal and receiving a read command, whether the read command relates to a read operation related to archiving or standard reading and one of the reading operations is performed either for archiving or standard reading, reviewing a record and reading data from the first stage memory or auxiliary memory according to said record, and when performing the second of said reading operations related to archiving or standard reading, data is read from the first stage memory, according to the invention, in that it is allocated to a process user archiving process or task identifier, and when defining, whether the read order is for an archive read operation or for a standard read operation, determine or operation

183 365 the reading was requested by the user or his program via the process or task id.

A method of managing a microprocessor-based computer system comprising memory storing orders, a computer central unit and a storage device, in which an archiving process is established in successive steps, run on a computer system adapted to send a start signal and a stop signal and send at least one associated with the archiving of the reading order, resulting in reading the original data from the memory device, memory-stored instructions are provided to the computer CPU and the computer CPU is made to perform at least one standard reading data from memory operation; file opening means is provided to open the file to be read by the standard and deny access to the file by other operations according to the invention, it is distinguished by the fact that measures related to the archiving process are used, disabling said access denied function and allowing simultaneous read access to the file via the read operation associated with archiving! standard reading operation.

Preferably, the computer system maintains the table of files open, wherein the access denied function is disabled by temporarily changing the table reversibly.

A method of managing a microprocessor-based computer system comprising memory storing orders, a computer central unit and a storage device, in which an archiving process is established in successive steps, run on a computer system adapted to send a start signal and a stop signal and send at least one associated with the archiving of the reading order, resulting in reading the original data from the memory device, the instructions stored in memory are delivered to the CPU of the computer and the CPU of the computer is made to execute at least one standard operation of reading data from the memory, the archiving process being able to operate on files that are open to access by these commands, according to the invention being distinguished that the start signal is delayed by a predetermined period of inactivity, sufficient to complete each sequence of file write operations, to be archived.

The present invention provides improvements that are applicable to the known methods. It is required that the system can distinguish between the read request from the archive program and the read request from other application programs that may be running.

Fig. 1 shows a block diagram of a personal computer and a tape cassette drive, Figs. 2a and 2b - diagrams illustrating a system memory map at the operating system level of a standard personal computer and a computer working according to the invention. 3 is a block diagram of a data recording method in an archiving operation, fig. 4 is a block diagram according to a second embodiment of the method of fig. 3, fig. 5 - block diagram illustrating an improvement of the embodiments with reference to fig. 3 and fig. 4.

Fig. 1 shows a personal computer 10 consisting of a central processing unit 12, a random access memory 14, and a hard disk non-volatile memory device 16. In the example shown, a tape unit 18 coupled to the computer 10 is used for archiving purposes.

Part of the archiving program is the write process, which works by capturing a standard reading and writing to the hard disk 16 so that the data flow between the disk drive 16 and other parts of the computer 10 can be controlled.

Before the file backup starts, the write process is activated by the backup program to redirect all write operations to another area of ​​the disk 16, called the delta area. A delta mapping table is kept to ensure a record of all write operations that have been redirected to the delta region.

This table maintains a mapping between the intended data destination on disk 16 associated with each write operation and the actual location in pa

183 365 crashes in the delta area. If there is another write operation to an area that is already recorded in the table, the old data in the delta area may be replaced with new data. This way, the data in the base part of the disk does not change during the backup as all changes are addressed to the delta area.

If the backup program requests a read from disk operation, the request is forwarded unchanged so that the data returned to the backup program comes from the original area of ​​the main part of the disk. When another application program occurs with a read request, the write process first checks the table to see if a write to disk to this area has occurred since the process started intercepting the write operation, and if it did, the read operation is redirected to the appropriate position in the delta area. If no write operation has been recorded, i.e. some data has not changed since the process started intercepting the write operation, then the read operation is transferred unchanged.

In this way, changes to data stored on disk 16 are normally seen by all applications other than the backup program. The backup program sees the data that will not change until an order to end the write process is given, which terminates the interception process of the read and write operation.

When the backup operation is complete, the save process is activated to restore the computer to its normal operating state. The recovery phase to standard operation is achieved by applying the changes stored in the delta area to the corresponding original data areas in the main portion of disk 16 using the mappings stored in the table. When changes to the delta region are accounted for, interception of write operations continues as described above. When there are no more write operations that have not been applied to the original data area, interception of the save operation is stopped and the system returns to normal operation.

Another improvement is as follows. If a record about the advancement of the performed backup process is kept, the software may pass the write operation to the main part of the disk memory 16 unchanged after that part of the disk has already been copied since any change of data is no longer relevant. This reduces the size of the delta mapping table. In addition, if the area information of the main part of the disk to which this operation is directed has already been entered into the mapping table, it can now be removed from this table, thus reducing the recovery phase time.

The invention finds particular application in IBM compatible personal computers, i.e. most personal computers using the 8086, 8088, 80286, 80386, 80486 and Pentium type processors manufactured by Intel and other microprocessor-based systems as the central processing unit (CPU). On such computers, when a program wants to access a file, it calls a standard program that writes the data to disk. This standard program, known as Interrupt 21 hex (INT 21h) in the DOS operating system, is an integral part of the operating system. The action performed by this program, known as an interrupt handler program, depends on the parameters passed to the program as input. This program is shown in Fig. 2a as the operating system portion in the system memory map, the INT 21h entry point is indicated by an arrow. In order to be able to use the preferred method according to the invention, additional program code is added at the operating system interface level as shown in Fig. 2b. In practice, in a DOS environment, it can be loaded to the computer as a device driver using the CONFIG.SYS file.

The effect of the added software is to replace the data write commands with an alternative set of instructions. Similarly, a data read command can be intercepted and replaced with an alternate instruction set.

The appropriate sequence of operations resulting from the alternate instruction set is shown in the form of a block diagram in Fig. 3. When receiving a INT 21 h program call, the program first checks to see if the call is a write call. If so, pro

183 365 grams checks in step 20 if it can be intercepted write call. If not, the data is written, step 22, to the original data area 24.

If the write call is intercepted, then the program checks the delta mapping table, step 26, to see if a write has previously been made to the original area of ​​the file 24, determined by the record or part specification in the file. If a write was made, step 28, then that part of the delta region 30 which previously corresponded to that part of the original file 24 in the delta mapping table is replaced with new data - step 32.

If a write call is intercepted but no write was previously made to this original area of ​​the file 24, then the record is added to the table and a new area, the delta area, is allocated for this data - step 34. The data is written to the new delta area - step 36 .

If the call is an intercepted read call, then it is checked (step 42) that the call is from the backup program. If the call is from the backup program, the program proceeds to step 40 and the data is read from the original file 24.

If the call is not from the backup program, the program checks the delta mapping table to see if the write to the original area of ​​file 24 corresponding to this read call was redirected to the delta area - step 44. If it was not redirected, step 46, the program goes back to step 40 and data is read from original file 24. If reading was redirected, data is read from corrected part of delta 30 step 48.

If the INT 21h call is neither a write nor a read call, it is routed to the standard INT 21h interrupt handler.

In the second embodiment of the invention, when reading and writing operations are captured during the writing process, instead of storing changed data in the delta area when the first write is made in a specific area of ​​the file, the original data is stored in the delta area and the original file may be changed. An entry is made in the mapping table that points to the original contents of the original file area, and which is now stored in the delta area. Any subsequent write to the same area of ​​the file is then ignored by the write process. Read requests from the backup program are redirected to the delta area if the mapping table points to writing new data to the original file area.

Fig. 4 shows the second embodiment by means of a block diagram. The diagram is similar to that shown in Fig. 3, where steps having the same reference number designate a similar operation. The differences between Fig. 3 and Fig. 4 are as follows;

In step 60, if reading capture is active, step 38, and the reading is not from the archive program, data is read from the original data area. This is the reciprocal of step 42 in Fig. 3.

An additional step 62 is introduced after step 28 in which the data from the original area is read before new data is written in its place for the first time.

Step 36 of Fig. 3 is modified to create a new step 64 that includes an additional writing to the delta area of ​​the data read in step 62.

Step 32 is modified to create a new step 66, which no longer redirects the data to write to the old ones in the delta area, but instead writes the data to the original data area.

The second method is slower than the first because each write request becomes one read request and two write requests, as opposed to the simple write redirection of the first method. However, the second method does not require applying the changes stored in the delta area to the original file after archiving is complete. The delta mapping table and the data stored in the delta area may simply be discarded. Additionally, because of this difference, no additional safeguards are necessary to enable data recovery in the event of severe disruptions (such as power outages) occurring when delta changes have not been fully applied to the original data. In the event that the method presented above is part of the archiving program,

183 Interception of reading operations can take place during archiving and does not have to involve the use of an operating system program.

Detailed implementation of the system as described with reference to Fig. 3 and Fig. 4 is within the scope of the skilled person, and a complete description thereof is therefore unnecessary. If the system is implemented in MS.DOS, and if required, the reader can refer to the IBM DOS Technical Reference Manual.

The invention is preferably implemented as part of the operating system itself, either as an integral part of the original operating system code or as an extension thereto, in the form of a device driver. In the case of an Intel 80386 (or higher) processor, the invention usually operates at the highest priority level, known as Ring 0, where access to all system components is unlimited.

However, the operation of the invention does not concern any particular CPU architecture. It can be implemented on other systems, such as Macintosh computers that use the 68000 series and PowerPC CPUs as the central processor.

The invention may be used in a multi-user environment. In this case, it is advantageous if the invention is used in an environment with file access control. The invention will guarantee an error-free copy while the remainder of the system is operating fully efficiently as if the invention were not followed. In the absence of file access control, there is a risk of file corruption, regardless of whether the invention is applied or not.

The invention is particularly applicable to files created by databases, such as dBase, which can be large and are divided into records. Records that are updated are written to the table and both the updated and original versions are kept in memory until archiving is complete. The table may contain, for example, the starting point in the file where the updated data begins and a length corresponding to the amount of updated data. Alternatively, the table may contain the hallmark of updated records.

In the case of multiple users or network operation, where the computer environment allows for the identification of the particular user desiring to perform the archiving, the present method may also include a step of recognizing the user and only archiving these user files as described above. Thus, it is not necessary to capture all data transactions, but only those relating to that user.

The archiving method described above, which can work on open files, is that it can distinguish between a request from an archive program and requests from other sources, such as standard applications. This appears at step 42 of Fig. 3 or step 60 of Fig. 4.

Assuming that the method for open files is an integral part of the backup program, the source of the read request can be easily determined because the backup program knows what program requested it. Problems arise when a certain archiving program already exists, e.g. in the form of a standard package, requiring no modification or in such a form that cannot be altered to accommodate the method for open files, which method must be implemented with additional program code.

According to the first improvement, the requests of the archiver program are distinguished from other requests by following a chain of events (i.e. looking backwards or upwards) to identify the code area that initiated the read request. In the following example of such a method, the MS.DOS operating system will be reused for illustration, however a similar technique may be used for other operating systems.

The read request is initiated by calling ΓΝΤ 21h, which would normally be directed to the interrupt handler. The interrupt handler generally has no knowledge of the calling program. It is simply commanded to execute a particular function and then returned to the calling program. On the aforementioned Intel processors used in a DOS environment, the CPU automatically places the caller's return address on the stack and jumps to the first command of the interrupt program.

183 365

When the function has finished, the interrupt handler sends an IRET (interrupt return) instruction which looks for an address from the stack and continues execution at the location indicated by that address. Hence, the interrupt handler need not and actually has no information about the calling program.

In the system described above with reference to Figs. 3 and 4, the interrupt program INT 21h is replaced by an alternate instruction set. In addition to the functions described so far, these instructions may be adapted to further specify the source of the request as follows.

In this improvement, the interrupt handler examines the stack to determine the return address. For Intel 80x86 series processors, the relative code address and segment of the calling program will be stored as the first and second words at the top of the stack, ie SS: [SP] and SS: [SP + 2] respectively. An outline of the implementation steps in MS.DOS is provided at the end of this description.

A program can look at the source of a call as defined by the stack and determine the program that made that call in various ways, the following examples are given below.

First, various code characteristics near the return address can be examined to determine if the calling program is a known backup program, since the code of each version of the program ready to be used without modification is the same. The code near the return address is compared with that expected from the backup program being used to determine whether the comparison indicates that the call was made by the backup program.

Second, the program name may be determined by reference to a Program Segment Prefix (PSP) or an environment description string associated with each loaded program. The segment is known from the contents of the stack and can be read from the PSP. This makes it possible to locate a string that describes the environment and use it to determine the name of the program in a known manner.

In the case of a non-DOS operating system, the calling program identification can be made based on other parameters of the stack, including connection numbers, job identification numbers, process numbers, and more. On some operating systems, global variables can also be used to determine the process name.

The proposed method consists in identifying certain known characteristics of the calling program, such as the name of the program, the name of a process or program consisting of several modules, or by identifying a certain signature in the program code, which may be a known sequence of bytes, by retrieving the calling program using stack.

According to a second improvement that can be used in a network environment, the identification of the calling program is determined by reserving a specific username for archiving purposes only. Instead of identifying the program, a user name is identified (unique user identification), and all requests for a user with a reserved name are treated as coming from the backup program. Since each user needs to register with the system before granting access to files, this is an efficient way, assuming of course that the username is only used for archiving and not for any other purpose. This method does not require advanced knowledge of any particular backup program. Similarly, a process or task identifier specific to the archiving process can be called to determine whether the read request comes from the archiving process or from another application. Two tasks with the same identity (id) never exist at the same moment in time, so they uniquely identify the process at every moment in time (although the task numbers can be reused).

The previously described methods have dealt with a read request, however the same procedure can be used for a write job. In the case when the archiving program sends a write request, an appropriate action can be taken, which would normally be

183 365 with the error correction procedure, as the archiving application should not normally send a write request to the interrupt handler.

As described above, the additional commands first check that the interrupt call is a read (or write) request, and if so, check whether it was sent by the backup program or by another application. In principle, the order of the two operations can be reversed and the source of the call is determined before its nature is examined.

The method for archiving open files described with reference to Figs. 2 and 3 assumes that reading access can always be granted to the archiving application. In practice, this is not always the case as the file may already be open for exclusive read / write related to another application and therefore access to the archiving application may be denied.

The present invention takes into account the fact that since an archiving application should never write to a file that is currently being archived and since the method for open files described above will ensure that the file copy received by the archiving application does not change when archiving is performed, it is perfectly safe to grant file reading access for the archiving application.

Access for archiving purposes can be achieved as follows. The operating system generally maintains a table of all open files, which includes information such as file handler IDs, relative file address pointers, and access permissions for each open file.

In the case of the MS-DOS operating system, files are opened using the INT 21h function. Hence, a file open request can be identified by adding an alternate instruction set as described above. By using the source identification technique as described in the previous section, or by direct command from the backup program, it can be determined whether the request to open a file was made by the backup application and, if so, the open file table can be temporarily changed to ensure that access even when this would normally be impossible. When access is granted, but before the interrupt handler returns, the table is restored to its previous state so that subsequent access requests from other applications will be rejected as is the case in standard situations. Even if the original application believes it has exclusive access to the file, requests to read from the archiving application will be satisfied.

In MS-DOS, the table of open files is called the System File Table (SFT). SFT is an array containing entered information for each open file. Each information entered includes the access mode granted to the file. The additional commands that are necessary modify the SFT when the backup application requires access to open files by temporarily overwriting the relevant information in the SFT to create the impression that the access rights that would normally prevent the backup program from gaining access have not yet been granted. Access will then be granted and file handler granted. Before returning to the caller, access rights in the SFT are restored to their original state. The System File Table (SFT) is fully described in the Undocumented DOS manual, reference above see Chapter 8, pages 465-469 and 490-494. In the particular case of the DOS operating system, the steps required in handling INT 21h to ensure access to the backup application are shown in Figure 5.

Referring to Fig. 5, upon receipt of a command to open a file as a call from INT 21h, the determination of the source of the request is made in step 70, using one of the techniques described in the previous section. If the call comes from an archive application, in step 72 it is determined whether the file to which access is requested is already open. If the answer to one of the questions is no, the program returns to the standard INT 21h handler, step 74. If the answer to both questions is YES, then the instruction set described in Fig. 5 is executed. This is as follows. Each entry of information into the SFT includes the access mode granted to the requesting process (Access Mode Attribute). In step 76, the current or original Access Mode Attribute from is stored

183 365 of the relevant entered information. In step 78, the Access Mode Attribute is changed to the state deny nothing, so that effectively the SFT is inoperable in the sense that it does not prevent multiple accesses to the open file. Now the standard interrupt handler in step 80 can be called to open the file in the standard way for the archiver. When the backup program has finished working with the file, the original previously remembered access mode attribute is re-entered into the SFT (step 82). Finally, execution is restored to the calling program with an IRET command that reads from the stack (step 84). The steps in the Appendix take into account that a file access enhancement has been used.

The exact way in which the SFT is altered is not critical and various ways may be used. The preferred way is to manipulate the fields used together share_prev_sft 'and share_net_machine (see Undocumented DOS, page 478). By manipulating these fields, such as by swapping read negate to no negate, access can be gained by the archiver. Another way is to change the part of the SHARE program that is part of MS.DOS (see pages 490-494) so ​​that access will be granted.

A similar approach would be used in other operating system environments, such as Novell NetWare.

The above-described method of archiving open files with reference to Fig. 3 and Fig. 4 ensures no changes in the open file during the archiving process. However, it does not determine whether the file is in good condition. For example, another application might be saving changes that require a series of write operations, some have already been made and some have not. Since the backup method works on open files, it is possible for the backup application to receive a file containing partially introduced changes.

The invention takes into account the fact that a good copy of a good file health can be ensured by delaying the request of the archive application to open the file until no change is made. Since most networked operating systems, due to their multi-tasking nature, are specially designed to run multiple processes simultaneously, and the ability to delay one process when another exits is a common convenience of such operating systems, this can easily be achieved. In general, it doesn't really matter if the archiving operation is suspended for a short period of time, as users are usually not dependent on it to finish, especially when files may be archived while they are opened. The delay in requesting to open the file corresponds to the delay of the start signal that initiates execution of the program described with reference to Figs. 3 and 4. The second approach is applicable in situations where there is no software capability to maintain the transactional atomicity of files. Then another method for establishing transactional indivisibility may be used as follows. Processing typically occurs for a relatively short period of time, with longer intervals between processes. The application program will generally perform all write operations required for a single processing in rapidly repeating sub-writes, as otherwise there is a risk of a power failure or a similar failure, which may result in only partially updated data appearing on the disk, which will be manifested when the system is restarted. a message about a damaged file appears. It is clear that the shorter the time a transaction is written to disk, the less likely it is to experience serious non-related problems (such as a power failure). By measuring the time between consecutive write operations, it is possible to estimate the state of a file for making transactions. For example, if no write has occurred in, say, the last minute, it is unlikely that the application is writing a single transaction. By empirically matching the period of inactivity to the characteristics of the application, a highly reliable transaction integrity index can be established. Hence there are various improvements to the method illustrated in Figs. 3 and 4, namely different techniques for providing file access and techniques for ensuring that the file is archived.

183 365 is in good condition before archiving takes place. It is advantageous when these various enhancements are used in combination. However, they can be used selectively and independently, and it is not essential that they be used in the same application.

The subject of the invention has been presented mainly by means of the DOS operating system, and more particularly MS.DOS. However, for the invention to function it does not depend on any particular CPU architecture. In particular, it is not limited to the DOS operating system and could be implemented on Novell NetWare, OS / 2, or UNIX systems, and on Macintosh computers that use 6800 series and Power PC processors.

Archive program code example:

. ; program code before calling

6F00: 0009 INT 21h (INT 21h call to open a

6F00: 000B? (the interrupt returns to this place. (program code after calling

Additional interrupt handler INT 21h according to the invention:

<td></td><td>(save the contents of registers using (local variables (check that the call is a request (which we want to intercept, i.e. open, (read, write, etc. If not, jump; to the old INT 21h interrupt handler. (Now examine the stack to determine the address (caller</td>

<td>pop dx</td><td>(calling program segment is now; in dx register</td>

<td>pop cx</td><td>(relative address of calling program (is now in cx</td>

<td>push cx</td><td>(put relative address back; on the stack</td>

<td>push dx</td><td>(put segment back - content (stack is restored ; DX: CX now points to the address of the program (caller, in this case 6F00: 000B (establish the identity of the calling program, e.g. by examining the program code before or; after calling INT 21 h for a known feature (characteristic.</td>

<td>jmp elsewhere</td><td>(if the calling program does not (is an archive program, then jump to another code.</td>

<td>jmp elsewhere 2</td><td>(if the file is not used, (jump to another code. (manipulate the table so that it gives the impression that access is granted.</td>

<td>pushf</td><td>(put tags for IRET simulation</td>

183 365

<td>all service</td><td>; call original interrupt handler ; to open a file (opening call will be executed and will come back here</td>

<td></td><td>; restore the array back to (original state.</td>

<td></td><td>(restore the contents of registers from variables</td>

<td>iret</td><td>(local (back to the archiving program.</td>

Writing instruction

Reading instruction

<img file="PL183365B1_D0001.tif" />

'26

Write to original data area

Save with deletion to _____delta,. "

Checking the table of previous zaols

<img file="PL183365B1_D0002.tif" />

N

Add a record to the board

Write to the new area _ delta N⁶

<img file="PL183365B1_D0003.tif" />

Checking the table of redirected entries

<img file="PL183365B1_D0004.tif" />

Reading from the delta area

Reading from the original data area

<img file="PL183365B1_D0005.tif" />

Delta area

<img file="PL183365B1_D0006.tif" />

Original Data Area

183 365

<img file="PL183365B1_D0007.tif" />

183 365

Opening Order

Jump to the original INT 2ih interrupt handler

<img file="PL183365B1_D0008.tif" />

<img file="PL183365B1_D0009.tif" />

Change the access mode to do not deny anything

<img file="PL183365B1_D0010.tif" />

Call the original INT 21 h to open the file

<img file="PL183365B1_D0011.tif" />

<img file="PL183365B1_D0012.tif" />

183 365

Fig.1

MEMORY

Computer central unit

<img file="PL183365B1_D0013.tif" />

<img file="PL183365B1_D0014.tif" />

<img file="PL183365B1_D0015.tif" />

Fig.2b

Fig.2a

DOS Operating System

New Point

INT 21 zones h

<img file="PL183365B1_D0016.tif" />

Publishing Department of the UP RP. Mintage 60 copies. Price PLN 4.00.