root/sysfile.c

DEFINITIONS

1. argfd
2. fdalloc
3. sys_dup
4. sys_read
5. sys_write
6. sys_close
7. sys_fstat
8. sys_link
9. isdirempty
10. sys_unlink
11. create
12. sys_open
13. sys_mkdir
14. sys_mknod
15. sys_chdir
16. sys_exec
17. sys_pipe

   1 //
   2 // File-system system calls.
   3 // Mostly argument checking, since we don't trust
   4 // user code, and calls into file.c and fs.c.
   5 //
   7 #include "types.h"
   8 #include "defs.h"
   9 #include "param.h"
  10 #include "stat.h"
  11 #include "mmu.h"
  12 #include "proc.h"
  13 #include "fs.h"
  14 #include "file.h"
  15 #include "fcntl.h"
  17 // Fetch the nth word-sized system call argument as a file descriptor
  18 // and return both the descriptor and the corresponding struct file.
  19 static int
argfd(int n, int *pfd, struct file **pf)
  21 {
  22   int fd;
  23   struct file *f;
  25   if(argint(n, &fd) < 0)
  26     return -1;
  27   if(fd < 0 || fd >= NOFILE || (f=proc->ofile[fd]) == 0)
  28     return -1;
  29   if(pfd)
  30     *pfd = fd;
  31   if(pf)
  32     *pf = f;
  33   return 0;
  34 }
  36 // Allocate a file descriptor for the given file.
  37 // Takes over file reference from caller on success.
  38 static int
fdalloc(struct file *f)
  40 {
  41   int fd;
  43   for(fd = 0; fd < NOFILE; fd++){
  44     if(proc->ofile[fd] == 0){
proc->ofile[fd] = f;
  46       return fd;
  47     }
  48   }
  49   return -1;
  50 }
  52 int
sys_dup(void)
  54 {
  55   struct file *f;
  56   int fd;
  58   if(argfd(0, 0, &f) < 0)
  59     return -1;
  60   if((fd=fdalloc(f)) < 0)
  61     return -1;
filedup(f);
  63   return fd;
  64 }
  66 int
sys_read(void)
  68 {
  69   struct file *f;
  70   int n;
  71   char *p;
  73   if(argfd(0, 0, &f) < 0 || argint(2, &n) < 0 || argptr(1, &p, n) < 0)
  74     return -1;
  75   return fileread(f, p, n);
  76 }
  78 int
sys_write(void)
  80 {
  81   struct file *f;
  82   int n;
  83   char *p;
  85   if(argfd(0, 0, &f) < 0 || argint(2, &n) < 0 || argptr(1, &p, n) < 0)
  86     return -1;
  87   return filewrite(f, p, n);
  88 }
  90 int
sys_close(void)
  92 {
  93   int fd;
  94   struct file *f;
  96   if(argfd(0, &fd, &f) < 0)
  97     return -1;
proc->ofile[fd] = 0;
fileclose(f);
 100   return 0;
 101 }
 103 int
sys_fstat(void)
 105 {
 106   struct file *f;
 107   struct stat *st;
 109   if(argfd(0, 0, &f) < 0 || argptr(1, (void*)&st, sizeof(*st)) < 0)
 110     return -1;
 111   return filestat(f, st);
 112 }
 114 // Create the path new as a link to the same inode as old.
 115 int
sys_link(void)
 117 {
 118   char name[DIRSIZ], *new, *old;
 119   struct inode *dp, *ip;
 121   if(argstr(0, &old) < 0 || argstr(1, &new) < 0)
 122     return -1;
begin_op();
 125   if((ip = namei(old)) == 0){
end_op();
 127     return -1;
 128   }
ilock(ip);
 131   if(ip->type == T_DIR){
iunlockput(ip);
end_op();
 134     return -1;
 135   }
ip->nlink++;
iupdate(ip);
iunlock(ip);
 141   if((dp = nameiparent(new, name)) == 0)
 142     goto bad;
ilock(dp);
 144   if(dp->dev != ip->dev || dirlink(dp, name, ip->inum) < 0){
iunlockput(dp);
 146     goto bad;
 147   }
iunlockput(dp);
iput(ip);
end_op();
 153   return 0;
bad:
ilock(ip);
ip->nlink--;
iupdate(ip);
iunlockput(ip);
end_op();
 161   return -1;
 162 }
 164 // Is the directory dp empty except for "." and ".." ?
 165 static int
isdirempty(struct inode *dp)
 167 {
 168   int off;
 169   struct dirent de;
 171   for(off=2*sizeof(de); off<dp->size; off+=sizeof(de)){
 172     if(readi(dp, (char*)&de, off, sizeof(de)) != sizeof(de))
panic("isdirempty: readi");
 174     if(de.inum != 0)
 175       return 0;
 176   }
 177   return 1;
 178 }
 180 //PAGEBREAK!
 181 int
sys_unlink(void)
 183 {
 184   struct inode *ip, *dp;
 185   struct dirent de;
 186   char name[DIRSIZ], *path;
uint off;
 189   if(argstr(0, &path) < 0)
 190     return -1;
begin_op();
 193   if((dp = nameiparent(path, name)) == 0){
end_op();
 195     return -1;
 196   }
ilock(dp);
 200   // Cannot unlink "." or "..".
 201   if(namecmp(name, ".") == 0 || namecmp(name, "..") == 0)
 202     goto bad;
 204   if((ip = dirlookup(dp, name, &off)) == 0)
 205     goto bad;
ilock(ip);
 208   if(ip->nlink < 1)
panic("unlink: nlink < 1");
 210   if(ip->type == T_DIR && !isdirempty(ip)){
iunlockput(ip);
 212     goto bad;
 213   }
memset(&de, 0, sizeof(de));
 216   if(writei(dp, (char*)&de, off, sizeof(de)) != sizeof(de))
panic("unlink: writei");
 218   if(ip->type == T_DIR){
dp->nlink--;
iupdate(dp);
 221   }
iunlockput(dp);
ip->nlink--;
iupdate(ip);
iunlockput(ip);
end_op();
 230   return 0;
bad:
iunlockput(dp);
end_op();
 235   return -1;
 236 }
 238 static struct inode*
