1*a5fbfe41SRobert Morris // File system implementation. Five layers: 2bcca6c6bSrsc // + Blocks: allocator for raw disk blocks. 3*a5fbfe41SRobert Morris // + Log: crash recovery for multi-step updates. 4bcca6c6bSrsc // + Files: inode allocator, reading, writing, metadata. 5bcca6c6bSrsc // + Directories: inode with special contents (list of other inodes!) 6bcca6c6bSrsc // + Names: paths like /usr/rtm/xv6/fs.c for convenient naming. 7bcca6c6bSrsc // 8eaea18cbSrsc // This file contains the low-level file system manipulation 9eaea18cbSrsc // routines. The (higher-level) system call implementations 10eaea18cbSrsc // are in sysfile.c. 11bcca6c6bSrsc 1211a9947fSrtm #include "types.h" 13558ab49fSrsc #include "defs.h" 1411a9947fSrtm #include "param.h" 15558ab49fSrsc #include "stat.h" 1611a9947fSrtm #include "mmu.h" 1711a9947fSrtm #include "proc.h" 1811a9947fSrtm #include "spinlock.h" 1911a9947fSrtm #include "buf.h" 2011a9947fSrtm #include "fs.h" 210aef8914SRuss Cox #include "file.h" 2211a9947fSrtm 23bcca6c6bSrsc #define min(a, b) ((a) < (b) ? (a) : (b)) 24fbf91039Srsc static void itrunc(struct inode*); 2511a9947fSrtm 26a505fd66Srsc // Read the super block. 2713a96baeSFrans Kaashoek void 28a505fd66Srsc readsb(int dev, struct superblock *sb) 29a505fd66Srsc { 30a505fd66Srsc struct buf *bp; 31a505fd66Srsc 32a505fd66Srsc bp = bread(dev, 1); 33a505fd66Srsc memmove(sb, bp->data, sizeof(*sb)); 34a505fd66Srsc brelse(bp); 35a505fd66Srsc } 36a505fd66Srsc 37a505fd66Srsc // Zero a block. 38a505fd66Srsc static void 39a505fd66Srsc bzero(int dev, int bno) 40a505fd66Srsc { 41a505fd66Srsc struct buf *bp; 42a505fd66Srsc 43a505fd66Srsc bp = bread(dev, bno); 44a505fd66Srsc memset(bp->data, 0, BSIZE); 455053dd6aSRobert Morris log_write(bp); 46a505fd66Srsc brelse(bp); 47a505fd66Srsc } 48a505fd66Srsc 49bcca6c6bSrsc // Blocks. 505be0039cSrtm 515053dd6aSRobert Morris // Allocate a zeroed disk block. 5224111398Skaashoek static uint 5324111398Skaashoek balloc(uint dev) 5424111398Skaashoek { 55a505fd66Srsc int b, bi, m; 5624111398Skaashoek struct buf *bp; 57a505fd66Srsc struct superblock sb; 5824111398Skaashoek 59a505fd66Srsc bp = 0; 60a505fd66Srsc readsb(dev, &sb); 61a505fd66Srsc for(b = 0; b < sb.size; b += BPB){ 62a505fd66Srsc bp = bread(dev, BBLOCK(b, sb.ninodes)); 63*a5fbfe41SRobert Morris for(bi = 0; bi < BPB && b + bi < sb.size; bi++){ 64a505fd66Srsc m = 1 << (bi % 8); 65a505fd66Srsc if((bp->data[bi/8] & m) == 0){ // Is block free? 66*a5fbfe41SRobert Morris bp->data[bi/8] |= m; // Mark block in use. 6713a96baeSFrans Kaashoek log_write(bp); 6824111398Skaashoek brelse(bp); 695053dd6aSRobert Morris bzero(dev, b + bi); 70a505fd66Srsc return b + bi; 7124111398Skaashoek } 72a505fd66Srsc } 7328d9ef04Skaashoek brelse(bp); 747d4aef6cSrsc } 757d4aef6cSrsc panic("balloc: out of blocks"); 767d4aef6cSrsc } 7724111398Skaashoek 78bb207a1dSrsc // Free a disk block. 7928d9ef04Skaashoek static void 8028d9ef04Skaashoek bfree(int dev, uint b) 8128d9ef04Skaashoek { 8228d9ef04Skaashoek struct buf *bp; 83a505fd66Srsc struct superblock sb; 84a505fd66Srsc int bi, m; 8528d9ef04Skaashoek 86a505fd66Srsc readsb(dev, &sb); 87a505fd66Srsc bp = bread(dev, BBLOCK(b, sb.ninodes)); 8828d9ef04Skaashoek bi = b % BPB; 89a505fd66Srsc m = 1 << (bi % 8); 90902b13f5Srtm if((bp->data[bi/8] & m) == 0) 91902b13f5Srtm panic("freeing free block"); 92*a5fbfe41SRobert Morris bp->data[bi/8] &= ~m; 9313a96baeSFrans Kaashoek log_write(bp); 9428d9ef04Skaashoek brelse(bp); 9528d9ef04Skaashoek } 9624111398Skaashoek 976c34f97cSrsc // Inodes. 986c34f97cSrsc // 99*a5fbfe41SRobert Morris // An inode describes a single unnamed file. 100*a5fbfe41SRobert Morris // The inode disk structure holds metadata: the file's type, 101*a5fbfe41SRobert Morris // its size, the number of links referring to it, and the 102*a5fbfe41SRobert Morris // list of blocks holding the file's content. 103bcca6c6bSrsc // 104bcca6c6bSrsc // The inodes are laid out sequentially on disk immediately after 105*a5fbfe41SRobert Morris // the superblock. Each inode has a number, indicating its 106*a5fbfe41SRobert Morris // position on the disk. 107*a5fbfe41SRobert Morris // 108*a5fbfe41SRobert Morris // The kernel keeps a cache of in-use inodes in memory 109*a5fbfe41SRobert Morris // to provide a place for synchronizing access 110*a5fbfe41SRobert Morris // to inodes used by multiple processes. The cached 111*a5fbfe41SRobert Morris // inodes include book-keeping information that is 112*a5fbfe41SRobert Morris // not stored on disk: ip->ref and ip->flags. 113bcca6c6bSrsc // 114902b13f5Srtm // ip->ref counts the number of pointer references to this cached 11548755214SRuss Cox // inode; references are typically kept in struct file and in proc->cwd. 116bcca6c6bSrsc // When ip->ref falls to zero, the inode is no longer cached. 117bcca6c6bSrsc // It is an error to use an inode without holding a reference to it. 118bcca6c6bSrsc // 119eaea18cbSrsc // Processes are only allowed to read and write inode 1201ddfbbb1SFrans Kaashoek // metadata and contents when holding the inode's lock, 121*a5fbfe41SRobert Morris // represented by the I_BUSY bit in ip->flags. 1221ddfbbb1SFrans Kaashoek // Because inode locks are held during disk accesses, 1231ddfbbb1SFrans Kaashoek // they are implemented using a flag rather than with 124*a5fbfe41SRobert Morris // spin locks. ilock() and iunlock() manipulate an 125*a5fbfe41SRobert Morris // inode's I_BUSY flag. Many routines in this file expect 126*a5fbfe41SRobert Morris // the caller to have already locked the inode; leaving 127eaea18cbSrsc // this responsibility with the caller makes it possible for them 128eaea18cbSrsc // to create arbitrarily-sized atomic operations. 129eaea18cbSrsc // 130eaea18cbSrsc // To give maximum control over locking to the callers, 131eaea18cbSrsc // the routines in this file that return inode pointers 132eaea18cbSrsc // return pointers to *unlocked* inodes. It is the callers' 133902b13f5Srtm // responsibility to lock them before using them. A non-zero 134902b13f5Srtm // ip->ref keeps these unlocked inodes in the cache. 135*a5fbfe41SRobert Morris // 136*a5fbfe41SRobert Morris // In order for the file system code to look at an inode, the inode 137*a5fbfe41SRobert Morris // must pass through a number of states, with transitions 138*a5fbfe41SRobert Morris // driven by the indicated functions: 139*a5fbfe41SRobert Morris // 140*a5fbfe41SRobert Morris // * Allocated on disk, indicated by a non-zero type. 141*a5fbfe41SRobert Morris // ialloc() and iput(). 142*a5fbfe41SRobert Morris // * Referenced in the cache, indicated by ip->ref > 0. 143*a5fbfe41SRobert Morris // iget() and iput(). 144*a5fbfe41SRobert Morris // * Cached inode is valid, indicated by I_VALID. 145*a5fbfe41SRobert Morris // ilock() and iput(). 146*a5fbfe41SRobert Morris // * Locked, indicated by I_BUSY. 147*a5fbfe41SRobert Morris // ilock() and iunlock(). 148bcca6c6bSrsc 149bcca6c6bSrsc struct { 150bcca6c6bSrsc struct spinlock lock; 151bcca6c6bSrsc struct inode inode[NINODE]; 152bcca6c6bSrsc } icache; 153bcca6c6bSrsc 154bcca6c6bSrsc void 155bcca6c6bSrsc iinit(void) 156bcca6c6bSrsc { 15734295f46Srsc initlock(&icache.lock, "icache"); 158bcca6c6bSrsc } 159bcca6c6bSrsc 160f9a06440SRuss Cox static struct inode* iget(uint dev, uint inum); 161f9a06440SRuss Cox 162f9a06440SRuss Cox //PAGEBREAK! 163f9a06440SRuss Cox // Allocate a new inode with the given type on device dev. 164*a5fbfe41SRobert Morris // A free inode has a type of zero. 165f9a06440SRuss Cox struct inode* 166f9a06440SRuss Cox ialloc(uint dev, short type) 167f9a06440SRuss Cox { 168f9a06440SRuss Cox int inum; 169f9a06440SRuss Cox struct buf *bp; 170f9a06440SRuss Cox struct dinode *dip; 171f9a06440SRuss Cox struct superblock sb; 172f9a06440SRuss Cox 173f9a06440SRuss Cox readsb(dev, &sb); 174*a5fbfe41SRobert Morris 175*a5fbfe41SRobert Morris for(inum = 1; inum < sb.ninodes; inum++){ 176f9a06440SRuss Cox bp = bread(dev, IBLOCK(inum)); 177f9a06440SRuss Cox dip = (struct dinode*)bp->data + inum%IPB; 178f9a06440SRuss Cox if(dip->type == 0){ // a free inode 179f9a06440SRuss Cox memset(dip, 0, sizeof(*dip)); 180f9a06440SRuss Cox dip->type = type; 18113a96baeSFrans Kaashoek log_write(bp); // mark it allocated on the disk 182f9a06440SRuss Cox brelse(bp); 183f9a06440SRuss Cox return iget(dev, inum); 184f9a06440SRuss Cox } 185f9a06440SRuss Cox brelse(bp); 186f9a06440SRuss Cox } 187f9a06440SRuss Cox panic("ialloc: no inodes"); 188f9a06440SRuss Cox } 189f9a06440SRuss Cox 190f9a06440SRuss Cox // Copy inode, which has changed, from memory to disk. 191f9a06440SRuss Cox void 192f9a06440SRuss Cox iupdate(struct inode *ip) 193f9a06440SRuss Cox { 194f9a06440SRuss Cox struct buf *bp; 195f9a06440SRuss Cox struct dinode *dip; 196f9a06440SRuss Cox 197f9a06440SRuss Cox bp = bread(ip->dev, IBLOCK(ip->inum)); 198f9a06440SRuss Cox dip = (struct dinode*)bp->data + ip->inum%IPB; 199f9a06440SRuss Cox dip->type = ip->type; 200f9a06440SRuss Cox dip->major = ip->major; 201f9a06440SRuss Cox dip->minor = ip->minor; 202f9a06440SRuss Cox dip->nlink = ip->nlink; 203f9a06440SRuss Cox dip->size = ip->size; 204f9a06440SRuss Cox memmove(dip->addrs, ip->addrs, sizeof(ip->addrs)); 20513a96baeSFrans Kaashoek log_write(bp); 206f9a06440SRuss Cox brelse(bp); 207f9a06440SRuss Cox } 208f9a06440SRuss Cox 209f5527388Srsc // Find the inode with number inum on device dev 2107895178dSrsc // and return the in-memory copy. 21107090dd7Srsc static struct inode* 21211a9947fSrtm iget(uint dev, uint inum) 21311a9947fSrtm { 214bcca6c6bSrsc struct inode *ip, *empty; 21511a9947fSrtm 216bcca6c6bSrsc acquire(&icache.lock); 21711a9947fSrtm 218bcca6c6bSrsc // Try for cached inode. 219bcca6c6bSrsc empty = 0; 220bcca6c6bSrsc for(ip = &icache.inode[0]; ip < &icache.inode[NINODE]; ip++){ 2210d6bbd31Srsc if(ip->ref > 0 && ip->dev == dev && ip->inum == inum){ 2220d6bbd31Srsc ip->ref++; 223bcca6c6bSrsc release(&icache.lock); 22407090dd7Srsc return ip; 22511a9947fSrtm } 226bcca6c6bSrsc if(empty == 0 && ip->ref == 0) // Remember empty slot. 227bcca6c6bSrsc empty = ip; 22811a9947fSrtm } 22911a9947fSrtm 230bcca6c6bSrsc // Allocate fresh inode. 231bcca6c6bSrsc if(empty == 0) 23232eea766Srsc panic("iget: no inodes"); 23311a9947fSrtm 234bcca6c6bSrsc ip = empty; 235bcca6c6bSrsc ip->dev = dev; 236bcca6c6bSrsc ip->inum = inum; 237bcca6c6bSrsc ip->ref = 1; 238f32f3638Srsc ip->flags = 0; 239bcca6c6bSrsc release(&icache.lock); 24011a9947fSrtm 24107090dd7Srsc return ip; 242f32f3638Srsc } 243f32f3638Srsc 244eaea18cbSrsc // Increment reference count for ip. 245eaea18cbSrsc // Returns ip to enable ip = idup(ip1) idiom. 24607090dd7Srsc struct inode* 24707090dd7Srsc idup(struct inode *ip) 248f32f3638Srsc { 249eaea18cbSrsc acquire(&icache.lock); 250eaea18cbSrsc ip->ref++; 251eaea18cbSrsc release(&icache.lock); 25207090dd7Srsc return ip; 253f32f3638Srsc } 254f32f3638Srsc 2551ddfbbb1SFrans Kaashoek // Lock the given inode. 25607090dd7Srsc void 25707090dd7Srsc ilock(struct inode *ip) 258f32f3638Srsc { 259f32f3638Srsc struct buf *bp; 260f32f3638Srsc struct dinode *dip; 261eaea18cbSrsc 26207090dd7Srsc if(ip == 0 || ip->ref < 1) 26307090dd7Srsc panic("ilock"); 264f32f3638Srsc 265f32f3638Srsc acquire(&icache.lock); 2661ddfbbb1SFrans Kaashoek while(ip->flags & I_BUSY) 2671ddfbbb1SFrans Kaashoek sleep(ip, &icache.lock); 2681ddfbbb1SFrans Kaashoek ip->flags |= I_BUSY; 269f32f3638Srsc release(&icache.lock); 270f32f3638Srsc 271f32f3638Srsc if(!(ip->flags & I_VALID)){ 272f32f3638Srsc bp = bread(ip->dev, IBLOCK(ip->inum)); 2733341e30fSrsc dip = (struct dinode*)bp->data + ip->inum%IPB; 274bcca6c6bSrsc ip->type = dip->type; 275bcca6c6bSrsc ip->major = dip->major; 276bcca6c6bSrsc ip->minor = dip->minor; 277bcca6c6bSrsc ip->nlink = dip->nlink; 278bcca6c6bSrsc ip->size = dip->size; 279bcca6c6bSrsc memmove(ip->addrs, dip->addrs, sizeof(ip->addrs)); 28011a9947fSrtm brelse(bp); 281f32f3638Srsc ip->flags |= I_VALID; 282eaea18cbSrsc if(ip->type == 0) 283eaea18cbSrsc panic("ilock: no type"); 28411a9947fSrtm } 285bcca6c6bSrsc } 286bcca6c6bSrsc 287bcca6c6bSrsc // Unlock the given inode. 28807090dd7Srsc void 289bcca6c6bSrsc iunlock(struct inode *ip) 290bcca6c6bSrsc { 2911ddfbbb1SFrans Kaashoek if(ip == 0 || !(ip->flags & I_BUSY) || ip->ref < 1) 292bcca6c6bSrsc panic("iunlock"); 293bcca6c6bSrsc 294bcca6c6bSrsc acquire(&icache.lock); 2951ddfbbb1SFrans Kaashoek ip->flags &= ~I_BUSY; 2961ddfbbb1SFrans Kaashoek wakeup(ip); 297bcca6c6bSrsc release(&icache.lock); 298bcca6c6bSrsc } 299bcca6c6bSrsc 300f32f3638Srsc // Caller holds reference to unlocked ip. Drop reference. 301bcca6c6bSrsc void 30207090dd7Srsc iput(struct inode *ip) 303bcca6c6bSrsc { 304f32f3638Srsc acquire(&icache.lock); 305f32f3638Srsc if(ip->ref == 1 && (ip->flags & I_VALID) && ip->nlink == 0){ 306f32f3638Srsc // inode is no longer used: truncate and free inode. 3071ddfbbb1SFrans Kaashoek if(ip->flags & I_BUSY) 308eaea18cbSrsc panic("iput busy"); 3091ddfbbb1SFrans Kaashoek ip->flags |= I_BUSY; 310f32f3638Srsc release(&icache.lock); 311f32f3638Srsc itrunc(ip); 312f32f3638Srsc ip->type = 0; 313f32f3638Srsc iupdate(ip); 314f32f3638Srsc acquire(&icache.lock); 315ce72cadbSrsc ip->flags = 0; 3168970df0cSrsc wakeup(ip); 317f32f3638Srsc } 318f32f3638Srsc ip->ref--; 319f32f3638Srsc release(&icache.lock); 320bcca6c6bSrsc } 321bcca6c6bSrsc 3227895178dSrsc // Common idiom: unlock, then put. 32307090dd7Srsc void 32407090dd7Srsc iunlockput(struct inode *ip) 32507090dd7Srsc { 32607090dd7Srsc iunlock(ip); 32707090dd7Srsc iput(ip); 32807090dd7Srsc } 32907090dd7Srsc 3308d2e9a48Srsc //PAGEBREAK! 331bcca6c6bSrsc // Inode contents 332bcca6c6bSrsc // 333bcca6c6bSrsc // The contents (data) associated with each inode is stored 334bcca6c6bSrsc // in a sequence of blocks on the disk. The first NDIRECT blocks 3357895178dSrsc // are listed in ip->addrs[]. The next NINDIRECT blocks are 336745e73cdSAustin Clements // listed in the block ip->addrs[NDIRECT]. 3379d3fb671Srtm 338bb207a1dSrsc // Return the disk block address of the nth block in inode ip. 33913ae8808Srsc // If there is no such block, bmap allocates one. 340eaea18cbSrsc static uint 34113ae8808Srsc bmap(struct inode *ip, uint bn) 34222bac2cbSkaashoek { 343bcca6c6bSrsc uint addr, *a; 344bcca6c6bSrsc struct buf *bp; 34522bac2cbSkaashoek 346ea2909b6Skaashoek if(bn < NDIRECT){ 34713ae8808Srsc if((addr = ip->addrs[bn]) == 0) 348bcca6c6bSrsc ip->addrs[bn] = addr = balloc(ip->dev); 349bcca6c6bSrsc return addr; 350bcca6c6bSrsc } 351bcca6c6bSrsc bn -= NDIRECT; 352bcca6c6bSrsc 353bcca6c6bSrsc if(bn < NINDIRECT){ 354bcca6c6bSrsc // Load indirect block, allocating if necessary. 35513ae8808Srsc if((addr = ip->addrs[NDIRECT]) == 0) 356ba6cd8a6Srsc ip->addrs[NDIRECT] = addr = balloc(ip->dev); 357bcca6c6bSrsc bp = bread(ip->dev, addr); 358bcca6c6bSrsc a = (uint*)bp->data; 359bcca6c6bSrsc if((addr = a[bn]) == 0){ 360bcca6c6bSrsc a[bn] = addr = balloc(ip->dev); 36113a96baeSFrans Kaashoek log_write(bp); 362bcca6c6bSrsc } 363bcca6c6bSrsc brelse(bp); 364bcca6c6bSrsc return addr; 36522bac2cbSkaashoek } 36622bac2cbSkaashoek 367bcca6c6bSrsc panic("bmap: out of range"); 368bcca6c6bSrsc } 369bcca6c6bSrsc 370bcca6c6bSrsc // Truncate inode (discard contents). 3718eb20827Srtm // Only called after the last dirent referring 3728eb20827Srtm // to this inode has been erased on disk. 373fbf91039Srsc static void 3742aa4c3bcSrtm itrunc(struct inode *ip) 37522bac2cbSkaashoek { 376ea2909b6Skaashoek int i, j; 377bcca6c6bSrsc struct buf *bp; 3787d4aef6cSrsc uint *a; 37922bac2cbSkaashoek 380bcca6c6bSrsc for(i = 0; i < NDIRECT; i++){ 381bcca6c6bSrsc if(ip->addrs[i]){ 38222bac2cbSkaashoek bfree(ip->dev, ip->addrs[i]); 38322bac2cbSkaashoek ip->addrs[i] = 0; 38422bac2cbSkaashoek } 38522bac2cbSkaashoek } 386bcca6c6bSrsc 387ba6cd8a6Srsc if(ip->addrs[NDIRECT]){ 388ba6cd8a6Srsc bp = bread(ip->dev, ip->addrs[NDIRECT]); 389bcca6c6bSrsc a = (uint*)bp->data; 390bcca6c6bSrsc for(j = 0; j < NINDIRECT; j++){ 391bcca6c6bSrsc if(a[j]) 392bcca6c6bSrsc bfree(ip->dev, a[j]); 393bcca6c6bSrsc } 394bcca6c6bSrsc brelse(bp); 395ba6cd8a6Srsc bfree(ip->dev, ip->addrs[NDIRECT]); 396ba6cd8a6Srsc ip->addrs[NDIRECT] = 0; 397bcca6c6bSrsc } 398bcca6c6bSrsc 39922bac2cbSkaashoek ip->size = 0; 40022bac2cbSkaashoek iupdate(ip); 40122bac2cbSkaashoek } 40222bac2cbSkaashoek 403bb207a1dSrsc // Copy stat information from inode. 404e958c538Skaashoek void 4051f544842Skaashoek stati(struct inode *ip, struct stat *st) 4061f544842Skaashoek { 4071dca3afbSrsc st->dev = ip->dev; 4081dca3afbSrsc st->ino = ip->inum; 4091dca3afbSrsc st->type = ip->type; 4101dca3afbSrsc st->nlink = ip->nlink; 4111dca3afbSrsc st->size = ip->size; 4121f544842Skaashoek } 4131f544842Skaashoek 414eaea18cbSrsc //PAGEBREAK! 415bb207a1dSrsc // Read data from inode. 416c59361f1Srtm int 41717a85657Srtm readi(struct inode *ip, char *dst, uint off, uint n) 418c59361f1Srtm { 419bcca6c6bSrsc uint tot, m; 420c59361f1Srtm struct buf *bp; 421c59361f1Srtm 422939f9edeSkaashoek if(ip->type == T_DEV){ 4231dca3afbSrsc if(ip->major < 0 || ip->major >= NDEV || !devsw[ip->major].read) 424939f9edeSkaashoek return -1; 425d844f0f9Srsc return devsw[ip->major].read(ip, dst, n); 426939f9edeSkaashoek } 427939f9edeSkaashoek 4287895178dSrsc if(off > ip->size || off + n < off) 429bcca6c6bSrsc return -1; 430bcca6c6bSrsc if(off + n > ip->size) 431bcca6c6bSrsc n = ip->size - off; 432bcca6c6bSrsc 433bcca6c6bSrsc for(tot=0; tot<n; tot+=m, off+=m, dst+=m){ 43413ae8808Srsc bp = bread(ip->dev, bmap(ip, off/BSIZE)); 435bcca6c6bSrsc m = min(n - tot, BSIZE - off%BSIZE); 436bcca6c6bSrsc memmove(dst, bp->data + off%BSIZE, m); 437c59361f1Srtm brelse(bp); 438c59361f1Srtm } 439bcca6c6bSrsc return n; 440ea2909b6Skaashoek } 441ea2909b6Skaashoek 442eaea18cbSrsc // PAGEBREAK! 443bb207a1dSrsc // Write data to inode. 444ea2909b6Skaashoek int 445bcca6c6bSrsc writei(struct inode *ip, char *src, uint off, uint n) 4466fa5ffb5Skaashoek { 447bcca6c6bSrsc uint tot, m; 4487d4aef6cSrsc struct buf *bp; 4497d4aef6cSrsc 4506fa5ffb5Skaashoek if(ip->type == T_DEV){ 4511dca3afbSrsc if(ip->major < 0 || ip->major >= NDEV || !devsw[ip->major].write) 452939f9edeSkaashoek return -1; 453d844f0f9Srsc return devsw[ip->major].write(ip, src, n); 4547d4aef6cSrsc } 4557d4aef6cSrsc 4561ddfbbb1SFrans Kaashoek if(off > ip->size || off + n < off) 457bcca6c6bSrsc return -1; 4581ddfbbb1SFrans Kaashoek if(off + n > MAXFILE*BSIZE) 4592e590463SRobert Morris return -1; 460bcca6c6bSrsc 461bcca6c6bSrsc for(tot=0; tot<n; tot+=m, off+=m, src+=m){ 46213ae8808Srsc bp = bread(ip->dev, bmap(ip, off/BSIZE)); 463bcca6c6bSrsc m = min(n - tot, BSIZE - off%BSIZE); 464bcca6c6bSrsc memmove(bp->data + off%BSIZE, src, m); 4652e590463SRobert Morris log_write(bp); 46628d9ef04Skaashoek brelse(bp); 46728d9ef04Skaashoek } 468bcca6c6bSrsc 469bcca6c6bSrsc if(n > 0 && off > ip->size){ 47048b82470Srsc ip->size = off; 47128d9ef04Skaashoek iupdate(ip); 47228d9ef04Skaashoek } 473bcca6c6bSrsc return n; 4746fa5ffb5Skaashoek } 4756fa5ffb5Skaashoek 476eaea18cbSrsc //PAGEBREAK! 477bcca6c6bSrsc // Directories 478bcca6c6bSrsc 479eaea18cbSrsc int 480fbf91039Srsc namecmp(const char *s, const char *t) 481fbf91039Srsc { 482766ba5ccSrsc return strncmp(s, t, DIRSIZ); 483fbf91039Srsc } 484fbf91039Srsc 485bcca6c6bSrsc // Look for a directory entry in a directory. 486eaea18cbSrsc // If found, set *poff to byte offset of entry. 48720365348Srtm // Caller must have already locked dp. 48807090dd7Srsc struct inode* 489fbf91039Srsc dirlookup(struct inode *dp, char *name, uint *poff) 490bcca6c6bSrsc { 491f32f3638Srsc uint off, inum; 492327cc21fSRobert Morris struct dirent de; 493bcca6c6bSrsc 494bcca6c6bSrsc if(dp->type != T_DIR) 49520365348Srtm panic("dirlookup not DIR"); 496bcca6c6bSrsc 497327cc21fSRobert Morris for(off = 0; off < dp->size; off += sizeof(de)){ 498327cc21fSRobert Morris if(readi(dp, (char*)&de, off, sizeof(de)) != sizeof(de)) 499327cc21fSRobert Morris panic("dirlink read"); 500327cc21fSRobert Morris if(de.inum == 0) 501bcca6c6bSrsc continue; 502327cc21fSRobert Morris if(namecmp(name, de.name) == 0){ 503bcca6c6bSrsc // entry matches path element 504e2a620daSrsc if(poff) 505327cc21fSRobert Morris *poff = off; 506327cc21fSRobert Morris inum = de.inum; 507f32f3638Srsc return iget(dp->dev, inum); 508f32f3638Srsc } 509f32f3638Srsc } 510327cc21fSRobert Morris 511bcca6c6bSrsc return 0; 512bcca6c6bSrsc } 513bcca6c6bSrsc 51413ae8808Srsc // Write a new directory entry (name, inum) into the directory dp. 515eaea18cbSrsc int 51613ae8808Srsc dirlink(struct inode *dp, char *name, uint inum) 517bcca6c6bSrsc { 518e2a620daSrsc int off; 519bcca6c6bSrsc struct dirent de; 52007090dd7Srsc struct inode *ip; 521f32f3638Srsc 522eaea18cbSrsc // Check that name is not present. 52307090dd7Srsc if((ip = dirlookup(dp, name, 0)) != 0){ 52407090dd7Srsc iput(ip); 525f32f3638Srsc return -1; 526f32f3638Srsc } 527bcca6c6bSrsc 528bcca6c6bSrsc // Look for an empty dirent. 529bcca6c6bSrsc for(off = 0; off < dp->size; off += sizeof(de)){ 530bcca6c6bSrsc if(readi(dp, (char*)&de, off, sizeof(de)) != sizeof(de)) 5317895178dSrsc panic("dirlink read"); 532bcca6c6bSrsc if(de.inum == 0) 533bcca6c6bSrsc break; 534bcca6c6bSrsc } 535bcca6c6bSrsc 536766ba5ccSrsc strncpy(de.name, name, DIRSIZ); 53713ae8808Srsc de.inum = inum; 538bcca6c6bSrsc if(writei(dp, (char*)&de, off, sizeof(de)) != sizeof(de)) 5397895178dSrsc panic("dirlink"); 540f32f3638Srsc 541f32f3638Srsc return 0; 542bcca6c6bSrsc } 543bcca6c6bSrsc 5448d2e9a48Srsc //PAGEBREAK! 545bcca6c6bSrsc // Paths 546bcca6c6bSrsc 547eaea18cbSrsc // Copy the next path element from path into name. 548eaea18cbSrsc // Return a pointer to the element following the copied one. 549eaea18cbSrsc // The returned path has no leading slashes, 550eaea18cbSrsc // so the caller can check *path=='\0' to see if the name is the last one. 551eaea18cbSrsc // If no name to remove, return 0. 552ab5c2dbbSrsc // 553ab5c2dbbSrsc // Examples: 554eaea18cbSrsc // skipelem("a/bb/c", name) = "bb/c", setting name = "a" 5557895178dSrsc // skipelem("///a//bb", name) = "bb", setting name = "a" 55613ae8808Srsc // skipelem("a", name) = "", setting name = "a" 557eaea18cbSrsc // skipelem("", name) = skipelem("////", name) = 0 558ab5c2dbbSrsc // 559ab5c2dbbSrsc static char* 560fbf91039Srsc skipelem(char *path, char *name) 561ab5c2dbbSrsc { 562fbf91039Srsc char *s; 563fbf91039Srsc int len; 564fbf91039Srsc 565ab5c2dbbSrsc while(*path == '/') 566ab5c2dbbSrsc path++; 567ab5c2dbbSrsc if(*path == 0) 568ab5c2dbbSrsc return 0; 569fbf91039Srsc s = path; 570ab5c2dbbSrsc while(*path != '/' && *path != 0) 571ab5c2dbbSrsc path++; 572fbf91039Srsc len = path - s; 573fbf91039Srsc if(len >= DIRSIZ) 574fbf91039Srsc memmove(name, s, DIRSIZ); 575fbf91039Srsc else { 576fbf91039Srsc memmove(name, s, len); 577fbf91039Srsc name[len] = 0; 578fbf91039Srsc } 579ab5c2dbbSrsc while(*path == '/') 580ab5c2dbbSrsc path++; 581ab5c2dbbSrsc return path; 582ab5c2dbbSrsc } 583ab5c2dbbSrsc 584eaea18cbSrsc // Look up and return the inode for a path name. 585bf2932a6Srsc // If parent != 0, return the inode for the parent and copy the final 586bf2932a6Srsc // path element into name, which must have room for DIRSIZ bytes. 58707090dd7Srsc static struct inode* 588f9a06440SRuss Cox namex(char *path, int nameiparent, char *name) 5899d3fb671Srtm { 59007090dd7Srsc struct inode *ip, *next; 5919d3fb671Srtm 592ab5c2dbbSrsc if(*path == '/') 5932ce40d70Srtm ip = iget(ROOTDEV, ROOTINO); 594f32f3638Srsc else 59548755214SRuss Cox ip = idup(proc->cwd); 5969d3fb671Srtm 597fbf91039Srsc while((path = skipelem(path, name)) != 0){ 59807090dd7Srsc ilock(ip); 59907090dd7Srsc if(ip->type != T_DIR){ 60007090dd7Srsc iunlockput(ip); 601eaea18cbSrsc return 0; 602eaea18cbSrsc } 603f9a06440SRuss Cox if(nameiparent && *path == '\0'){ 604e2a620daSrsc // Stop one level early. 60507090dd7Srsc iunlock(ip); 60607090dd7Srsc return ip; 607ab5c2dbbSrsc } 6087895178dSrsc if((next = dirlookup(ip, name, 0)) == 0){ 60907090dd7Srsc iunlockput(ip); 610eaea18cbSrsc return 0; 611eaea18cbSrsc } 61207090dd7Srsc iunlockput(ip); 61307090dd7Srsc ip = next; 614ab5c2dbbSrsc } 615f9a06440SRuss Cox if(nameiparent){ 61607090dd7Srsc iput(ip); 6175051da6dSrtm return 0; 61820365348Srtm } 61907090dd7Srsc return ip; 6200633b971Skaashoek } 6219d3fb671Srtm 6227895178dSrsc struct inode* 6237895178dSrsc namei(char *path) 6247895178dSrsc { 6257895178dSrsc char name[DIRSIZ]; 62613ae8808Srsc return namex(path, 0, name); 6277895178dSrsc } 628bf2932a6Srsc 6297895178dSrsc struct inode* 6307895178dSrsc nameiparent(char *path, char *name) 6317895178dSrsc { 63213ae8808Srsc return namex(path, 1, name); 6337895178dSrsc } 634