root/fs.c

DEFINITIONS

1. readsb
2. bzero
3. balloc
4. bfree
5. iinit
6. ialloc
7. iupdate
8. iget
9. idup
10. ilock
11. iunlock
12. iput
13. iunlockput
14. bmap
15. itrunc
16. stati
17. readi
18. writei
19. namecmp
20. dirlookup
21. dirlink
22. skipelem
23. namex
24. namei
25. nameiparent

   1 // File system implementation.  Five layers:
   2 //   + Blocks: allocator for raw disk blocks.
   3 //   + Log: crash recovery for multi-step updates.
   4 //   + Files: inode allocator, reading, writing, metadata.
   5 //   + Directories: inode with special contents (list of other inodes!)
   6 //   + Names: paths like /usr/rtm/xv6/fs.c for convenient naming.
   7 //
   8 // This file contains the low-level file system manipulation 
   9 // routines.  The (higher-level) system call implementations
  10 // are in sysfile.c.
  12 #include "types.h"
  13 #include "defs.h"
  14 #include "param.h"
  15 #include "stat.h"
  16 #include "mmu.h"
  17 #include "proc.h"
  18 #include "spinlock.h"
  19 #include "fs.h"
  20 #include "buf.h"
  21 #include "file.h"
  23 #define min(a, b) ((a) < (b) ? (a) : (b))
  24 static void itrunc(struct inode*);
  25 struct superblock sb;   // there should be one per dev, but we run with one dev
  27 // Read the super block.
  28 void
readsb(int dev, struct superblock *sb)
  30 {
  31   struct buf *bp;
bp = bread(dev, 1);
memmove(sb, bp->data, sizeof(*sb));
brelse(bp);
  36 }
  38 // Zero a block.
  39 static void
bzero(int dev, int bno)
  41 {
  42   struct buf *bp;
bp = bread(dev, bno);
memset(bp->data, 0, BSIZE);
log_write(bp);
brelse(bp);
  48 }
  50 // Blocks. 
  52 // Allocate a zeroed disk block.
  53 static uint
balloc(uint dev)
  55 {
  56   int b, bi, m;
  57   struct buf *bp;
bp = 0;
  60   for(b = 0; b < sb.size; b += BPB){
bp = bread(dev, BBLOCK(b, sb));
  62     for(bi = 0; bi < BPB && b + bi < sb.size; bi++){
m = 1 << (bi % 8);
  64       if((bp->data[bi/8] & m) == 0){  // Is block free?
bp->data[bi/8] |= m;  // Mark block in use.
log_write(bp);
brelse(bp);
bzero(dev, b + bi);
  69         return b + bi;
  70       }
  71     }
brelse(bp);
  73   }
panic("balloc: out of blocks");
  75 }
  77 // Free a disk block.
  78 static void
