// to inodes used by multiple processes. The cached
// inodes include book-keeping information that is
// not stored on disk: ip->ref and ip->flags.
-//
-// ip->ref counts the number of pointer references to this cached
-// inode; references are typically kept in struct file and in proc->cwd.
-// When ip->ref falls to zero, the inode is no longer cached.
-// It is an error to use an inode without holding a reference to it.
//
-// Processes are only allowed to read and write inode
-// metadata and contents when holding the inode's lock,
-// represented by the I_BUSY bit in ip->flags.
-// Because inode locks are held during disk accesses,
-// they are implemented using a flag rather than with
-// spin locks. ilock() and iunlock() manipulate an
-// inode's I_BUSY flag. Many routines in this file expect
-// the caller to have already locked the inode; leaving
-// this responsibility with the caller makes it possible for them
-// to create arbitrarily-sized atomic operations.
+// An inode and its in-memory represtative go through a
+// sequence of states before they can be used by the
+// rest of the file system code.
//
-// To give maximum control over locking to the callers,
-// the routines in this file that return inode pointers
-// return pointers to *unlocked* inodes. It is the callers'
-// responsibility to lock them before using them. A non-zero
-// ip->ref keeps these unlocked inodes in the cache.
+// * Allocation: an inode is allocated if its type (on disk)
+// is non-zero. ialloc() allocates, iput() frees if
+// the link count has fallen to zero.
//
-// In order for the file system code to look at an inode, the inode
-// must pass through a number of states, with transitions
-// driven by the indicated functions:
-//
-// * Allocated on disk, indicated by a non-zero type.
-// ialloc() and iput().
-// * Referenced in the cache, indicated by ip->ref > 0.
-// iget() and iput().
-// * Cached inode is valid, indicated by I_VALID.
-// ilock() and iput().
-// * Locked, indicated by I_BUSY.
-// ilock() and iunlock().
+// * Referencing in cache: an entry in the inode cache
+// is free if ip->ref is zero. Otherwise ip->ref tracks
+// the number of in-memory pointers to the entry (open
+// files and current directories). iget() to find or
+// create a cache entry and increment its ref, iput()
+// to decrement ref.
+//
+// * Valid: the information (type, size, &c) in an inode
+// cache entry is only correct when the I_VALID bit
+// is set in ip->flags. ilock() reads the inode from
+// the disk and sets I_VALID, while iput() clears
+// I_VALID if ip->ref has fallen to zero.
+//
+// * Locked: file system code may only examine and modify
+// the information in an inode and its content if it
+// has first locked the inode. The I_BUSY flag indicates
+// that the inode is locked. ilock() sets I_BUSY,
+// while iunlock clears it.
+//
+// Thus a typical sequence is:
+// ip = iget(dev, inum)
+// ilock(ip)
+// ... examine and modify ip->xxx ...
+// iunlock(ip)
+// iput(ip)
+//
+// ilock() is separate from iget() so that system calls can
+// get a long-term reference to an inode (as for an open file)
+// and only lock it for short periods (e.g., in read()).
+// The separation also helps avoid deadlock and races during
+// pathname lookup. iget() increments ip->ref so that the inode
+// stays cached and pointers to it remain valid.
+//
+// Many internal file system functions expect the caller to
+// have locked the inodes involved; this lets callers create
+// multi-step atomic operations.
struct {
struct spinlock lock;
panic("ialloc: no inodes");
}
-// Copy inode, which has changed, from memory to disk.
+// Copy a modified in-memory inode to disk.
void
iupdate(struct inode *ip)
{
}
// Find the inode with number inum on device dev
-// and return the in-memory copy.
+// and return the in-memory copy. Does not lock
+// the inode and does not read it from disk.
static struct inode*
iget(uint dev, uint inum)
{
acquire(&icache.lock);
- // Try for cached inode.
+ // Is the inode already cached?
empty = 0;
for(ip = &icache.inode[0]; ip < &icache.inode[NINODE]; ip++){
if(ip->ref > 0 && ip->dev == dev && ip->inum == inum){
empty = ip;
}
- // Allocate fresh inode.
+ // Recycle an inode cache entry.
if(empty == 0)
panic("iget: no inodes");
}
// Lock the given inode.
+// Reads the inode from disk if necessary.
void
ilock(struct inode *ip)
{
release(&icache.lock);
}
-// Caller holds reference to unlocked ip. Drop reference.
+// Drop a reference to an in-memory inode.
+// If that was the last reference, the inode cache entry can
+// be recycled.
+// If that was the last reference and the inode has no links
+// to it, free the inode (and its content) on disk.
void
iput(struct inode *ip)
{
acquire(&icache.lock);
if(ip->ref == 1 && (ip->flags & I_VALID) && ip->nlink == 0){
- // inode is no longer used: truncate and free inode.
+ // inode has no links: truncate and free inode.
if(ip->flags & I_BUSY)
panic("iput busy");
ip->flags |= I_BUSY;
}
//PAGEBREAK!
-// Inode contents
+// Inode content
//
-// The contents (data) associated with each inode is stored
-// in a sequence of blocks on the disk. The first NDIRECT blocks
+// The content (data) associated with each inode is stored
+// in blocks on the disk. The first NDIRECT block numbers
// are listed in ip->addrs[]. The next NINDIRECT blocks are
-// listed in the block ip->addrs[NDIRECT].
+// listed in block ip->addrs[NDIRECT].
// Return the disk block address of the nth block in inode ip.
// If there is no such block, bmap allocates one.
}
// Truncate inode (discard contents).
-// Only called after the last dirent referring
-// to this inode has been erased on disk.
+// Only called when the inode has no links
+// to it (no directory entries referring to it)
+// and has no in-memory reference to it (is
+// not an open file or current directory).
static void
itrunc(struct inode *ip)
{
// Look for a directory entry in a directory.
// If found, set *poff to byte offset of entry.
-// Caller must have already locked dp.
struct inode*
dirlookup(struct inode *dp, char *name, uint *poff)
{
projects / cs3210-lab1.git / commitdiff