minix文件系统源码分析之namei.c（上）（基于linux1.2.13）

/*
 *  linux/fs/minix/namei.c
 *
 *  Copyright (C) 1991, 1992  Linus Torvalds
 */

#ifdef MODULE
#include <linux/module.h>
#endif

#include <linux/sched.h>
#include <linux/minix_fs.h>
#include <linux/kernel.h>
#include <linux/string.h>
#include <linux/stat.h>
#include <linux/fcntl.h>
#include <linux/errno.h>

#include <asm/segment.h>

/*
 * comment out this line if you want names > info->s_namelen chars to be
 * truncated. Else they will be disallowed (ENAMETOOLONG).
 */
/* #define NO_TRUNCATE */

static inline int namecompare(int len, int maxlen,
  const char * name, const char * buffer)
{
  if (len > maxlen)
    return 0;
  if (len < maxlen && buffer[len])
    return 0;
  return !memcmp(name, buffer, len);
}

/*
 * ok, we cannot use strncmp, as the name is not in our data space.
 * Thus we'll have to use minix_match. No big problem. Match also makes
 * some sanity tests.
 *
 * NOTE! unlike strncmp, minix_match returns 1 for success, 0 for failure.
 */
// 比较文件名是否相等并且更新下一个要比较的地址偏移
static int minix_match(int len, const char * name,
  struct buffer_head * bh, unsigned long * offset,
  struct minix_sb_info * info)
{
  struct minix_dir_entry * de;
  // 目录项
  de = (struct minix_dir_entry *) (bh->b_data + *offset);
  // 指向下一个目录项，s_dirsize表示一个目录项的大小
  *offset += info->s_dirsize;
  // 参数校验,s_namelen是该文件系统对文件名的长度限制
  if (!de->inode || len > info->s_namelen)
    return 0;
  /* "" means "." ---> so paths like "/usr/lib//libc.a" work */
  // name是空并且当前目录项的名字是当前目录，则返回匹配，为了解决路径中连续两个斜杠的问题
  if (!len && (de->name[0]=='.') && (de->name[1]=='\0'))
    return 1;
  // 比较名字
  return namecompare(len,info->s_namelen,name,de->name);
}

/*
 *  minix_find_entry()
 *
 * finds an entry in the specified directory with the wanted name. It
 * returns the cache buffer in which the entry was found, and the entry
 * itself (as a parameter - res_dir). It does NOT read the inode of the
 * entry - you'll have to do that yourself if you want to.
 */
// 根据指定目录返回该目录下文件名为name的entry结构
static struct buffer_head * minix_find_entry(struct inode * dir,
  const char * name, int namelen, struct minix_dir_entry ** res_dir)
{
  unsigned long block, offset;
  struct buffer_head * bh;
  struct minix_sb_info * info;

  *res_dir = NULL;
  if (!dir || !dir->i_sb)
    return NULL;
  // minix超级块
  info = &dir->i_sb->u.minix_sb;
  // 文件名长度是否超过了限制
  if (namelen > info->s_namelen) {
#ifdef NO_TRUNCATE
    return NULL;
#else
    namelen = info->s_namelen;
#endif
  }
  bh = NULL;
  block = offset = 0;
  // 有没有超过了目录文件的大小
  while (block*BLOCK_SIZE+offset < dir->i_size) {
    if (!bh) {
      // 读入目录的内容，即一系列的目录项结构体
      bh = minix_bread(dir,block,0);
      // 读失败则跳过，继续读下一块
      if (!bh) {
        block++;
        continue;
      }
    }
    // 保存当前要比较的目录项,返回给调用方，offset在minix_match中被更新为下一个目录项
    *res_dir = (struct minix_dir_entry *) (bh->b_data + offset);
    // 匹配则返回
    if (minix_match(namelen,name,bh,&offset,info))
      return bh;
    // 不匹配，判断是否超过了数据块的大小，不是的话继续匹配下一个目录项
    if (offset < bh->b_size)
      continue;
    // 该块目录项已经比较完，还没有找到合适的
    brelse(bh);
    // 重置buffer，下一个循环读入下一个数据块
    bh = NULL;
    // 重置目录项偏移
    offset = 0;
    // 下一个循环要读取的块号
    block++;
  }
  brelse(bh);
  *res_dir = NULL;
  return NULL;
}
// 查找name对应的inode内容
int minix_lookup(struct inode * dir,const char * name, int len,
  struct inode ** result)
{
  int ino;
  struct minix_dir_entry * de;
  struct buffer_head * bh;