bfree(int dev, uint b)
  80 {
  81   struct buf *bp;
  82   int bi, m;
readsb(dev, &sb);
bp = bread(dev, BBLOCK(b, sb));
bi = b % BPB;
m = 1 << (bi % 8);
  88   if((bp->data[bi/8] & m) == 0)
panic("freeing free block");
bp->data[bi/8] &= ~m;
log_write(bp);
brelse(bp);
  93 }
  95 // Inodes.
  96 //
  97 // An inode describes a single unnamed file.
  98 // The inode disk structure holds metadata: the file's type,
  99 // its size, the number of links referring to it, and the
 100 // list of blocks holding the file's content.
 101 //
 102 // The inodes are laid out sequentially on disk at
 103 // sb.startinode. Each inode has a number, indicating its
 104 // position on the disk.
 105 //
 106 // The kernel keeps a cache of in-use inodes in memory
 107 // to provide a place for synchronizing access
 108 // to inodes used by multiple processes. The cached
 109 // inodes include book-keeping information that is
 110 // not stored on disk: ip->ref and ip->flags.
 111 //
 112 // An inode and its in-memory represtative go through a
 113 // sequence of states before they can be used by the
 114 // rest of the file system code.
 115 //
 116 // * Allocation: an inode is allocated if its type (on disk)
 117 //   is non-zero. ialloc() allocates, iput() frees if
 118 //   the link count has fallen to zero.
 119 //
 120 // * Referencing in cache: an entry in the inode cache
 121 //   is free if ip->ref is zero. Otherwise ip->ref tracks
 122 //   the number of in-memory pointers to the entry (open
 123 //   files and current directories). iget() to find or
 124 //   create a cache entry and increment its ref, iput()
 125 //   to decrement ref.
 126 //
 127 // * Valid: the information (type, size, &c) in an inode
 128 //   cache entry is only correct when the I_VALID bit
 129 //   is set in ip->flags. ilock() reads the inode from
 130 //   the disk and sets I_VALID, while iput() clears
 131 //   I_VALID if ip->ref has fallen to zero.
 132 //
 133 // * Locked: file system code may only examine and modify
 134 //   the information in an inode and its content if it
 135 //   has first locked the inode. The I_BUSY flag indicates
 136 //   that the inode is locked. ilock() sets I_BUSY,
 137 //   while iunlock clears it.
 138 //
 139 // Thus a typical sequence is:
 140 //   ip = iget(dev, inum)
 141 //   ilock(ip)
 142 //   ... examine and modify ip->xxx ...
 143 //   iunlock(ip)
 144 //   iput(ip)
 145 //
 146 // ilock() is separate from iget() so that system calls can
 147 // get a long-term reference to an inode (as for an open file)
 148 // and only lock it for short periods (e.g., in read()).
 149 // The separation also helps avoid deadlock and races during
 150 // pathname lookup. iget() increments ip->ref so that the inode
 151 // stays cached and pointers to it remain valid.
 152 //
 153 // Many internal file system functions expect the caller to
 154 // have locked the inodes involved; this lets callers create
 155 // multi-step atomic operations.
 157 struct {
 158   struct spinlock lock;
 159   struct inode inode[NINODE];
 160 } icache;
 162 void
iinit(int dev)
 164 {
initlock(&icache.lock, "icache");
readsb(dev, &sb);
cprintf("sb: size %d nblocks %d ninodes %d nlog %d logstart %d inodestart %d bmap start %d\n", sb.size,
sb.nblocks, sb.ninodes, sb.nlog, sb.logstart, sb.inodestart, sb.bmapstart);
 169 }
 171 static struct inode* iget(uint dev, uint inum);
 173 //PAGEBREAK!
 174 // Allocate a new inode with the given type on device dev.
 175 // A free inode has a type of zero.
 176 struct inode*
ialloc(uint dev, short type)
 178 {
 179   int inum;
 180   struct buf *bp;
 181   struct dinode *dip;
 183   for(inum = 1; inum < sb.ninodes; inum++){
bp = bread(dev, IBLOCK(inum, sb));
dip = (struct dinode*)bp->data + inum%IPB;
 186     if(dip->type == 0){  // a free inode
memset(dip, 0, sizeof(*dip));
dip->type = type;
log_write(bp);   // mark it allocated on the disk
brelse(bp);
 191       return iget(dev, inum);
 192     }
brelse(bp);
 194   }
panic("ialloc: no inodes");
 196 }
 198 // Copy a modified in-memory inode to disk.
 199 void
iupdate(struct inode *ip)
 201 {
 202   struct buf *bp;
 203   struct dinode *dip;
bp = bread(ip->dev, IBLOCK(ip->inum, sb));
dip = (struct dinode*)bp->data + ip->inum%IPB;
dip->type = ip->type;
dip->major = ip->major;
dip->minor = ip->minor;
dip->nlink = ip->nlink;
dip->size = ip->size;
memmove(dip->addrs, ip->addrs, sizeof(ip->addrs));
log_write(bp);
brelse(bp);
 215 }
 217 // Find the inode with number inum on device dev
 218 // and return the in-memory copy. Does not lock
 219 // the inode and does not read it from disk.
 220 static struct inode*
