xv6-65oo2/kernel/fs.c

676 lines
16 KiB
C
Raw Normal View History

2011-10-11 10:41:37 +00:00
// File system implementation. Five layers:
2007-08-20 18:23:52 +00:00
// + Blocks: allocator for raw disk blocks.
2011-10-11 10:41:37 +00:00
// + Log: crash recovery for multi-step updates.
2007-08-20 18:23:52 +00:00
// + Files: inode allocator, reading, writing, metadata.
// + Directories: inode with special contents (list of other inodes!)
// + Names: paths like /usr/rtm/xv6/fs.c for convenient naming.
//
// This file contains the low-level file system manipulation
// routines. The (higher-level) system call implementations
// are in sysfile.c.
2007-08-20 18:23:52 +00:00
#include "types.h"
2019-05-31 15:45:42 +00:00
#include "riscv.h"
2007-08-27 23:26:33 +00:00
#include "defs.h"
#include "param.h"
2007-08-27 23:26:33 +00:00
#include "stat.h"
#include "spinlock.h"
#include "proc.h"
#include "sleeplock.h"
#include "fs.h"
#include "buf.h"
#include "file.h"
2007-08-20 18:23:52 +00:00
#define min(a, b) ((a) < (b) ? (a) : (b))
2007-08-21 19:58:55 +00:00
static void itrunc(struct inode*);
// there should be one superblock per disk device, but we run with
// only one device
struct superblock sb;
2006-07-21 22:10:40 +00:00
// Read the super block.
static void
readsb(int dev, struct superblock *sb)
{
struct buf *bp;
bp = bread(dev, 1);
memmove(sb, bp->data, sizeof(*sb));
brelse(bp);
}
// Init fs
void
fsinit(int dev) {
readsb(dev, &sb);
if(sb.magic != FSMAGIC)
panic("invalid file system");
initlog(dev, &sb);
}
// Zero a block.
static void
bzero(int dev, int bno)
{
struct buf *bp;
bp = bread(dev, bno);
memset(bp->data, 0, BSIZE);
log_write(bp);
brelse(bp);
}
// Blocks.
// Allocate a zeroed disk block.
2006-09-06 17:27:19 +00:00
static uint
balloc(uint dev)
2006-08-09 01:09:36 +00:00
{
int b, bi, m;
2006-08-09 01:09:36 +00:00
struct buf *bp;
bp = 0;
for(b = 0; b < sb.size; b += BPB){
bp = bread(dev, BBLOCK(b, sb));
2011-10-11 10:41:37 +00:00
for(bi = 0; bi < BPB && b + bi < sb.size; bi++){
m = 1 << (bi % 8);
if((bp->data[bi/8] & m) == 0){ // Is block free?
2011-10-11 10:41:37 +00:00
bp->data[bi/8] |= m; // Mark block in use.
log_write(bp);
brelse(bp);
bzero(dev, b + bi);
return b + bi;
}
2006-08-09 01:09:36 +00:00
}
brelse(bp);
2006-08-09 01:09:36 +00:00
}
2007-08-10 16:52:31 +00:00
panic("balloc: out of blocks");
2006-08-09 01:09:36 +00:00
}
2006-09-07 14:28:12 +00:00
// Free a disk block.
2006-09-06 17:27:19 +00:00
static void
bfree(int dev, uint b)
{
struct buf *bp;
int bi, m;
bp = bread(dev, BBLOCK(b, sb));
bi = b % BPB;
m = 1 << (bi % 8);
2007-08-24 19:32:36 +00:00
if((bp->data[bi/8] & m) == 0)
panic("freeing free block");
2011-10-11 10:41:37 +00:00
bp->data[bi/8] &= ~m;
log_write(bp);
brelse(bp);
}
2006-08-09 01:09:36 +00:00
2007-08-27 14:23:48 +00:00
// Inodes.
//
2011-10-11 10:41:37 +00:00
// An inode describes a single unnamed file.
// The inode disk structure holds metadata: the file's type,
// its size, the number of links referring to it, and the
// list of blocks holding the file's content.
2007-08-20 18:23:52 +00:00
//
// The inodes are laid out sequentially on disk at
// sb.startinode. Each inode has a number, indicating its
2011-10-11 10:41:37 +00:00
// position on the disk.
//
// The kernel keeps a cache of in-use inodes in memory
// to provide a place for synchronizing access
// to inodes used by multiple processes. The cached
// inodes include book-keeping information that is
2017-08-08 17:34:13 +00:00
// not stored on disk: ip->ref and ip->valid.
2007-08-20 18:23:52 +00:00
//
2017-08-08 17:24:38 +00:00
// An inode and its in-memory representation go through a
2011-10-11 14:11:53 +00:00
// sequence of states before they can be used by the
// rest of the file system code.
//
2011-10-11 14:11:53 +00:00
// * Allocation: an inode is allocated if its type (on disk)
2017-08-08 17:24:38 +00:00
// is non-zero. ialloc() allocates, and iput() frees if
// the reference and link counts have fallen to zero.
2011-10-11 10:41:37 +00:00
//
2011-10-11 14:11:53 +00:00
// * 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
2017-08-08 17:24:38 +00:00
// files and current directories). iget() finds or
// creates a cache entry and increments its ref; iput()
// decrements ref.
2011-10-11 14:11:53 +00:00
//
// * Valid: the information (type, size, &c) in an inode
2017-08-08 17:34:13 +00:00
// cache entry is only correct when ip->valid is 1.
// ilock() reads the inode from
// the disk and sets ip->valid, while iput() clears
// ip->valid if ip->ref has fallen to zero.
2011-10-11 14:11:53 +00:00
//
// * Locked: file system code may only examine and modify
// the information in an inode and its content if it
2016-09-12 00:59:57 +00:00
// has first locked the inode.
2011-10-11 14:11:53 +00:00
//
// 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.
2017-08-08 18:12:25 +00:00
//
// The icache.lock spin-lock protects the allocation of icache
2017-08-09 10:54:45 +00:00
// entries. Since ip->ref indicates whether an entry is free,
// and ip->dev and ip->inum indicate which i-node an entry
// holds, one must hold icache.lock while using any of those fields.
2017-08-08 18:12:25 +00:00
//
// An ip->lock sleep-lock protects all ip-> fields other than ref,
2017-08-08 18:12:25 +00:00
// dev, and inum. One must hold ip->lock in order to
// read or write that inode's ip->valid, ip->size, ip->type, &c.
2007-08-20 18:23:52 +00:00
struct {
struct spinlock lock;
struct inode inode[NINODE];
} icache;
void
iinit()
2007-08-20 18:23:52 +00:00
{
2016-09-12 00:59:57 +00:00
int i = 0;
initlock(&icache.lock, "icache");
2016-09-12 00:59:57 +00:00
for(i = 0; i < NINODE; i++) {
initsleeplock(&icache.inode[i].lock, "inode");
}
2007-08-20 18:23:52 +00:00
}
2009-07-12 02:26:01 +00:00
static struct inode* iget(uint dev, uint inum);
2017-08-09 10:54:45 +00:00
// Allocate an inode on device dev.
2017-08-09 18:16:55 +00:00
// Mark it as allocated by giving it type type.
2017-08-09 10:54:45 +00:00
// Returns an unlocked but allocated and referenced inode.
2009-07-12 02:26:01 +00:00
struct inode*
ialloc(uint dev, short type)
{
int inum;
struct buf *bp;
struct dinode *dip;
2011-10-11 10:41:37 +00:00
for(inum = 1; inum < sb.ninodes; inum++){
bp = bread(dev, IBLOCK(inum, sb));
2009-07-12 02:26:01 +00:00
dip = (struct dinode*)bp->data + inum%IPB;
if(dip->type == 0){ // a free inode
memset(dip, 0, sizeof(*dip));
dip->type = type;
log_write(bp); // mark it allocated on the disk
2009-07-12 02:26:01 +00:00
brelse(bp);
return iget(dev, inum);
}
brelse(bp);
}
panic("ialloc: no inodes");
}
2011-10-11 14:11:53 +00:00
// Copy a modified in-memory inode to disk.
2017-08-09 10:54:45 +00:00
// Must be called after every change to an ip->xxx field
// that lives on disk, since i-node cache is write-through.
2017-08-08 18:12:25 +00:00
// Caller must hold ip->lock.
2009-07-12 02:26:01 +00:00
void
iupdate(struct inode *ip)
{
struct buf *bp;
struct dinode *dip;
bp = bread(ip->dev, IBLOCK(ip->inum, sb));
2009-07-12 02:26:01 +00:00
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);
2009-07-12 02:26:01 +00:00
brelse(bp);
}
2006-09-06 17:50:20 +00:00
// Find the inode with number inum on device dev
2011-10-11 14:11:53 +00:00
// 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)
{
2007-08-20 18:23:52 +00:00
struct inode *ip, *empty;
2007-08-20 18:23:52 +00:00
acquire(&icache.lock);
2011-10-11 14:11:53 +00:00
// Is the inode already cached?
2007-08-20 18:23:52 +00:00
empty = 0;
for(ip = &icache.inode[0]; ip < &icache.inode[NINODE]; ip++){
2006-09-07 15:15:32 +00:00
if(ip->ref > 0 && ip->dev == dev && ip->inum == inum){
ip->ref++;
2007-08-20 18:23:52 +00:00
release(&icache.lock);
return ip;
}
2007-08-20 18:23:52 +00:00
if(empty == 0 && ip->ref == 0) // Remember empty slot.
empty = ip;
}
2011-10-11 14:11:53 +00:00
// Recycle an inode cache entry.
2007-08-20 18:23:52 +00:00
if(empty == 0)
2007-08-08 09:50:46 +00:00
panic("iget: no inodes");
2007-08-20 18:23:52 +00:00
ip = empty;
ip->dev = dev;
ip->inum = inum;
ip->ref = 1;
2017-08-08 17:34:13 +00:00
ip->valid = 0;
2007-08-20 18:23:52 +00:00
release(&icache.lock);
return ip;
2007-08-20 18:23:52 +00:00
}
// Increment reference count for ip.
// Returns ip to enable ip = idup(ip1) idiom.
struct inode*
idup(struct inode *ip)
2007-08-20 18:23:52 +00:00
{
acquire(&icache.lock);
ip->ref++;
release(&icache.lock);
return ip;
}
// Lock the given inode.
2011-10-11 14:11:53 +00:00
// Reads the inode from disk if necessary.
void
ilock(struct inode *ip)
{
struct buf *bp;
struct dinode *dip;
if(ip == 0 || ip->ref < 1)
panic("ilock");
2016-09-12 00:59:57 +00:00
acquiresleep(&ip->lock);
2017-08-08 17:34:13 +00:00
if(ip->valid == 0){
bp = bread(ip->dev, IBLOCK(ip->inum, sb));
2007-08-28 04:13:24 +00:00
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);
2017-08-08 17:34:13 +00:00
ip->valid = 1;
if(ip->type == 0)
panic("ilock: no type");
}
2007-08-20 18:23:52 +00:00
}
// Unlock the given inode.
void
2007-08-20 18:23:52 +00:00
iunlock(struct inode *ip)
{
2016-09-12 00:59:57 +00:00
if(ip == 0 || !holdingsleep(&ip->lock) || ip->ref < 1)
2007-08-20 18:23:52 +00:00
panic("iunlock");
2016-09-12 00:59:57 +00:00
releasesleep(&ip->lock);
2007-08-20 18:23:52 +00:00
}
2011-10-11 14:11:53 +00:00
// 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.
// All calls to iput() must be inside a transaction in
// case it has to free the inode.
2007-08-20 18:23:52 +00:00
void
iput(struct inode *ip)
2007-08-20 18:23:52 +00:00
{
2019-06-06 14:38:11 +00:00
acquire(&icache.lock);
if(ip->ref == 1 && ip->valid && ip->nlink == 0){
// inode has no links and no other references: truncate and free.
// ip->ref == 1 means no other process can have ip locked,
// so this acquiresleep() won't block (or deadlock).
acquiresleep(&ip->lock);
release(&icache.lock);
2019-06-06 14:38:11 +00:00
itrunc(ip);
ip->type = 0;
iupdate(ip);
ip->valid = 0;
releasesleep(&ip->lock);
acquire(&icache.lock);
}
ip->ref--;
release(&icache.lock);
}
2007-08-27 14:31:50 +00:00
// Common idiom: unlock, then put.
void
iunlockput(struct inode *ip)
{
iunlock(ip);
iput(ip);
}
2011-10-11 14:11:53 +00:00
// Inode content
2007-08-20 18:23:52 +00:00
//
2011-10-11 14:11:53 +00:00
// 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
2011-10-11 14:11:53 +00:00
// listed in block ip->addrs[NDIRECT].
2007-08-20 18:23:52 +00:00
2006-09-07 14:28:12 +00:00
// Return the disk block address of the nth block in inode ip.
// If there is no such block, bmap allocates one.
static uint
bmap(struct inode *ip, uint bn)
{
2007-08-20 18:23:52 +00:00
uint addr, *a;
struct buf *bp;
2007-08-28 18:32:08 +00:00
if(bn < NDIRECT){
if((addr = ip->addrs[bn]) == 0)
2007-08-20 18:23:52 +00:00
ip->addrs[bn] = addr = balloc(ip->dev);
return addr;
}
2007-08-20 18:23:52 +00:00
bn -= NDIRECT;
2007-08-28 18:32:08 +00:00
if(bn < NINDIRECT){
2007-08-20 18:23:52 +00:00
// Load indirect block, allocating if necessary.
if((addr = ip->addrs[NDIRECT]) == 0)
ip->addrs[NDIRECT] = addr = balloc(ip->dev);
2007-08-20 18:23:52 +00:00
bp = bread(ip->dev, addr);
a = (uint*)bp->data;
2007-08-28 18:32:08 +00:00
if((addr = a[bn]) == 0){
2007-08-20 18:23:52 +00:00
a[bn] = addr = balloc(ip->dev);
log_write(bp);
2007-08-20 18:23:52 +00:00
}
brelse(bp);
return addr;
}
panic("bmap: out of range");
}
2007-08-20 18:23:52 +00:00
// Truncate inode (discard contents).
2011-10-11 14:11:53 +00:00
// 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).
2007-08-21 19:58:55 +00:00
static void
2006-08-30 18:55:06 +00:00
itrunc(struct inode *ip)
{
int i, j;
2007-08-20 18:23:52 +00:00
struct buf *bp;
2007-08-10 16:52:31 +00:00
uint *a;
2007-08-28 18:32:08 +00:00
for(i = 0; i < NDIRECT; i++){
if(ip->addrs[i]){
bfree(ip->dev, ip->addrs[i]);
ip->addrs[i] = 0;
}
}
if(ip->addrs[NDIRECT]){
bp = bread(ip->dev, ip->addrs[NDIRECT]);
2007-08-20 18:23:52 +00:00
a = (uint*)bp->data;
2007-08-28 18:32:08 +00:00
for(j = 0; j < NINDIRECT; j++){
2007-08-20 18:23:52 +00:00
if(a[j])
bfree(ip->dev, a[j]);
}
brelse(bp);
bfree(ip->dev, ip->addrs[NDIRECT]);
ip->addrs[NDIRECT] = 0;
2006-08-30 18:55:06 +00:00
}
2007-08-20 18:23:52 +00:00
ip->size = 0;
iupdate(ip);
2006-08-15 15:53:46 +00:00
}
2006-09-07 14:28:12 +00:00
// Copy stat information from inode.
2017-08-08 18:12:25 +00:00
// Caller must hold ip->lock.
2006-08-12 04:33:50 +00:00
void
stati(struct inode *ip, struct stat *st)
{
2006-09-07 13:08:23 +00:00
st->dev = ip->dev;
st->ino = ip->inum;
st->type = ip->type;
st->nlink = ip->nlink;
st->size = ip->size;
2006-08-12 04:33:50 +00:00
}
2006-09-07 14:28:12 +00:00
// Read data from inode.
2017-08-08 18:12:25 +00:00
// Caller must hold ip->lock.
// If user_dst==1, then dst is a user virtual address;
// otherwise, dst is a kernel address.
2006-07-27 21:10:00 +00:00
int
readi(struct inode *ip, int user_dst, uint64 dst, uint off, uint n)
2006-07-27 21:10:00 +00:00
{
2007-08-20 18:23:52 +00:00
uint tot, m;
2006-07-27 21:10:00 +00:00
struct buf *bp;
2007-08-27 14:31:50 +00:00
if(off > ip->size || off + n < off)
2007-08-20 18:23:52 +00:00
return -1;
if(off + n > ip->size)
n = ip->size - off;
2006-07-27 21:10:00 +00:00
2007-08-28 18:32:08 +00:00
for(tot=0; tot<n; tot+=m, off+=m, dst+=m){
bp = bread(ip->dev, bmap(ip, off/BSIZE));
2007-08-20 18:23:52 +00:00
m = min(n - tot, BSIZE - off%BSIZE);
2019-08-20 16:46:56 +00:00
if(either_copyout(user_dst, dst, bp->data + (off % BSIZE), m) == -1) {
brelse(bp);
break;
2019-08-20 16:46:56 +00:00
}
2007-08-20 18:23:52 +00:00
brelse(bp);
}
2007-08-20 18:23:52 +00:00
return n;
}
2006-09-07 14:28:12 +00:00
// Write data to inode.
2017-08-08 18:12:25 +00:00
// Caller must hold ip->lock.
// If user_src==1, then src is a user virtual address;
// otherwise, src is a kernel address.
int
writei(struct inode *ip, int user_src, uint64 src, uint off, uint n)
{
2007-08-20 18:23:52 +00:00
uint tot, m;
2007-08-10 16:52:31 +00:00
struct buf *bp;
if(off > ip->size || off + n < off)
2007-08-20 18:23:52 +00:00
return -1;
if(off + n > MAXFILE*BSIZE)
return -1;
2007-08-20 18:23:52 +00:00
2007-08-28 18:32:08 +00:00
for(tot=0; tot<n; tot+=m, off+=m, src+=m){
bp = bread(ip->dev, bmap(ip, off/BSIZE));
2007-08-20 18:23:52 +00:00
m = min(n - tot, BSIZE - off%BSIZE);
2019-08-20 15:57:24 +00:00
if(either_copyin(bp->data + (off % BSIZE), user_src, src, m) == -1) {
brelse(bp);
break;
2019-08-20 15:57:24 +00:00
}
log_write(bp);
2007-08-10 16:52:31 +00:00
brelse(bp);
}
2007-08-20 18:23:52 +00:00
if(n > 0){
if(off > ip->size)
ip->size = off;
// write the i-node back to disk even if the size didn't change
// because the loop above might have called bmap() and added a new
// block to ip->addrs[].
2007-08-10 16:52:31 +00:00
iupdate(ip);
}
2007-08-20 18:23:52 +00:00
return n;
}
2007-08-20 18:23:52 +00:00
// Directories
2007-08-09 19:05:00 +00:00
int
2007-08-21 19:58:55 +00:00
namecmp(const char *s, const char *t)
{
2007-08-24 21:00:02 +00:00
return strncmp(s, t, DIRSIZ);
2007-08-21 19:58:55 +00:00
}
2007-08-09 19:05:00 +00:00
// Look for a directory entry in a directory.
// If found, set *poff to byte offset of entry.
struct inode*
2007-08-21 19:58:55 +00:00
dirlookup(struct inode *dp, char *name, uint *poff)
2007-08-09 19:05:00 +00:00
{
uint off, inum;
struct dirent de;
2007-08-09 19:05:00 +00:00
if(dp->type != T_DIR)
2007-08-24 14:56:17 +00:00
panic("dirlookup not DIR");
2007-08-09 19:05:00 +00:00
for(off = 0; off < dp->size; off += sizeof(de)){
if(readi(dp, 0, (uint64)&de, off, sizeof(de)) != sizeof(de))
2017-04-27 02:56:51 +00:00
panic("dirlookup read");
if(de.inum == 0)
continue;
if(namecmp(name, de.name) == 0){
// entry matches path element
if(poff)
*poff = off;
inum = de.inum;
return iget(dp->dev, inum);
2007-08-09 19:05:00 +00:00
}
}
return 0;
2007-08-09 19:05:00 +00:00
}
// Write a new directory entry (name, inum) into the directory dp.
int
dirlink(struct inode *dp, char *name, uint inum)
2007-08-20 18:23:52 +00:00
{
2007-08-20 19:37:15 +00:00
int off;
2007-08-20 18:23:52 +00:00
struct dirent de;
struct inode *ip;
// Check that name is not present.
if((ip = dirlookup(dp, name, 0)) != 0){
iput(ip);
return -1;
}
2007-08-20 18:23:52 +00:00
// Look for an empty dirent.
for(off = 0; off < dp->size; off += sizeof(de)){
if(readi(dp, 0, (uint64)&de, off, sizeof(de)) != sizeof(de))
2007-08-27 14:31:50 +00:00
panic("dirlink read");
2007-08-20 18:23:52 +00:00
if(de.inum == 0)
break;
}
2007-08-24 21:00:02 +00:00
strncpy(de.name, name, DIRSIZ);
de.inum = inum;
if(writei(dp, 0, (uint64)&de, off, sizeof(de)) != sizeof(de))
2007-08-27 14:31:50 +00:00
panic("dirlink");
return 0;
2007-08-20 18:23:52 +00:00
}
// Paths
// Copy the next path element from path into name.
// Return a pointer to the element following the copied one.
// The returned path has no leading slashes,
// so the caller can check *path=='\0' to see if the name is the last one.
// If no name to remove, return 0.
2007-08-20 18:23:52 +00:00
//
// Examples:
// skipelem("a/bb/c", name) = "bb/c", setting name = "a"
2007-08-27 14:31:50 +00:00
// skipelem("///a//bb", name) = "bb", setting name = "a"
// skipelem("a", name) = "", setting name = "a"
// skipelem("", name) = skipelem("////", name) = 0
2007-08-20 18:23:52 +00:00
//
static char*
2007-08-21 19:58:55 +00:00
skipelem(char *path, char *name)
2007-08-20 18:23:52 +00:00
{
2007-08-21 19:58:55 +00:00
char *s;
int len;
2007-08-20 18:23:52 +00:00
while(*path == '/')
path++;
if(*path == 0)
return 0;
2007-08-21 19:58:55 +00:00
s = path;
2007-08-20 18:23:52 +00:00
while(*path != '/' && *path != 0)
path++;
2007-08-21 19:58:55 +00:00
len = path - s;
if(len >= DIRSIZ)
memmove(name, s, DIRSIZ);
2007-08-28 18:37:41 +00:00
else {
2007-08-21 19:58:55 +00:00
memmove(name, s, len);
name[len] = 0;
}
2007-08-20 18:23:52 +00:00
while(*path == '/')
path++;
return path;
}
// Look up and return the inode for a path name.
2007-08-28 19:39:49 +00:00
// If parent != 0, return the inode for the parent and copy the final
// path element into name, which must have room for DIRSIZ bytes.
// Must be called inside a transaction since it calls iput().
static struct inode*
2009-07-12 02:26:01 +00:00
namex(char *path, int nameiparent, char *name)
2006-07-21 22:10:40 +00:00
{
struct inode *ip, *next;
2007-08-09 19:05:00 +00:00
if(*path == '/')
2008-10-08 18:57:13 +00:00
ip = iget(ROOTDEV, ROOTINO);
else
ip = idup(myproc()->cwd);
2006-07-21 22:10:40 +00:00
2007-08-21 19:58:55 +00:00
while((path = skipelem(path, name)) != 0){
ilock(ip);
if(ip->type != T_DIR){
iunlockput(ip);
return 0;
}
2009-07-12 02:26:01 +00:00
if(nameiparent && *path == '\0'){
2007-08-20 19:37:15 +00:00
// Stop one level early.
iunlock(ip);
return ip;
}
2007-08-27 14:31:50 +00:00
if((next = dirlookup(ip, name, 0)) == 0){
iunlockput(ip);
return 0;
}
iunlockput(ip);
ip = next;
2006-07-21 22:10:40 +00:00
}
2009-07-12 02:26:01 +00:00
if(nameiparent){
iput(ip);
2007-08-09 19:05:00 +00:00
return 0;
2007-08-24 14:56:17 +00:00
}
return ip;
2006-07-21 22:10:40 +00:00
}
2006-08-08 18:07:37 +00:00
2007-08-27 14:31:50 +00:00
struct inode*
namei(char *path)
{
char name[DIRSIZ];
return namex(path, 0, name);
2007-08-27 14:31:50 +00:00
}
2007-08-28 19:39:49 +00:00
2007-08-27 14:31:50 +00:00
struct inode*
nameiparent(char *path, char *name)
{
return namex(path, 1, name);
2007-08-27 14:31:50 +00:00
}