create(char *path, short type, short major, short minor)
 240 {
uint off;
 242   struct inode *ip, *dp;
 243   char name[DIRSIZ];
 245   if((dp = nameiparent(path, name)) == 0)
 246     return 0;
ilock(dp);
 249   if((ip = dirlookup(dp, name, &off)) != 0){
iunlockput(dp);
ilock(ip);
 252     if(type == T_FILE && ip->type == T_FILE)
 253       return ip;
iunlockput(ip);
 255     return 0;
 256   }
 258   if((ip = ialloc(dp->dev, type)) == 0)
panic("create: ialloc");
ilock(ip);
ip->major = major;
ip->minor = minor;
ip->nlink = 1;
iupdate(ip);
 267   if(type == T_DIR){  // Create . and .. entries.
dp->nlink++;  // for ".."
iupdate(dp);
 270     // No ip->nlink++ for ".": avoid cyclic ref count.
 271     if(dirlink(ip, ".", ip->inum) < 0 || dirlink(ip, "..", dp->inum) < 0)
panic("create dots");
 273   }
 275   if(dirlink(dp, name, ip->inum) < 0)
panic("create: dirlink");
iunlockput(dp);
 280   return ip;
 281 }
 283 int
sys_open(void)
 285 {
 286   char *path;
 287   int fd, omode;
 288   struct file *f;
 289   struct inode *ip;
 291   if(argstr(0, &path) < 0 || argint(1, &omode) < 0)
 292     return -1;
begin_op();
 296   if(omode & O_CREATE){
ip = create(path, T_FILE, 0, 0);
 298     if(ip == 0){
end_op();
 300       return -1;
 301     }
 302   } else {
 303     if((ip = namei(path)) == 0){
end_op();
 305       return -1;
 306     }
ilock(ip);
 308     if(ip->type == T_DIR && omode != O_RDONLY){
iunlockput(ip);
end_op();
 311       return -1;
 312     }
 313   }
 315   if((f = filealloc()) == 0 || (fd = fdalloc(f)) < 0){
 316     if(f)
fileclose(f);
iunlockput(ip);
end_op();
 320     return -1;
 321   }
iunlock(ip);
end_op();
f->type = FD_INODE;
f->ip = ip;
f->off = 0;
f->readable = !(omode & O_WRONLY);
f->writable = (omode & O_WRONLY) || (omode & O_RDWR);
 330   return fd;
 331 }
 333 int
sys_mkdir(void)
 335 {
 336   char *path;
 337   struct inode *ip;
begin_op();
 340   if(argstr(0, &path) < 0 || (ip = create(path, T_DIR, 0, 0)) == 0){
end_op();
 342     return -1;
 343   }
iunlockput(ip);
end_op();
 346   return 0;
 347 }
 349 int
sys_mknod(void)
 351 {
 352   struct inode *ip;
 353   char *path;
 354   int len;
 355   int major, minor;
begin_op();
 358   if((len=argstr(0, &path)) < 0 ||
argint(1, &major) < 0 ||
argint(2, &minor) < 0 ||
 361      (ip = create(path, T_DEV, major, minor)) == 0){
end_op();
 363     return -1;
 364   }
iunlockput(ip);
end_op();
 367   return 0;
 368 }
 370 int
sys_chdir(void)
 372 {
 373   char *path;
 374   struct inode *ip;
begin_op();
 377   if(argstr(0, &path) < 0 || (ip = namei(path)) == 0){
end_op();
 379     return -1;
 380   }
ilock(ip);
 382   if(ip->type != T_DIR){
iunlockput(ip);
end_op();
 385     return -1;
 386   }
iunlock(ip);
iput(proc->cwd);
end_op();
proc->cwd = ip;
 391   return 0;
 392 }
 394 int
sys_exec(void)
 396 {
 397   char *path, *argv[MAXARG];
 398   int i;
uint uargv, uarg;
 401   if(argstr(0, &path) < 0 || argint(1, (int*)&uargv) < 0){
 402     return -1;
 403   }
memset(argv, 0, sizeof(argv));
 405   for(i=0;; i++){
 406     if(i >= NELEM(argv))
 407       return -1;
 408     if(fetchint(uargv+4*i, (int*)&uarg) < 0)
 409       return -1;
 410     if(uarg == 0){
argv[i] = 0;
 412       break;
 413     }
 414     if(fetchstr(uarg, &argv[i]) < 0)
 415       return -1;
 416   }
 417   return exec(path, argv);
 418 }
 420 int
sys_pipe(void)
 422 {
 423   int *fd;
 424   struct file *rf, *wf;
 425   int fd0, fd1;
 427   if(argptr(0, (void*)&fd, 2*sizeof(fd[0])) < 0)
 428     return -1;
 429   if(pipealloc(&rf, &wf) < 0)
 430     return -1;
fd0 = -1;
 432   if((fd0 = fdalloc(rf)) < 0 || (fd1 = fdalloc(wf)) < 0){
 433     if(fd0 >= 0)
proc->ofile[fd0] = 0;
fileclose(rf);
fileclose(wf);
 437     return -1;
 438   }
fd[0] = fd0;
fd[1] = fd1;
 441   return 0;
 442 }