iget(uint dev, uint inum)
 222 {
 223   struct inode *ip, *empty;
acquire(&icache.lock);
 227   // Is the inode already cached?
empty = 0;
 229   for(ip = &icache.inode[0]; ip < &icache.inode[NINODE]; ip++){
 230     if(ip->ref > 0 && ip->dev == dev && ip->inum == inum){
ip->ref++;
release(&icache.lock);
 233       return ip;
 234     }
 235     if(empty == 0 && ip->ref == 0)    // Remember empty slot.
empty = ip;
 237   }
 239   // Recycle an inode cache entry.
 240   if(empty == 0)
panic("iget: no inodes");
ip = empty;
ip->dev = dev;
ip->inum = inum;
ip->ref = 1;
ip->flags = 0;
release(&icache.lock);
 250   return ip;
 251 }
 253 // Increment reference count for ip.
 254 // Returns ip to enable ip = idup(ip1) idiom.
 255 struct inode*
idup(struct inode *ip)
 257 {
acquire(&icache.lock);
ip->ref++;
release(&icache.lock);
 261   return ip;
 262 }
 264 // Lock the given inode.
 265 // Reads the inode from disk if necessary.
 266 void
ilock(struct inode *ip)
 268 {
 269   struct buf *bp;
 270   struct dinode *dip;
 272   if(ip == 0 || ip->ref < 1)
panic("ilock");
acquire(&icache.lock);
 276   while(ip->flags & I_BUSY)
sleep(ip, &icache.lock);
ip->flags |= I_BUSY;
release(&icache.lock);
 281   if(!(ip->flags & I_VALID)){
bp = bread(ip->dev, IBLOCK(ip->inum, sb));
dip = (struct dinode*)bp->data + ip->inum%IPB;
ip->type = dip->type;
ip->major = dip->major;
ip->minor = dip->minor;
ip->nlink = dip->nlink;
ip->size = dip->size;
memmove(ip->addrs, dip->addrs, sizeof(ip->addrs));
brelse(bp);
ip->flags |= I_VALID;
 292     if(ip->type == 0)
panic("ilock: no type");
 294   }
 295 }
 297 // Unlock the given inode.
 298 void
iunlock(struct inode *ip)
 300 {
 301   if(ip == 0 || !(ip->flags & I_BUSY) || ip->ref < 1)
panic("iunlock");
acquire(&icache.lock);
ip->flags &= ~I_BUSY;
wakeup(ip);
release(&icache.lock);
 308 }
 310 // Drop a reference to an in-memory inode.
 311 // If that was the last reference, the inode cache entry can
 312 // be recycled.
 313 // If that was the last reference and the inode has no links
 314 // to it, free the inode (and its content) on disk.
 315 // All calls to iput() must be inside a transaction in
 316 // case it has to free the inode.
 317 void
iput(struct inode *ip)
 319 {
acquire(&icache.lock);
 321   if(ip->ref == 1 && (ip->flags & I_VALID) && ip->nlink == 0){
 322     // inode has no links and no other references: truncate and free.
 323     if(ip->flags & I_BUSY)
panic("iput busy");
ip->flags |= I_BUSY;
release(&icache.lock);
itrunc(ip);
ip->type = 0;
iupdate(ip);
acquire(&icache.lock);
ip->flags = 0;
wakeup(ip);
 333   }
ip->ref--;
release(&icache.lock);
 336 }
 338 // Common idiom: unlock, then put.
 339 void
iunlockput(struct inode *ip)
 341 {
iunlock(ip);
iput(ip);
 344 }
 346 //PAGEBREAK!
 347 // Inode content
 348 //
 349 // The content (data) associated with each inode is stored
 350 // in blocks on the disk. The first NDIRECT block numbers
 351 // are listed in ip->addrs[].  The next NINDIRECT blocks are 
 352 // listed in block ip->addrs[NDIRECT].
 354 // Return the disk block address of the nth block in inode ip.
 355 // If there is no such block, bmap allocates one.
 356 static uint