  *result = NULL;
  if (!dir)
    return -ENOENT;
  if (!S_ISDIR(dir->i_mode)) {
    iput(dir);
    return -ENOENT;
  }
  // 判断是否有name对应的目录项
  if (!(bh = minix_find_entry(dir,name,len,&de))) {
    iput(dir);
    return -ENOENT;
  }
  // inode号
  ino = de->inode;
  brelse(bh);
  // 读取inode的内容
  if (!(*result = iget(dir->i_sb,ino))) {
    iput(dir);
    return -EACCES;
  }
  iput(dir);
  return 0;
}

/*
 *  minix_add_entry()
 *
 * adds a file entry to the specified directory, returning a possible
 * error value if it fails.
 *
 * NOTE!! The inode part of 'de' is left at 0 - which means you
 * may not sleep between calling this and putting something into
 * the entry, as someone else might have used it while you slept.
 */
// 新增一个目录项
static int minix_add_entry(struct inode * dir,
  const char * name, int namelen,
  struct buffer_head ** res_buf,
  struct minix_dir_entry ** res_dir)
{
  int i;
  unsigned long block, offset;
  struct buffer_head * bh;
  struct minix_dir_entry * de;
  struct minix_sb_info * info;

  *res_buf = NULL;
  *res_dir = NULL;
  if (!dir || !dir->i_sb)
    return -ENOENT;
  // 超级块内容
  info = &dir->i_sb->u.minix_sb;
  if (namelen > info->s_namelen) {
#ifdef NO_TRUNCATE
    return -ENAMETOOLONG;
#else
    namelen = info->s_namelen;
#endif
  }
  if (!namelen)
    return -ENOENT;
  bh = NULL;
  block = offset = 0;
  while (1) {
    if (!bh) {
      bh = minix_bread(dir,block,1);
      if (!bh)
        return -ENOSPC;
    }
    // 当前目录项
    de = (struct minix_dir_entry *) (bh->b_data + offset);
    // 更新下一个目录项地址
    offset += info->s_dirsize;
    // 遍历完全部的目录项，都没有找到重复的项，则追加一个目录项
    if (block*bh->b_size + offset > dir->i_size) {
      // 初始化
      de->inode = 0;
      // 更新目录文件大小
      dir->i_size = block*bh->b_size + offset;
      // inode节点数据有更新，需要回写
      dir->i_dirt = 1;
    }
    // 已存在的目录项
    if (de->inode) {
      // 判断文件名为name的目录项是否已经存在
      if (namecompare(namelen, info->s_namelen, name, de->name)) {
        brelse(bh);
        return -EEXIST;
      }
    } else {
      // 新增一个目录项
      dir->i_mtime = dir->i_ctime = CURRENT_TIME;
      dir->i_dirt = 1;
      for (i = 0; i < info->s_namelen ; i++)
        de->name[i] = (i < namelen) ? name[i] : 0;
      dir->i_version = ++event;
      // 新增了一个目录项，需要回写
      mark_buffer_dirty(bh, 1);
      // 返回新增的目录项
      *res_dir = de;
      break;
    }
    // 还没超过块的大小，则不需要读入新的块
    if (offset < bh->b_size)
      continue;
    brelse(bh);
    // 重置然后读入下一块
    bh = NULL;
    offset = 0;
    block++;
  }
  *res_buf = bh;
  return 0;
}
// 新建一个文件
int minix_create(struct inode * dir,const char * name, int len, int mode,
  struct inode ** result)
{
  int error;
  struct inode * inode;
  struct buffer_head * bh;
  struct minix_dir_entry * de;

