Assigned: xxx
Due: xxx

• Multiple threads to use a single file concurrently.
  • The same file may be read & written by more than one thread concurrently. Each thread opens the file separately and has its own seek position within the file. This allows two threads to sequentially read a file at different rates.
  • All file system operations must be atomic and serializable. In other words, if one thread is in the middle of a file write, another thread that reads the file will see either all of the change or none of it. In addition, if the write operation finishes before the read operation starts, the read must return the modified data.
  • When a file is deleted, threads that already have the file open may continue to read and write the file until they close it. FileSystem::Remove must prevent further opens on a file, but the disk blocks for the file can't be reclaimed until the file has been closed by all threads that currently have the file open.

  You'll probably need to keep a table of open files to do this part.

• Files to be as large as the disk (2 MBytes). In the basic file system, files are limited to just under 128 * 32, or 4 KBytes. The basic file system keeps a list of direct pointers to file blocks, limiting the file size to the number of block pointers that fit into a single disk sector. You'll certainly need to use single indirect blocks, and may need to use doubly indirect blocks to allow large files.
• Files to grow. The file system currently restricts files to the size declared when they open. We want to allow users to add data to files once they've been created. To test this, allow the directory file to expand beyond its current limit of ten files. While you're doing this part, be careful to ensure that concurrent accesses to the file header remain properly synchronized.

For extra credit, you can optimize the file system by placing blocks intelligently. This is not required, but may prove to be an interesting project for those who finish the required goals early.