bmap(struct inode *ip, uint bn)
 358 {
uint addr, *a;
 360   struct buf *bp;
 362   if(bn < NDIRECT){
 363     if((addr = ip->addrs[bn]) == 0)
ip->addrs[bn] = addr = balloc(ip->dev);
 365     return addr;
 366   }
bn -= NDIRECT;
 369   if(bn < NINDIRECT){
 370     // Load indirect block, allocating if necessary.
 371     if((addr = ip->addrs[NDIRECT]) == 0)
ip->addrs[NDIRECT] = addr = balloc(ip->dev);
bp = bread(ip->dev, addr);
a = (uint*)bp->data;
 375     if((addr = a[bn]) == 0){
a[bn] = addr = balloc(ip->dev);
log_write(bp);
 378     }
brelse(bp);
 380     return addr;
 381   }
panic("bmap: out of range");
 384 }
 386 // Truncate inode (discard contents).
 387 // Only called when the inode has no links
 388 // to it (no directory entries referring to it)
 389 // and has no in-memory reference to it (is
 390 // not an open file or current directory).
 391 static void
itrunc(struct inode *ip)
 393 {
 394   int i, j;
 395   struct buf *bp;
uint *a;
 398   for(i = 0; i < NDIRECT; i++){
 399     if(ip->addrs[i]){
bfree(ip->dev, ip->addrs[i]);
ip->addrs[i] = 0;
 402     }
 403   }
 405   if(ip->addrs[NDIRECT]){
bp = bread(ip->dev, ip->addrs[NDIRECT]);
a = (uint*)bp->data;
 408     for(j = 0; j < NINDIRECT; j++){
 409       if(a[j])
bfree(ip->dev, a[j]);
 411     }
brelse(bp);
bfree(ip->dev, ip->addrs[NDIRECT]);
ip->addrs[NDIRECT] = 0;
 415   }
ip->size = 0;
iupdate(ip);
 419 }
 421 // Copy stat information from inode.
 422 void
stati(struct inode *ip, struct stat *st)
 424 {
st->dev = ip->dev;
st->ino = ip->inum;
st->type = ip->type;
st->nlink = ip->nlink;
st->size = ip->size;
 430 }
 432 //PAGEBREAK!
 433 // Read data from inode.
 434 int
readi(struct inode *ip, char *dst, uint off, uint n)
 436 {
uint tot, m;
 438   struct buf *bp;
 440   if(ip->type == T_DEV){
 441     if(ip->major < 0 || ip->major >= NDEV || !devsw[ip->major].read)
 442       return -1;
 443     return devsw[ip->major].read(ip, dst, n);
 444   }
 446   if(off > ip->size || off + n < off)
 447     return -1;
 448   if(off + n > ip->size)
n = ip->size - off;
 451   for(tot=0; tot<n; tot+=m, off+=m, dst+=m){
bp = bread(ip->dev, bmap(ip, off/BSIZE));
m = min(n - tot, BSIZE - off%BSIZE);
memmove(dst, bp->data + off%BSIZE, m);
brelse(bp);
 456   }
 457   return n;
 458 }
 460 // PAGEBREAK!
 461 // Write data to inode.
 462 int
writei(struct inode *ip, char *src, uint off, uint n)
 464 {
uint tot, m;
 466   struct buf *bp;
 468   if(ip->type == T_DEV){
 469     if(ip->major < 0 || ip->major >= NDEV || !devsw[ip->major].write)
 470       return -1;
 471     return devsw[ip->major].write(ip, src, n);
 472   }
 474   if(off > ip->size || off + n < off)
 475     return -1;
 476   if(off + n > MAXFILE*BSIZE)
 477     return -1;
 479   for(tot=0; tot<n; tot+=m, off+=m, src+=m){
bp = bread(ip->dev, bmap(ip, off/BSIZE));
m = min(n - tot, BSIZE - off%BSIZE);
memmove(bp->data + off%BSIZE, src, m);
log_write(bp);
brelse(bp);
 485   }
 487   if(n > 0 && off > ip->size){
ip->size = off;
iupdate(ip);
 490   }
 491   return n;
 492 }
 494 //PAGEBREAK!
 495 // Directories
 497 int
namecmp(const char *s, const char *t)
 499 {
 500   return strncmp(s, t, DIRSIZ);
 501 }
 503 // Look for a directory entry in a directory.
 504 // If found, set *poff to byte offset of entry.
 505 struct inode*
