Introduction
代写一个文件系统，用Python写的TinyDos，一个一个的完成未实现的函数以及命令，最终做成一个可存/读/访问的文件系统。
In order to store files on a drive, the drive must have a number of data structures stored on it. These data structures are sometimes referred to as metadata - data about data. This information has to be stored on the drive so that when the drive is attached to a computer the operating system can make sense of what is stored.
What you have to do
You have to implement a very simple disk operating system called TinyDOS which provides the ability to store and retrieve data on a virtual drive and allows inspection of that data using cat or similar commands at any time during the execution of a program which uses the virtual drive.
The TinyDOS system creates files with full pathnames such as /dir1/dir2/file3 . The slashes represent separation into directories. The root directory is / . Each part of the pathname will be no more than 8 characters long.
There are classes you have to implement in order to get your file system working: a volume class is essential, but you probably want to have a directory entry class and possibly others. You also must write a TinyDOS program which the markers will use to pass commands to your implementation.
Drive
The virtual drive is represented by an ordinary file on your computer. The Python code to implement the virtual drive is provided in the drive.py file (see later in the handout if you wish to use a different language). You make a drive by creating a Drive object and calling the format method. This creates the file on the real machine which represents your virtual drive. All of the data on the virtual disk should be stored as readable ASCII so that by opening the real machine file you can easily see the contents of your virtual drive.
The write_block method of the Drive class writes directly to the underlying real file. Similarly the read_block method reads from the real file. Your file system must do all of its work by writing entire blocks to the drive and reading blocks from the drive using only these functions. This is how drives work, they are block addressable devices. In this assignment a block is always 512 bytes long.
Every virtual drive contains 128 blocks (from 0 to 127).
If you run the following program which creates a drive file and then displays it using cat , you will see the structure of a virtual drive.1
2
3
4
5import drive
from subprocess import call
vdrive = drive.Drive('vdrive')
vdrive.format()
call('cat vdrive', shell=True)
Initially each block is filled in with 512 spaces. These blocks are separated by a line like:
** 1 **
where the number is the block number of the block directly above the separator.
Volume
A drive is represented to the operating system as a volume. Formatting a volume means putting extra information on the drive so that it can be recognised and used by the TinyDOS operating system. This is a second format. The drive format is like that performed by a drive manufacturer before shipping a drive. A volume format is like the format you can perform using your operating system.
The only access a volume has to a drive is through the methods in the Drive class.
A volume format should write the following information into block 0 of the drive. Block 0 is the volume info block.
The first 128 bytes of the block represent the bitmap of available blocks on the drive. If a block is free it is represented with the byte corresponding to ‘ - ‘. If the block is used it is ‘ + ‘.
The remaining 384 bytes of block 0 consist of 6 directory entries.
Directory Entry
A directory entry consists of 64 bytes in the following form:
| bytes | interpretation |
|---|---|
| 0-1 | file type, “f:” means an ordinary file, “d:” means a directory |
| 2-10 | the file name terminated with a space (so max length of the file name is 8). No spaces in names. |
| 11-14 | four digits representing the length of the file in bytes, e.g. “0001”, “6144” |
| 15 | colon “:”. Then there are 12 block numbers in the following format. |
| 16-19 | three digits followed by a space, representing a block number holding the first block of file data |
| … | e.g. “001 “, “999 “. Max file size is 12 x 512 = 6144 bytes. |
| 60-63 | the last block number. If a block is not used it should be “000 “. |
Using a Volume
A s you use a volume to create files you need to make modifications to the volume (which makes modifications to the drive).
To create a file you need to find an empty directory entry in the directory you are creating the file in. All directories except the root directory can grow as needed.
At first this is all a file consists of - a directory entry. When the file gets written to it must be allocated a block for data. Each block is taken from the free blocks indicated in the volume bitmap. The block number is inserted into its correct position in the 12 block numbers of the directory entry. The length of the file also needs to be updated in the directory entry and the block containing the directory entry needs to be written back to the drive, along with any other blocks which have been modified.
Directory
A directory (apart from the one in the volume info block) is just an ordinary file with a file type of “ d: “. Like ordinary files they have a maximum number of 12 blocks of data. Each block allocated to a directory consists of 8 directory entries. When a new block is allocated to a directory you can fill in all the 8 directory entries in that block (initially each should be the same as the default directory entries in the volume info block).
A File
When a file is created it has a size of zero. As data is appended to the file, blocks are allocated to the file and the file length goes up. Writing to a file normally requires reading a block, modifying the contents of the block and writing the updated block back to the drive. It also requires modifying the directory entry for the file and writing that to the drive as well.
To test
In order to test your TinyDOS implementation you need to provide a program which takes commands from stdin (usually the keyboard) and interprets them. You should call this program TinyDOS (e.g. TinyDOS.py , or TinyDOS.java etc.) and give the marker instructions on how to start it (because you might have written it in a variety of languages) in Question 1.
The marker will redirect input into your program, e.g.:
python3 TinyDOS.py < commandfile
The commands your TinyDOS program must work with are:
format volumeName
Creates an ordinary file called volumeName and fills it in as a newly formatted TinyDOS volume. The real file will be 66944 bytes long. The volume is used for the next commands in the command file.
reconnect volumeName
Reconnects the ordinary file called volumeName to be used as a TinyDOS volume for the next commands in the command file.
ls fullDirectoryPathname
Lists the contents of the directory specified by fullDirectoryPathname. All pathnames of files and directories for TinyDOS will be fully qualified. You can make ls as pretty as you like, it must show the names, types and sizes of all files in the directory.
mkfile fullFilePathname
Makes a file with the pathname fullFilePathname. Any directories in the path should already exist.
mkdir fullDirectoryPathname
Makes a directory with the pathname fullDirectoryPathname. Any directories in the path should already exist.
append fullFilePathname "data"
Writes all of the data between the double quotes to the end of the file called fullFilePathname. The file must already exist. Double quotes will not appear inside the data.
print fullFilePathname
Prints all of the data from the file called fullFilePathname to the screen. The file must already exist.
delfile fullFilePathname
Deletes the file called fullFilePathname. The file must already exist.
deldir fullDirectoryPathname
Deletes the directory called fullDirectoryPathname. The directory must already exist and the directory must be empty.
quit
The TinyDOS program quits.
All commands in a command file will be legal. However you should write your program in such a way that all incorrect situations cause an error to be reported to the user, either by printing a message on the screen or by throwing or raising an exception. These exceptions are allowed to terminate the program.
The marker will have a second terminal open when testing your program. In this terminal he/she will be able to call commands such as cat to display the contents of the file which contains your drive information. This way the marker should see the effects of the commands modifying the underlying file. The reason for this is that it is possible to perform many of the commands in memory without using read_block or write_block and the assignment is to get you to implement a file system only with read_block and write_block.