xv6/fs.c

757 lines
16 KiB
C
Raw Normal View History

2007-08-20 18:23:52 +00:00
// File system implementation.
//
// Four layers:
// + Blocks: allocator for raw disk blocks.
// + 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.
//
// Disk layout is: superblock, inodes, disk bitmap, data blocks.
// TODO: Check locking!
#include "types.h"
2006-08-12 04:33:50 +00:00
#include "stat.h"
#include "param.h"
#include "x86.h"
#include "mmu.h"
#include "proc.h"
#include "defs.h"
#include "spinlock.h"
#include "buf.h"
#include "fs.h"
#include "fsvar.h"
#include "dev.h"
2007-08-20 18:23:52 +00:00
#define min(a, b) ((a) < (b) ? (a) : (b))
2006-07-21 22:10:40 +00:00
2007-08-20 18:23:52 +00:00
static void ifree(struct inode*);
// Blocks.
2006-09-06 17:50:20 +00:00
// Allocate a disk block.
2006-09-06 17:27:19 +00:00
static uint
balloc(uint dev)
2006-08-09 01:09:36 +00:00
{
2007-08-10 16:52:31 +00:00
int b, bi, m, ninodes, size;
2006-08-09 01:09:36 +00:00
struct buf *bp;
struct superblock *sb;
bp = bread(dev, 1);
2006-09-06 17:27:19 +00:00
sb = (struct superblock*) bp->data;
2006-08-09 01:09:36 +00:00
size = sb->size;
ninodes = sb->ninodes;
2006-09-06 17:27:19 +00:00
for(b = 0; b < size; b++) {
if(b % BPB == 0) {
2006-08-09 01:09:36 +00:00
brelse(bp);
bp = bread(dev, BBLOCK(b, ninodes));
}
bi = b % BPB;
m = 0x1 << (bi % 8);
2006-09-06 17:27:19 +00:00
if((bp->data[bi/8] & m) == 0) { // is block free?
2007-08-10 16:52:31 +00:00
bp->data[bi/8] |= 0x1 << (bi % 8);
bwrite(bp, BBLOCK(b, ninodes)); // mark it allocated on disk
brelse(bp);
return b;
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;
struct superblock *sb;
2007-08-10 16:52:31 +00:00
int bi, m, ninodes;
bp = bread(dev, 1);
2006-09-06 17:27:19 +00:00
sb = (struct superblock*) bp->data;
ninodes = sb->ninodes;
brelse(bp);
bp = bread(dev, b);
memset(bp->data, 0, BSIZE);
bwrite(bp, b);
brelse(bp);
bp = bread(dev, BBLOCK(b, ninodes));
bi = b % BPB;
2007-08-10 16:52:31 +00:00
m = 0x1 << (bi % 8);
bp->data[bi/8] &= ~m;
2006-09-06 17:27:19 +00:00
bwrite(bp, BBLOCK(b, ninodes)); // mark it free on disk
brelse(bp);
}
2006-08-09 01:09:36 +00:00
2007-08-20 18:23:52 +00:00
// Inodes
//
// The inodes are laid out sequentially on disk immediately after
// the superblock. The kernel keeps a cache of the in-use
// on-disk structures to provide a place for synchronizing access
// to inodes shared between multiple processes.
//
// ip->ref counts the number of references to this
// inode; references are typically kept in struct file and in cp->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.
//
// Inodes can be marked busy, just like bufs, meaning
// that some process has logically locked the inode, and other processes
// are not allowed to look at it. Because the locking can last for
// a long time (for example, during a disk access), we use a flag
// like in buffer cache, not spin locks. The inode should always be
// locked during modifications to it.
struct {
struct spinlock lock;
struct inode inode[NINODE];
} icache;
void
iinit(void)
{
initlock(&icache.lock, "icache.lock");
}
2006-09-06 17:50:20 +00:00
// Find the inode with number inum on device dev
// and return an in-memory copy. Loads the inode
// from disk into the in-core table if necessary.
2007-08-20 18:23:52 +00:00
// The returned inode is locked and has its ref count incremented.
2006-09-06 17:50:20 +00:00
// Caller must iput the return value when done with it.
2006-09-06 17:27:19 +00:00
struct inode*
iget(uint dev, uint inum)
{
2007-08-20 18:23:52 +00:00
struct inode *ip, *empty;
struct dinode *dip;
struct buf *bp;
2007-08-20 18:23:52 +00:00
acquire(&icache.lock);
loop:
2007-08-20 18:23:52 +00:00
// Try for cached inode.
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){
if(ip->busy){
2007-08-20 18:23:52 +00:00
sleep(ip, &icache.lock);
goto loop;
}
2006-09-07 15:15:32 +00:00
ip->ref++;
ip->busy = 1;
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;
}
2007-08-20 18:23:52 +00:00
// Allocate fresh inode.
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;
ip->busy = 1;
release(&icache.lock);
2006-08-09 01:09:36 +00:00
bp = bread(dev, IBLOCK(inum));
2006-09-06 17:27:19 +00:00
dip = &((struct dinode*)(bp->data))[inum % IPB];
2007-08-20 18:23:52 +00:00
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);
2007-08-20 18:23:52 +00:00
return ip;
}
// Iget the inode for the file system root (/).
struct inode*
igetroot(void)
{
return iget(ROOTDEV, 1);
}
2007-08-20 18:23:52 +00:00
// Lock the given inode.
2006-09-06 17:27:19 +00:00
void
2007-08-20 18:23:52 +00:00
ilock(struct inode *ip)
{
2007-08-20 18:23:52 +00:00
if(ip->ref < 1)
panic("ilock");
2007-08-20 18:23:52 +00:00
acquire(&icache.lock);
while(ip->busy)
sleep(ip, &icache.lock);
ip->busy = 1;
release(&icache.lock);
}
// Unlock the given inode.
void
iunlock(struct inode *ip)
{
if(ip->busy != 1 || ip->ref < 1)
panic("iunlock");
acquire(&icache.lock);
ip->busy = 0;
wakeup(ip);
release(&icache.lock);
}
// Unlock inode and drop reference.
void
iput(struct inode *ip)
{
if(ip->ref < 1 || ip->busy != 1)
panic("iput");
if((ip->ref == 1) && (ip->nlink == 0)) {
itrunc(ip);
ifree(ip);
}
acquire(&icache.lock);
ip->ref -= 1;
ip->busy = 0;
wakeup(ip);
release(&icache.lock);
}
// Increment reference count for ip.
// Returns ip to enable ip = iincref(ip1) idiom.
struct inode*
iincref(struct inode *ip)
{
ilock(ip);
ip->ref++;
iunlock(ip);
return ip;
}
// Caller holds reference to unlocked ip.
// Drop reference.
void
idecref(struct inode *ip)
{
ilock(ip);
iput(ip);
}
2007-08-20 18:23:52 +00:00
// Allocate a new inode with the given type on device dev.
2006-09-06 17:27:19 +00:00
struct inode*
2006-08-08 18:07:37 +00:00
ialloc(uint dev, short type)
{
struct inode *ip;
2007-08-10 16:52:31 +00:00
struct dinode *dip;
2006-08-08 18:07:37 +00:00
struct superblock *sb;
int ninodes;
int inum;
struct buf *bp;
bp = bread(dev, 1);
2007-08-20 18:23:52 +00:00
sb = (struct superblock*)bp->data;
2006-08-08 18:07:37 +00:00
ninodes = sb->ninodes;
brelse(bp);
2006-08-09 01:09:36 +00:00
2006-09-06 17:27:19 +00:00
for(inum = 1; inum < ninodes; inum++) { // loop over inode blocks
2006-08-09 01:09:36 +00:00
bp = bread(dev, IBLOCK(inum));
2006-09-06 17:27:19 +00:00
dip = &((struct dinode*)(bp->data))[inum % IPB];
if(dip->type == 0) { // a free inode
memset(dip, 0, sizeof(*dip));
dip->type = type;
bwrite(bp, IBLOCK(inum)); // mark it allocated on the disk
brelse(bp);
ip = iget(dev, inum);
return ip;
2006-08-08 18:07:37 +00:00
}
brelse(bp);
}
panic("ialloc: no inodes");
2006-08-08 18:07:37 +00:00
}
2007-08-20 18:23:52 +00:00
// Copy inode, which has changed, from memory to disk.
2006-07-21 22:10:40 +00:00
void
2007-08-20 18:23:52 +00:00
iupdate(struct inode *ip)
2006-07-21 22:10:40 +00:00
{
2007-08-20 18:23:52 +00:00
struct buf *bp;
struct dinode *dip;
2006-07-21 22:10:40 +00:00
2007-08-20 18:23:52 +00:00
bp = bread(ip->dev, IBLOCK(ip->inum));
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));
bwrite(bp, IBLOCK(ip->inum));
brelse(bp);
2006-07-21 22:10:40 +00:00
}
2007-08-20 18:23:52 +00:00
// Free (delete) the given inode.
// Caller must have ip locked.
static void
ifree(struct inode *ip)
2006-07-21 22:10:40 +00:00
{
2007-08-20 18:23:52 +00:00
ip->type = 0;
iupdate(ip);
2006-07-21 22:10:40 +00:00
}
2007-08-20 18:23:52 +00:00
// Inode contents
//
// The contents (data) associated with each inode is stored
// in a sequence of blocks on the disk. The first NDIRECT blocks
// are stored in ip->addrs[]. The next NINDIRECT blocks are
// listed in the block ip->addrs[INDIRECT].
2006-09-07 14:28:12 +00:00
// Return the disk block address of the nth block in inode ip.
2007-08-20 18:23:52 +00:00
// If there is no such block: if alloc is set, allocate one, else return -1.
uint
2007-08-20 18:23:52 +00:00
bmap(struct inode *ip, uint bn, int alloc)
{
2007-08-20 18:23:52 +00:00
uint addr, *a;
struct buf *bp;
2006-09-06 17:27:19 +00:00
if(bn < NDIRECT) {
2007-08-20 18:23:52 +00:00
if((addr = ip->addrs[bn]) == 0) {
if(!alloc)
return -1;
ip->addrs[bn] = addr = balloc(ip->dev);
}
return addr;
}
2007-08-20 18:23:52 +00:00
bn -= NDIRECT;
if(bn < NINDIRECT) {
// Load indirect block, allocating if necessary.
if((addr = ip->addrs[INDIRECT]) == 0) {
if(!alloc)
return -1;
ip->addrs[INDIRECT] = addr = balloc(ip->dev);
}
bp = bread(ip->dev, addr);
a = (uint*)bp->data;
if((addr = a[bn]) == 0) {
if(!alloc) {
brelse(bp);
return -1;
}
a[bn] = addr = balloc(ip->dev);
bwrite(bp, ip->addrs[INDIRECT]);
}
brelse(bp);
return addr;
}
panic("bmap: out of range");
}
2007-08-20 18:23:52 +00:00
// Truncate inode (discard contents).
2006-09-06 17:27:19 +00:00
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-20 18:23:52 +00:00
for(i = 0; i < NDIRECT; i++) {
if(ip->addrs[i]) {
bfree(ip->dev, ip->addrs[i]);
ip->addrs[i] = 0;
}
}
2007-08-20 18:23:52 +00:00
if(ip->addrs[INDIRECT]) {
bp = bread(ip->dev, ip->addrs[INDIRECT]);
a = (uint*)bp->data;
for(j = 0; j < NINDIRECT; j++) {
if(a[j])
bfree(ip->dev, a[j]);
}
brelse(bp);
ip->addrs[INDIRECT] = 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.
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.
2006-07-27 21:10:00 +00:00
int
readi(struct inode *ip, char *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;
2006-09-06 17:27:19 +00:00
if(ip->type == T_DEV) {
2006-09-07 13:08:23 +00:00
if(ip->major < 0 || ip->major >= NDEV || !devsw[ip->major].read)
return -1;
2006-09-07 13:08:23 +00:00
return devsw[ip->major].read(ip->minor, dst, n);
}
2007-08-20 18:23:52 +00:00
if(off + n < off)
return -1;
if(off + n > ip->size)
n = ip->size - off;
2006-07-27 21:10:00 +00:00
2007-08-20 18:23:52 +00:00
for(tot=0; tot<n; tot+=m, off+=m, dst+=m) {
bp = bread(ip->dev, bmap(ip, off/BSIZE, 0));
m = min(n - tot, BSIZE - off%BSIZE);
memmove(dst, bp->data + off%BSIZE, m);
brelse(bp);
}
2007-08-20 18:23:52 +00:00
return n;
}
2006-09-07 14:28:12 +00:00
// Write data to inode.
int
2007-08-20 18:23:52 +00:00
writei(struct inode *ip, char *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;
2006-09-06 17:27:19 +00:00
if(ip->type == T_DEV) {
2006-09-07 13:08:23 +00:00
if(ip->major < 0 || ip->major >= NDEV || !devsw[ip->major].write)
return -1;
2007-08-20 18:23:52 +00:00
return devsw[ip->major].write(ip->minor, src, n);
2007-08-10 16:52:31 +00:00
}
2007-08-20 18:23:52 +00:00
if(off + n < off)
return -1;
if(off + n > MAXFILE*BSIZE)
n = MAXFILE*BSIZE - off;
for(tot=0; tot<n; tot+=m, off+=m, src+=m) {
bp = bread(ip->dev, bmap(ip, off/BSIZE, 1));
m = min(n - tot, BSIZE - off%BSIZE);
memmove(bp->data + off%BSIZE, src, m);
bwrite(bp, bmap(ip, off/BSIZE, 0));
2007-08-10 16:52:31 +00:00
brelse(bp);
}
2007-08-20 18:23:52 +00:00
if(n > 0 && off > ip->size) {
ip->size = off;
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
//
2007-08-20 18:23:52 +00:00
// Directories are just inodes (files) filled with dirent structures.
2007-08-09 19:05:00 +00:00
// Look for a directory entry in a directory.
// If not found, return -1.
// If found:
// set *poff to the byte offset of the directory entry
// set *pinum to the inode number
// return 0.
static int
2007-08-20 18:23:52 +00:00
dirlookup(struct inode *dp, char *name, int namelen, uint *poff, uint *pinum)
2007-08-09 19:05:00 +00:00
{
uint off;
struct buf *bp;
struct dirent *de;
if(dp->type != T_DIR)
return -1;
for(off = 0; off < dp->size; off += BSIZE){
2007-08-20 18:23:52 +00:00
bp = bread(dp->dev, bmap(dp, off / BSIZE, 0));
2007-08-09 19:05:00 +00:00
for(de = (struct dirent*) bp->data;
de < (struct dirent*) (bp->data + BSIZE);
de++){
if(de->inum == 0)
continue;
if(memcmp(name, de->name, namelen) == 0 &&
(namelen == DIRSIZ || de->name[namelen]== 0)){
// entry matches path element
*poff = off + (uchar*)de - bp->data;
*pinum = de->inum;
brelse(bp);
return 0;
}
}
brelse(bp);
}
return -1;
}
2007-08-20 18:23:52 +00:00
// Write a new directory entry (name, ino) into the directory dp.
// Caller must have locked dp.
void
dirwrite(struct inode *dp, char *name, uint ino)
{
int i, off;
struct dirent de;
// Look for an empty dirent.
for(off = 0; off < dp->size; off += sizeof(de)){
if(readi(dp, (char*)&de, off, sizeof(de)) != sizeof(de))
panic("dirwrite read");
if(de.inum == 0)
break;
}
de.inum = ino;
for(i = 0; i < DIRSIZ && name[i]; i++)
de.name[i] = name[i];
for(; i < DIRSIZ; i++)
de.name[i] = '\0';
if(writei(dp, (char*)&de, off, sizeof(de)) != sizeof(de))
panic("dirwrite");
}
// Paths
// Skip over the next path element in path,
// saving it in *name and its length in *len.
// Return a pointer to the element after that
// (after any trailing slashes).
// Thus the caller can check whether *path=='\0'
// to see whether the name just removed was
// the last one.
// If there is no name to remove, return 0.
//
// Examples:
// skipelem("a/bb/c") = "bb/c", with *name = "a/bb/c", len=1
// skipelem("///a/bb") = "b", with *name="a/bb", len=1
// skipelem("") = skipelem("////") = 0
//
static char*
skipelem(char *path, char **name, int *len)
{
while(*path == '/')
path++;
if(*path == 0)
return 0;
*name = path;
while(*path != '/' && *path != 0)
path++;
*len = path - *name;
while(*path == '/')
path++;
return path;
}
// look up a path name, in one of three modes.
// NAMEI_LOOKUP: return locked target inode.
// NAMEI_CREATE: return locked parent inode.
// return 0 if name does exist.
// *ret_last points to last path component (i.e. new file name).
// *ret_ip points to the the name that did exist, if it did.
// *ret_ip and *ret_last may be zero even if return value is zero.
// NAMEI_DELETE: return locked parent inode, offset of dirent in *ret_off.
// return 0 if name doesn't exist.
2006-09-06 17:27:19 +00:00
struct inode*
2006-09-06 19:08:14 +00:00
namei(char *path, int mode, uint *ret_off,
char **ret_last, struct inode **ret_ip)
2006-07-21 22:10:40 +00:00
{
struct inode *dp;
2007-08-09 19:05:00 +00:00
char *name;
int namelen;
2007-08-09 19:06:37 +00:00
uint off, dev, inum;
if(ret_off)
*ret_off = 0xffffffff;
if(ret_last)
*ret_last = 0;
if(ret_ip)
*ret_ip = 0;
2007-08-09 19:05:00 +00:00
if(*path == '/')
2007-08-20 18:23:52 +00:00
dp = igetroot();
else {
2007-08-09 19:06:37 +00:00
dp = iincref(cp->cwd);
ilock(dp);
}
2006-07-21 22:10:40 +00:00
2007-08-09 19:05:00 +00:00
while((path = skipelem(path, &name, &namelen)) != 0){
// Truncate names in path to DIRSIZ chars.
if(namelen > DIRSIZ)
namelen = DIRSIZ;
2006-07-21 22:10:40 +00:00
2007-08-09 19:05:00 +00:00
if(dp->type != T_DIR)
goto fail;
2006-07-21 22:10:40 +00:00
2007-08-20 18:23:52 +00:00
if(dirlookup(dp, name, namelen, &off, &inum) < 0){
2007-08-09 19:05:00 +00:00
if(mode == NAMEI_CREATE && *path == '\0'){
*ret_last = name;
return dp;
}
2007-08-09 19:05:00 +00:00
goto fail;
}
2007-08-09 19:05:00 +00:00
if(mode == NAMEI_DELETE && *path == '\0'){
2007-08-08 09:08:29 +00:00
// can't unlink . and ..
2007-08-09 19:05:00 +00:00
if((namelen == 1 && memcmp(name, ".", 1) == 0) ||
(namelen == 2 && memcmp(name, "..", 2) == 0)){
goto fail;
2007-08-08 09:08:29 +00:00
}
*ret_off = off;
return dp;
}
2007-08-09 19:05:00 +00:00
2006-07-21 22:10:40 +00:00
dev = dp->dev;
iput(dp);
2007-08-09 19:05:00 +00:00
dp = iget(dev, inum);
if(dp->type == 0 || dp->nlink < 1)
panic("namei");
2006-07-21 22:10:40 +00:00
}
2007-08-09 19:05:00 +00:00
if(mode == NAMEI_LOOKUP)
return dp;
if(mode == NAMEI_CREATE && ret_ip){
*ret_ip = dp;
return 0;
}
goto fail;
fail:
iput(dp);
return 0;
2006-07-21 22:10:40 +00:00
}
2006-08-08 18:07:37 +00:00
2007-08-10 16:37:27 +00:00
// Create the path and return its locked inode structure.
2006-09-07 14:28:12 +00:00
// If cp already exists, return 0.
2006-09-06 17:27:19 +00:00
struct inode*
2007-08-10 16:37:27 +00:00
mknod(char *path, short type, short major, short minor)
2006-08-08 18:07:37 +00:00
{
struct inode *ip, *dp;
char *last;
2006-08-08 18:07:37 +00:00
2007-08-10 16:37:27 +00:00
if((dp = namei(path, NAMEI_CREATE, 0, &last, 0)) == 0)
return 0;
ip = mknod1(dp, last, type, major, minor);
iput(dp);
return ip;
}
2006-09-07 14:28:12 +00:00
// Create a new inode named name inside dp
// and return its locked inode structure.
// If name already exists, return 0.
2006-09-06 17:27:19 +00:00
struct inode*
mknod1(struct inode *dp, char *name, short type, short major, short minor)
{
struct inode *ip;
2006-08-08 18:07:37 +00:00
ip = ialloc(dp->dev, type);
2006-09-06 17:27:19 +00:00
if(ip == 0)
return 0;
2006-08-08 18:07:37 +00:00
ip->major = major;
ip->minor = minor;
2006-08-09 01:19:48 +00:00
ip->size = 0;
ip->nlink = 1;
2006-08-09 01:19:48 +00:00
2006-09-06 17:27:19 +00:00
iupdate(ip); // write new inode to disk
2007-08-20 18:23:52 +00:00
dirwrite(dp, name, ip->inum);
return ip;
2006-08-08 18:07:37 +00:00
}
2006-09-07 14:28:12 +00:00
// Unlink the inode named cp.
int
2007-08-10 16:37:27 +00:00
unlink(char *path)
{
struct inode *ip, *dp;
struct dirent de;
uint off, inum, dev;
2006-09-06 17:27:19 +00:00
2007-08-10 16:37:27 +00:00
dp = namei(path, NAMEI_DELETE, &off, 0, 0);
if(dp == 0)
return -1;
dev = dp->dev;
if(readi(dp, (char*)&de, off, sizeof(de)) != sizeof(de) || de.inum == 0)
panic("unlink no entry");
2007-08-09 19:05:00 +00:00
// Cannot remove "." or ".." - the 2 and 3 count the trailing NUL.
if(memcmp(de.name, ".", 2) == 0 || memcmp(de.name, "..", 3) == 0){
iput(dp);
return -1;
}
inum = de.inum;
memset(&de, 0, sizeof(de));
if(writei(dp, (char*)&de, off, sizeof(de)) != sizeof(de))
panic("unlink dir write");
2006-09-06 17:27:19 +00:00
iupdate(dp);
iput(dp);
ip = iget(dev, inum);
2006-08-24 19:21:19 +00:00
if(ip->nlink < 1)
panic("unlink nlink < 1");
ip->nlink--;
iupdate(ip);
iput(ip);
return 0;
}
2006-08-13 02:12:44 +00:00
2006-09-07 14:28:12 +00:00
// Create the path new as a link to the same inode as old.
2006-08-13 02:12:44 +00:00
int
link(char *name1, char *name2)
{
struct inode *ip, *dp;
char *last;
2006-08-13 02:12:44 +00:00
2006-09-06 17:27:19 +00:00
if((ip = namei(name1, NAMEI_LOOKUP, 0, 0, 0)) == 0)
return -1;
if(ip->type == T_DIR){
iput(ip);
2006-08-13 02:12:44 +00:00
return -1;
}
iunlock(ip);
2006-09-06 17:27:19 +00:00
if((dp = namei(name2, NAMEI_CREATE, 0, &last, 0)) == 0) {
idecref(ip);
return -1;
}
if(dp->dev != ip->dev){
idecref(ip);
iput(dp);
2006-08-13 02:12:44 +00:00
return -1;
}
2006-09-06 17:27:19 +00:00
ilock(ip);
2006-09-08 14:26:16 +00:00
ip->nlink++;
2006-09-06 17:27:19 +00:00
iupdate(ip);
2006-08-13 02:12:44 +00:00
2007-08-20 18:23:52 +00:00
dirwrite(dp, last, ip->inum);
2006-08-13 02:12:44 +00:00
iput(dp);
iput(ip);
return 0;
}