dirlookup(struct inode *dp, char *name, uint *poff)
 507 {
uint off, inum;
 509   struct dirent de;
 511   if(dp->type != T_DIR)
panic("dirlookup not DIR");
 514   for(off = 0; off < dp->size; off += sizeof(de)){
 515     if(readi(dp, (char*)&de, off, sizeof(de)) != sizeof(de))
panic("dirlink read");
 517     if(de.inum == 0)
 518       continue;
 519     if(namecmp(name, de.name) == 0){
 520       // entry matches path element
 521       if(poff)
 522         *poff = off;
inum = de.inum;
 524       return iget(dp->dev, inum);
 525     }
 526   }
 528   return 0;
 529 }
 531 // Write a new directory entry (name, inum) into the directory dp.
 532 int
dirlink(struct inode *dp, char *name, uint inum)
 534 {
 535   int off;
 536   struct dirent de;
 537   struct inode *ip;
 539   // Check that name is not present.
 540   if((ip = dirlookup(dp, name, 0)) != 0){
iput(ip);
 542     return -1;
 543   }
 545   // Look for an empty dirent.
 546   for(off = 0; off < dp->size; off += sizeof(de)){
 547     if(readi(dp, (char*)&de, off, sizeof(de)) != sizeof(de))
panic("dirlink read");
 549     if(de.inum == 0)
 550       break;
 551   }
strncpy(de.name, name, DIRSIZ);
de.inum = inum;
 555   if(writei(dp, (char*)&de, off, sizeof(de)) != sizeof(de))
panic("dirlink");
 558   return 0;
 559 }
 561 //PAGEBREAK!
 562 // Paths
 564 // Copy the next path element from path into name.
 565 // Return a pointer to the element following the copied one.
 566 // The returned path has no leading slashes,
 567 // so the caller can check *path=='\0' to see if the name is the last one.
 568 // If no name to remove, return 0.
 569 //
 570 // Examples:
 571 //   skipelem("a/bb/c", name) = "bb/c", setting name = "a"
 572 //   skipelem("///a//bb", name) = "bb", setting name = "a"
 573 //   skipelem("a", name) = "", setting name = "a"
 574 //   skipelem("", name) = skipelem("////", name) = 0
 575 //
 576 static char*
skipelem(char *path, char *name)
 578 {
 579   char *s;
 580   int len;
 582   while(*path == '/')
path++;
 584   if(*path == 0)
 585     return 0;
s = path;
 587   while(*path != '/' && *path != 0)
path++;
len = path - s;
 590   if(len >= DIRSIZ)
memmove(name, s, DIRSIZ);
 592   else {
memmove(name, s, len);
name[len] = 0;
 595   }
 596   while(*path == '/')
path++;
 598   return path;
 599 }
 601 // Look up and return the inode for a path name.
 602 // If parent != 0, return the inode for the parent and copy the final
 603 // path element into name, which must have room for DIRSIZ bytes.
 604 // Must be called inside a transaction since it calls iput().
 605 static struct inode*
namex(char *path, int nameiparent, char *name)
 607 {
 608   struct inode *ip, *next;
 610   if(*path == '/')
ip = iget(ROOTDEV, ROOTINO);
 612   else
ip = idup(proc->cwd);
 615   while((path = skipelem(path, name)) != 0){
ilock(ip);
 617     if(ip->type != T_DIR){
iunlockput(ip);
 619       return 0;
 620     }
 621     if(nameiparent && *path == '\0'){
 622       // Stop one level early.
iunlock(ip);
 624       return ip;
 625     }
 626     if((next = dirlookup(ip, name, 0)) == 0){
iunlockput(ip);
 628       return 0;
 629     }
iunlockput(ip);
ip = next;
 632   }
 633   if(nameiparent){
iput(ip);
 635     return 0;
 636   }
 637   return ip;
 638 }
 640 struct inode*
namei(char *path)
 642 {
 643   char name[DIRSIZ];
 644   return namex(path, 0, name);
 645 }
 647 struct inode*
nameiparent(char *path, char *name)
 649 {
 650   return namex(path, 1, name);
 651 }