Clarifications.

[pintos-anon] / doc / filesys.texi

diff --git a/doc/filesys.texi b/doc/filesys.texi
index 3624aa28141f016abbfbada74399c0461967c137..4d663913b29e3b49dfd881d69b1de911e5027278 100644 (file)
--- a/doc/filesys.texi
+++ b/doc/filesys.texi
@@ -26,12 +26,13 @@ Your submission should define @code{THREAD_JOIN_IMPLEMENTED} in
 
 @menu
 * File System New Code::        
+* File System Synchronization::  
 * Problem 4-1 Large Files::     
 * Problem 4-2 File Growth::     
 * Problem 4-3 Subdirectories::  
 * Problem 4-4 Buffer Cache::    
 * File System Design Document Requirements::  
-* File System FAQ::            
+* File System FAQ::             
 @end menu
 
 @node File System New Code
@@ -89,12 +90,12 @@ prepared for interactions with all previous parts (as usual).
 @node File System Synchronization
 @section Synchronization
 
-The file system as provided requires external synchronization, that is,
+The provided file system requires external synchronization, that is,
 callers must ensure that only one thread can be running in the file
-system code at once.  Your submission should use a more finely granular
-synchronization strategy.  You will need to consider synchronization for
-each type of file system object.  The provided code uses the following
-strategies:
+system code at once.  Your submission should use a finer-grained
+synchronization strategy.  You will need to consider synchronization
+issues for each type of file system object.  The provided code uses the
+following strategies:
 
 @itemize @bullet
 @item
@@ -105,9 +106,9 @@ external viewpoint.
 
 @item
 Inodes are immutable in the provided file system, that is, their content
-never changes between creation and deletion, and furthermore only one
-copy of an inode's data is maintained in memory at once, even if the
-file is open in multiple contexts.
+never changes between creation and deletion.  Furthermore, only one copy
+of an inode's data is maintained in memory at once, even if the file is
+open in multiple contexts.
 
 @item
 File data doesn't have to be consistent because it's just not part of
@@ -117,11 +118,10 @@ show inconsistent results: it can show that none, all, or part of the
 write has completed.  (However, after the write system call returns to
 its caller, all subsequent readers must see the change.)  Similarly,
 when two threads write to the same part of a file at the same time,
-their data may be arbitrarily interleaved.
-
-External synchronization of the provided file system ensures that reads
-and writes are fully serialized, but your file system doesn't have to
-maintain full serialization as long as it follows the rules above.
+their data may be interleaved.  External synchronization of the provided
+file system ensures that reads and writes are fully serialized, but your
+file system doesn't have to maintain full serialization as long as it
+follows the rules above.
 @end itemize
 
 @node Problem 4-1 Large Files
@@ -266,7 +266,11 @@ Note that write-behind makes your filesystem more fragile in the face
 of crashes.  Therefore, you should
 periodically write all cached blocks to disk.  If you have
 @func{timer_sleep} from the first project working, this is an
-excellent application for it.
+excellent application for it.  (If you're still using the base
+implementation of @func{timer_sleep}, be aware that it busy-waits, which
+is not an acceptable solution.) If @func{timer_sleep}'s delays seem too
+short or too long, reread the explanation of the @option{-r} option to
+@command{pintos} (@pxref{Debugging versus Testing}).
 
 Likewise, read-ahead is only really useful when done asynchronously.
 That is, if a process wants disk block 1 from the file, it needs to
@@ -477,6 +481,9 @@ the 64-block limit.  The same rule applies to anything that's
 ``similar'' to a block of disk data, such as a @struct{inode_disk}
 without the @code{length} or @code{sector_cnt} members.
 
+You can keep a cached copy of the free map in memory permanently if you
+like.  It doesn't have to count against the cache size.
+
 That means you'll have to change the way the inode implementation
 accesses its corresponding on-disk inode right now, since it currently
 just embeds a @struct{inode_disk} in @struct{inode} and reads the