text: //
  // File-system system calls.
  // Mostly argument checking, since we don't trust
  // user code, and calls into file.c and fs.c.
  //
  
  #include "xv6/types.h"
  #include "xv6/defs.h"
  #include "xv6/param.h"
  #include "xv6/stat.h"
  #include "xv6/mmu.h"
  #include "xv6/proc.h"
  #include "xv6/fs.h"
  #include "xv6/spinlock.h"
  #include "xv6/sleeplock.h"
  #include "xv6/file.h"
  #include "xv6/fcntl.h"
  
  // Fetch the nth word-sized system call argument as a file descriptor
  // and return both the descriptor and the corresponding struct file.
  static int
  argfd(int n, int *pfd, struct file **pf)
  {
      int fd;
      struct file *f;
  
      if (argint(n, &fd) < 0)
          return -1;
      if (fd < 0 || fd >= NOFILE || (f = proc->ofile[fd]) == 0)
          return -1;
      if (pfd)
          *pfd = fd;
      if (pf)
          *pf = f;
      return 0;
  }
  
  // Allocate a file descriptor for the given file.
  // Takes over file reference from caller on success.
  static int
  fdalloc(struct file *f)
  {
      int fd;
  
      for (fd = 0; fd < NOFILE; fd++) {
          if (proc->ofile[fd] == 0) {
              proc->ofile[fd] = f;
              return fd;
          }
      }
      return -1;
  }
  
  int
  sys_dup(void)
  {
      struct file *f;
      int fd;
  
      if (argfd(0, 0, &f) < 0)
          return -1;
      if ((fd = fdalloc(f)) < 0)
          return -1;
      filedup(f);
      return fd;
  }
  
  int
  sys_read(void)
  {
      struct file *f;
      int n;
      char *p;
  
      if (argfd(0, 0, &f) < 0 || argint(2, &n) < 0 || argptr(1, &p, n) < 0)
          return -1;
      return fileread(f, p, n);
  }
  
  int
  sys_write(void)
  {
      struct file *f;
      int n;
      char *p;
  
      if (argfd(0, 0, &f) < 0 || argint(2, &n) < 0 || argptr(1, &p, n) < 0)
          return -1;
      return filewrite(f, p, n);
  }
  
  int
  sys_close(void)
  {
      int fd;
      struct file *f;
  
      if (argfd(0, &fd, &f) < 0)
          return -1;
      proc->ofile[fd] = 0;
      fileclose(f);
      return 0;
  }
  
  int
  sys_fstat(void)
  {
      struct file *f;
      struct stat *st;
  
      if (argfd(0, 0, &f) < 0 || argptr(1, (void*)&st, sizeof(*st)) < 0)
          return -1;
      return filestat(f, st);
  }
  
  // Create the path new as a link to the same inode as old.
  int
  sys_link(void)
  {
      char name[DIRSIZ], *new, *old;
      struct inode *dp, *ip;
  
      if (argstr(0, &old) < 0 || argstr(1, &new) < 0)
          return -1;
  
      begin_op();
      if ((ip = namei(old)) == 0) {
          end_op();
          return -1;
      }
  
      ilock(ip);
      if (ip->type == T_DIR) {
          iunlockput(ip);
          end_op();
          return -1;
      }
  
      ip->nlink++;
      iupdate(ip);
      iunlock(ip);
  
      if ((dp = nameiparent(new, name)) == 0)
          goto bad;
      ilock(dp);
      if (dp->dev != ip->dev || dirlink(dp, name, ip->inum) < 0) {
          iunlockput(dp);
          goto bad;
      }
      iunlockput(dp);
      iput(ip);
  
      end_op();
  
      return 0;
  
  bad:
      ilock(ip);
      ip->nlink--;
      iupdate(ip);
      iunlockput(ip);
      end_op();
      return -1;
  }
  
  // Is the directory dp empty except for "." and ".." ?
  static int
  isdirempty(struct inode *dp)
  {
      int off;
      struct dirent de;
  
      for (off = 2 * sizeof(de); off < dp->size; off += sizeof(de)) {
          if (readi(dp, (char*)&de, off, sizeof(de)) != sizeof(de))
              panic("isdirempty: readi");
          if (de.inum != 0)
              return 0;
      }
      return 1;
  }
  
  //PAGEBREAK!
  int
  sys_unlink(void)
  {
      struct inode *ip, *dp;
      struct dirent de;
      char name[DIRSIZ], *path;
      uint off;
  
      if (argstr(0, &path) < 0)
          return -1;
  
      begin_op();
      if ((dp = nameiparent(path, name)) == 0) {
          end_op();
          return -1;
      }
  
      ilock(dp);
  
      // Cannot unlink "." or "..".
      if (namecmp(name, ".") == 0 || namecmp(name, "..") == 0)
          goto bad;
  
      if ((ip = dirlookup(dp, name, &off)) == 0)
          goto bad;
      ilock(ip);
  
      if (ip->nlink < 1)
          panic("unlink: nlink < 1");
      if (ip->type == T_DIR && !isdirempty(ip)) {
          iunlockput(ip);
          goto bad;
      }
  
      memset(&de, 0, sizeof(de));
      if (writei(dp, (char*)&de, off, sizeof(de)) != sizeof(de))
          panic("unlink: writei");
      if (ip->type == T_DIR) {
          dp->nlink--;
          iupdate(dp);
      }
      iunlockput(dp);
  
      ip->nlink--;
      iupdate(ip);
      iunlockput(ip);
  
      end_op();
  
      return 0;
  
  bad:
      iunlockput(dp);
      end_op();
      return -1;
  }
  
  static struct inode*
  create(char *path, short type, short major, short minor)
  {
      uint off;
      struct inode *ip, *dp;
      char name[DIRSIZ];
  
      if ((dp = nameiparent(path, name)) == 0)
          return 0;
      ilock(dp);
  
      if ((ip = dirlookup(dp, name, &off)) != 0) {
          iunlockput(dp);
          ilock(ip);
          if (type == T_FILE && ip->type == T_FILE)
              return ip;
          iunlockput(ip);
          return 0;
      }
  
      if ((ip = ialloc(dp->dev, type)) == 0)
          panic("create: ialloc");
  
      ilock(ip);
      ip->major = major;
      ip->minor = minor;
      ip->nlink = 1;
      iupdate(ip);
  
      if (type == T_DIR) { // Create . and .. entries.
          dp->nlink++;  // for ".."
          iupdate(dp);
          // No ip->nlink++ for ".": avoid cyclic ref count.
          if (dirlink(ip, ".", ip->inum) < 0 || dirlink(ip, "..", dp->inum) < 0)
              panic("create dots");
      }
  
      if (dirlink(dp, name, ip->inum) < 0)
          panic("create: dirlink");
  
      iunlockput(dp);
  
      return ip;
  }
  
  int
  sys_open(void)
  {
      char *path;
      int fd, omode;
      struct file *f;
      struct inode *ip;
  
      if (argstr(0, &path) < 0 || argint(1, &omode) < 0)
          return -1;
  
      begin_op();
  
      if (omode & O_CREATE) {
          ip = create(path, T_FILE, 0, 0);
          if (ip == 0) {
              end_op();
              return -1;
          }
      } else {
          if ((ip = namei(path)) == 0) {
              end_op();
              return -1;
          }
          ilock(ip);
          if (ip->type == T_DIR && omode != O_RDONLY) {
              iunlockput(ip);
              end_op();
              return -1;
          }
      }
  
      if ((f = filealloc()) == 0 || (fd = fdalloc(f)) < 0) {
          if (f)
              fileclose(f);
          iunlockput(ip);
          end_op();
          return -1;
      }
      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);
      return fd;
  }
  
  int
  sys_mkdir(void)
  {
      char *path;
      struct inode *ip;
  
      begin_op();
      if (argstr(0, &path) < 0 || (ip = create(path, T_DIR, 0, 0)) == 0) {
          end_op();
          return -1;
      }
      iunlockput(ip);
      end_op();
      return 0;
  }
  
  int
  sys_mknod(void)
  {
      struct inode *ip;
      char *path;
      int major, minor;
  
      begin_op();
      if ((argstr(0, &path)) < 0 ||
              argint(1, &major) < 0 ||
              argint(2, &minor) < 0 ||
              (ip = create(path, T_DEV, major, minor)) == 0) {
          end_op();
          return -1;
      }
      iunlockput(ip);
      end_op();
      return 0;
  }
  
  int
  sys_chdir(void)
  {
      char *path;
      struct inode *ip;
  
      begin_op();
      if (argstr(0, &path) < 0 || (ip = namei(path)) == 0) {
          end_op();
          return -1;
      }
      ilock(ip);
      if (ip->type != T_DIR) {
          iunlockput(ip);
          end_op();
          return -1;
      }
      iunlock(ip);
      iput(proc->cwd);
      end_op();
      proc->cwd = ip;
      return 0;
  }
  
  int
  sys_exec(void)
  {
      char *path, *argv[MAXARG];
      int i;
      uint uargv, uarg;
  
      if (argstr(0, &path) < 0 || argint(1, (int*)&uargv) < 0) {
          return -1;
      }
      memset(argv, 0, sizeof(argv));
      for (i = 0;; i++) {
          if (i >= NELEM(argv))
              return -1;
          if (fetchint(uargv + 4 * i, (int*)&uarg) < 0)
              return -1;
          if (uarg == 0) {
              argv[i] = 0;
              break;
          }
          if (fetchstr(uarg, &argv[i]) < 0)
              return -1;
      }
      return exec(path, argv);
  }
  
  int
  sys_pipe(void)
  {
      int *fd;
      struct file *rf, *wf;
      int fd0, fd1;
  
      if (argptr(0, (void*)&fd, 2 * sizeof(fd[0])) < 0)
          return -1;
      if (pipealloc(&rf, &wf) < 0)
          return -1;
      fd0 = -1;
      if ((fd0 = fdalloc(rf)) < 0 || (fd1 = fdalloc(wf)) < 0) {
          if (fd0 >= 0)
              proc->ofile[fd0] = 0;
          fileclose(rf);
          fileclose(wf);
          return -1;
      }
      fd[0] = fd0;
      fd[1] = fd1;
      return 0;
  }
  