  *result = NULL;
  if (!dir)
    return -ENOENT;
  // 在硬盘和内存都新建一个inode节点
  inode = minix_new_inode(dir);
  if (!inode) {
    iput(dir);
    return -ENOSPC;
  }
  inode->i_op = &minix_file_inode_operations;
  inode->i_mode = mode;
  inode->i_dirt = 1;
  // 找到一个可用的目录项，de保存目录项地址
  error = minix_add_entry(dir,name,len, &bh ,&de);
  if (error) {
    inode->i_nlink--;
    inode->i_dirt = 1;
    iput(inode);
    iput(dir);
    return error;
  }
  // 保存inode号到目录项
  de->inode = inode->i_ino;
  mark_buffer_dirty(bh, 1);
  brelse(bh);
  iput(dir);
  *result = inode;
  return 0;
}
// 新建一个inode，文件类型根据mode判断
int minix_mknod(struct inode * dir, const char * name, int len, int mode, int rdev)
{
  int error;
  struct inode * inode;
  struct buffer_head * bh;
  struct minix_dir_entry * de;

  if (!dir)
    return -ENOENT;
  // 判断之前是否已经存在名字为name的目录项
  bh = minix_find_entry(dir,name,len,&de);
  if (bh) {
    brelse(bh);
    iput(dir);
    return -EEXIST;
  }
  // 新建一个inode
  inode = minix_new_inode(dir);
  if (!inode) {
    iput(dir);
    return -ENOSPC;
  }
  inode->i_uid = current->fsuid;
  inode->i_mode = mode;
  inode->i_op = NULL;
  if (S_ISREG(inode->i_mode))
    inode->i_op = &minix_file_inode_operations;
  else if (S_ISDIR(inode->i_mode)) {
    inode->i_op = &minix_dir_inode_operations;
    if (dir->i_mode & S_ISGID)
      inode->i_mode |= S_ISGID;
  }
  else if (S_ISLNK(inode->i_mode))
    inode->i_op = &minix_symlink_inode_operations;
  else if (S_ISCHR(inode->i_mode))
    inode->i_op = &chrdev_inode_operations;
  else if (S_ISBLK(inode->i_mode))
    inode->i_op = &blkdev_inode_operations;
  else if (S_ISFIFO(inode->i_mode))
    init_fifo(inode);
  if (S_ISBLK(mode) || S_ISCHR(mode))
    inode->i_rdev = rdev;
  inode->i_dirt = 1;
  // 新增一个目录项，de保存新增的地址
  error = minix_add_entry(dir, name, len, &bh, &de);
  if (error) {
    inode->i_nlink--;
    inode->i_dirt = 1;
    iput(inode);
    iput(dir);
    return error;
  }
  // 保存inode号到目录项中
  de->inode = inode->i_ino;
  mark_buffer_dirty(bh, 1);
  brelse(bh);
  iput(dir);
  iput(inode);
  return 0;
}
// 新建一个目录
int minix_mkdir(struct inode * dir, const char * name, int len, int mode)
{
  int error;
  struct inode * inode;
  struct buffer_head * bh, *dir_block;
  struct minix_dir_entry * de;
  struct minix_sb_info * info;

  if (!dir || !dir->i_sb) {
    iput(dir);
    return -EINVAL;
  }
  // 超级块
  info = &dir->i_sb->u.minix_sb;
  // 重复性判断
  bh = minix_find_entry(dir,name,len,&de);
  if (bh) {
    brelse(bh);
    iput(dir);
    return -EEXIST;
  }
  // 文件个数是否超过限制 
  if (dir->i_nlink >= MINIX_LINK_MAX) {
    iput(dir);
    return -EMLINK;
  }
  // 新增一个inode
  inode = minix_new_inode(dir);
  if (!inode) {
    iput(dir);
    return -ENOSPC;
  }
  inode->i_op = &minix_dir_inode_operations;
  // 设置文件的大小，为两个目录项，用来存..和.
  inode->i_size = 2 * info->s_dirsize;
  // 申请一个数据块，并读取第一块数据，即读入刚申请的那个块
  dir_block = minix_bread(inode,0,1);
  if (!dir_block) {
    iput(dir);
    inode->i_nlink--;
    inode->i_dirt = 1;
    iput(inode);
    return -ENOSPC;
  }
  de = (struct minix_dir_entry *) dir_block->b_data;
  // 第一项是保存.的，inode即自己
  de->inode=inode->i_ino;
  strcpy(de->name,".");
  // 第二项保存..的，即保存父目录项inode号
  de = (struct minix_dir_entry *) (dir_block->b_data + info->s_dirsize);
  de->inode = dir->i_ino;
  strcpy(de->name,"..");
  // inode本身链接数是一，.指向自己，所以是2个
  inode->i_nlink = 2;
  // 新增了东西，需要回写
  mark_buffer_dirty(dir_block, 1);
  brelse(dir_block);
  inode->i_mode = S_IFDIR | (mode & 0777 & ~current->fs->umask);
  if (dir->i_mode & S_ISGID)
    inode->i_mode |= S_ISGID;
  inode->i_dirt = 1;
  // 追加一个目录项，de保存新目录的地址
  error = minix_add_entry(dir, name, len, &bh, &de);
  if (error) {
    iput(dir);
    inode->i_nlink=0;
    iput(inode);
    return error;
  }
  // 保存inode号到目录项
  de->inode = inode->i_ino;
  mark_buffer_dirty(bh, 1);
  // 父目录链接数加一，因为子目录的..目录项指向他
  dir->i_nlink++;
  // 父inode也需要回写
  dir->i_dirt = 1;
  iput(dir);
  iput(inode);
  brelse(bh);
  return 0;
}

/*
 * routine to check that the specified directory is empty (for rmdir)
 */
// 判断目录是不是空的
static int empty_dir(struct inode * inode)
{
  unsigned int block, offset;
  struct buffer_head * bh;
  struct minix_dir_entry * de;
  struct minix_sb_info * info;

  if (!inode || !inode->i_sb)
    return 1;
  info = &inode->i_sb->u.minix_sb;
  block = 0;
  bh = NULL;
  // 偏移为两个目录项之后，从这个开始遍历全部目录项，有一个还有数据说明目录非空
  offset = 2*info->s_dirsize;
  // 目录文件的大小不是目录项的整数倍，说明数据有问题
  if (inode->i_size & (info->s_dirsize-1))
    goto bad_dir;
  // 目录文件大小小于两个目录项说明数据有问题，因为至少有.和..两项
  if (inode->i_size < offset)
    goto bad_dir;
  // 读取目录文件的第一块内容
  bh = minix_bread(inode,0,0);
  if (!bh)
    goto bad_dir;
  de = (struct minix_dir_entry *) bh->b_data;
  // 第一项没有内容或者不等于.则说明有问题
  if (!de->inode || strcmp(de->name,"."))
    goto bad_dir;
  de = (struct minix_dir_entry *) (bh->b_data + info->s_dirsize);
  // 第二项没有内容或者不等于..说明有问题
  if (!de->inode || strcmp(de->name,".."))
    goto bad_dir;
  // 遍历每个目录项
  while (block*BLOCK_SIZE+offset < inode->i_size) {
    if (!bh) {
      // 读入对应块的内容
      bh = minix_bread(inode,block,0);
      // 失败的就跳过
      if (!bh) {
        block++;
        continue;
      }
    }
    de = (struct minix_dir_entry *) (bh->b_data + offset);
    // 下一个目录项地址
    offset += info->s_dirsize;
    // 还有数据说明，说明非空，直接返回
    if (de->inode) {
      brelse(bh);
      return 0;
    }
    // 当前块的数据还没有读完
    if (offset < bh->b_size)
      continue;
    // 继续读下一块
    brelse(bh);
    bh = NULL;
    offset = 0;
    block++;
  }
  brelse(bh);
  return 1;
bad_dir:
  brelse(bh);
  printk("Bad directory on device %04x\n",inode->i_dev);
  return 1;
}
// 删除目录
int minix_rmdir(struct inode * dir, const char * name, int len)
{
  int retval;
  struct inode * inode;
  struct buffer_head * bh;
  struct minix_dir_entry * de;

  inode = NULL;
  // name对应的目录是否存在
  bh = minix_find_entry(dir,name,len,&de);
  retval = -ENOENT;
  if (!bh)
    goto end_rmdir;
  retval = -EPERM;
  // 获取目录文件对应的inode
  if (!(inode = iget(dir->i_sb, de->inode)))
    goto end_rmdir;
    // 权限校验
        if ((dir->i_mode & S_ISVTX) && !fsuser() &&
            current->fsuid != inode->i_uid &&
            current->fsuid != dir->i_uid)
    goto end_rmdir;
  if (inode->i_dev != dir->i_dev)
    goto end_rmdir;
  if (inode == dir)  /* we may not delete ".", but "../dir" is ok */
    goto end_rmdir;
  if (!S_ISDIR(inode->i_mode)) {
    retval = -ENOTDIR;
    goto end_rmdir;
  }
  // 目录非空
  if (!empty_dir(inode)) {
    retval = -ENOTEMPTY;
    goto end_rmdir;
  }
  if (de->inode != inode->i_ino) {
    retval = -ENOENT;
    goto end_rmdir;
  }
  if (inode->i_count > 1) {
    retval = -EBUSY;
    goto end_rmdir;
  }
  if (inode->i_nlink != 2)
    printk("empty directory has nlink!=2 (%d)\n",inode->i_nlink);
  // 置为未使用
  de->inode = 0;
  dir->i_version = ++event;
  mark_buffer_dirty(bh, 1);
  inode->i_nlink=0;
  inode->i_dirt=1;
  inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
  // 删除了..，所以父目录链接数减一
  dir->i_nlink--;
  dir->i_dirt=1;
  retval = 0;
end_rmdir:
  iput(dir);
  iput(inode);
  brelse(bh);
  return retval;
}
// 链接数减一
int minix_unlink(struct inode * dir, const char * name, int len)
{
  int retval;
  struct inode * inode;
  struct buffer_head * bh;
  struct minix_dir_entry * de;

repeat:
  retval = -ENOENT;
  inode = NULL;
  bh = minix_find_entry(dir,name,len,&de);
  if (!bh)
    goto end_unlink;
  if (!(inode = iget(dir->i_sb, de->inode)))
    goto end_unlink;
  retval = -EPERM;
  if (S_ISDIR(inode->i_mode))
    goto end_unlink;
  if (de->inode != inode->i_ino) {
    iput(inode);
    brelse(bh);
    current->counter = 0;
    schedule();
    goto repeat;
  }
  if ((dir->i_mode & S_ISVTX) && !fsuser() &&
      current->fsuid != inode->i_uid &&
      current->fsuid != dir->i_uid)
    goto end_unlink;
  if (de->inode != inode->i_ino) {
    retval = -ENOENT;
    goto end_unlink;
  }
  if (!inode->i_nlink) {
    printk("Deleting nonexistent file (%04x:%lu), %d\n",
      inode->i_dev,inode->i_ino,inode->i_nlink);
    inode->i_nlink=1;
  }
  de->inode = 0;
  dir->i_version = ++event;
  mark_buffer_dirty(bh, 1);
  dir->i_ctime = dir->i_mtime = CURRENT_TIME;
  dir->i_dirt = 1;
  inode->i_nlink--;
  inode->i_ctime = dir->i_ctime;
  inode->i_dirt = 1;
  retval = 0;
end_unlink:
  brelse(bh);
  iput(inode);
  iput(dir);
  return retval;
}
// 生成一个文件保存另一个文件路径，即软链
int minix_symlink(struct inode * dir, const char * name, int len, const char * symname)
{
  struct minix_dir_entry * de;
  struct inode * inode = NULL;
  struct buffer_head * bh = NULL, * name_block = NULL;
  int i;
  char c;

  if (!(inode = minix_new_inode(dir))) {
    iput(dir);
    return -ENOSPC;
  }
  inode->i_mode = S_IFLNK | 0777;
  inode->i_op = &minix_symlink_inode_operations;
  name_block = minix_bread(inode,0,1);
  if (!name_block) {
    iput(dir);
    inode->i_nlink--;
    inode->i_dirt = 1;
    iput(inode);
    return -ENOSPC;
  }
  i = 0;
// 软链文章内容
  while (i < 1023 && (c=*(symname++)))
    name_block->b_data[i++] = c;
  name_block->b_data[i] = 0;
  mark_buffer_dirty(name_block, 1);
  brelse(name_block);
  inode->i_size = i;
  inode->i_dirt = 1;
  // 新增一个目录项
  bh = minix_find_entry(dir,name,len,&de);
  if (bh) {
    inode->i_nlink--;
    inode->i_dirt = 1;
    iput(inode);
    brelse(bh);
    iput(dir);
    return -EEXIST;
  }
  i = minix_add_entry(dir, name, len, &bh, &de);
  if (i) {
    inode->i_nlink--;
    inode->i_dirt = 1;
    iput(inode);
    iput(dir);
    return i;
  }
  de->inode = inode->i_ino;
  mark_buffer_dirty(bh, 1);
  brelse(bh);
  iput(dir);
  iput(inode);
  return 0;
}
// 增加一个硬链接
int minix_link(struct inode * oldinode, struct inode * dir, const char * name, int len)
{
  int error;
  struct minix_dir_entry * de;
  struct buffer_head * bh;

  if (S_ISDIR(oldinode->i_mode)) {
    iput(oldinode);
    iput(dir);
    return -EPERM;
  }
  if (oldinode->i_nlink >= MINIX_LINK_MAX) {
    iput(oldinode);
    iput(dir);
    return -EMLINK;
  }
  // 去重
  bh = minix_find_entry(dir,name,len,&de);
  if (bh) {
    brelse(bh);
    iput(dir);
    iput(oldinode);
    return -EEXIST;
  }
  // 查找空闲目录项，de是新目录项地址
  error = minix_add_entry(dir, name, len, &bh, &de);
  if (error) {
    iput(dir);
    iput(oldinode);
    return error;
  }
  // 保存inode号
  de->inode = oldinode->i_ino;
  mark_buffer_dirty(bh, 1);
  brelse(bh);
  iput(dir);
  // inode链接数减一，因为多了一个目录项指向他
  oldinode->i_nlink++;
  oldinode->i_ctime = CURRENT_TIME;
  oldinode->i_dirt = 1;
  iput(oldinode);
  return 0;
}