/*
* linux/fs/namei.c
*
* (C) 1991 Linus Torvalds
*/
/*
* Some corrections by tytso.
*/
/*
* tytso 作了一些纠正。
*/
#include <linux/sched.h> // 调度程序头文件,定义了任务结构task_struct、初始任务0 的数据,
// 还有一些有关描述符参数设置和获取的嵌入式汇编函数宏语句。
#include <linux/kernel.h> // 内核头文件。含有一些内核常用函数的原形定义。
#include <asm/segment.h> // 段操作头文件。定义了有关段寄存器操作的嵌入式汇编函数。
#include <string.h> // 字符串头文件。主要定义了一些有关字符串操作的嵌入函数。
#include <fcntl.h> // 文件控制头文件。用于文件及其描述符的操作控制常数符号的定义。
#include <errno.h> // 错误号头文件。包含系统中各种出错号。(Linus 从minix 中引进的)。
#include <const.h> // 常数符号头文件。目前仅定义了i 节点中i_mode 字段的各标志位。
#include <sys/stat.h> // 文件状态头文件。含有文件或文件系统状态结构stat{}和常量。
// 访问模式宏。x 是include/fcntl.h 第7 行开始定义的文件访问标志。
// 根据x 值索引对应数值(数值表示rwx 权限: r, w, rw, wxrwxrwx)(数值是8 进制)。
#define ACC_MODE(x) ( "\004\002\006\377"[(x)&O_ACCMODE])
/*
* comment out this line if you want names > NAME_LEN chars to be
* truncated. Else they will be disallowed.
*/
/*
* 如果想让文件名长度>NAME_LEN 的字符被截掉,就将下面定义注释掉。
*/
/* #define NO_TRUNCATE */
#define MAY_EXEC 1 // 可执行(可进入)。
#define MAY_WRITE 2 // 可写。
#define MAY_READ 4 // 可读。
/*
* permission()
*
* is used to check for read/write/execute permissions on a file.
* I don't know if we should look at just the euid or both euid and
* uid, but that should be easily changed.
*/
/*
* permission()
* 该函数用于检测一个文件的读/写/执行权限。我不知道是否只需检查euid,还是
* 需要检查euid 和uid 两者,不过这很容易修改。
*/
检测文件访问许可权限。
// 参数:inode - 文件对应的i 节点;mask - 访问属性屏蔽码。
// 返回:访问许可返回1,否则返回0。
static int
permission (struct m_inode *inode, int mask)
{
int mode = inode->i_mode; // 文件访问属性
/* special case: not even root can read/write a deleted file */
/* 特殊情况:即使是超级用户(root)也不能读/写一个已被删除的文件 */
// 如果i 节点有对应的设备,但该i 节点的连接数等于0,则返回。
if (inode->i_dev && !inode->i_nlinks)
return 0;
// 否则,如果进程的有效用户id(euid)与i 节点的用户id 相同,则取文件宿主的用户访问权限。
else if (current->euid == inode->i_uid)
mode >>= 6;
// 否则,如果进程的有效组id(egid)与i 节点的组id 相同,则取组用户的访问权限。
else if (current->egid == inode->i_gid)
mode >>= 3;
// 如果上面所取的的访问权限与屏蔽码相同,或者是超级用户,则返回1,否则返回0。
if (((mode & mask & 0007) == mask) || suser ())
return 1;
return 0;
}
/*
* ok, we cannot use strncmp, as the name is not in our data space.
* Thus we'll have to use match. No big problem. Match also makes
* some sanity tests.
*
* NOTE! unlike strncmp, match returns 1 for success, 0 for failure.
*/
/*
* ok,我们不能使用strncmp 字符串比较函数,因为名称不在我们的数据空间(不在内核空间)。
* 因而我们只能使用match()。问题不大。match()同样也处理一些完整的测试。
*
* 注意!与strncmp 不同的是match()成功时返回1,失败时返回0。
*/
指定长度字符串比较函数。
// 参数:len - 比较的字符串长度;name - 文件名指针;de - 目录项结构。
// 返回:相同返回1,不同返回0。
static int
match (int len, const char *name, struct dir_entry *de)
{
register int same __asm__ ("ax");
// 如果目录项指针空,或者目录项i 节点等于0,或者要比较的字符串长度超过文件名长度,则返回0。
if (!de || !de->inode || len > NAME_LEN)
return 0;
// 如果要比较的长度len 小于NAME_LEN,但是目录项中文件名长度超过len,则返回0。
if (len NAME_LEN && de->name[len])
return 0;
// 下面嵌入汇编语句,在用户数据空间(fs)执行字符串的比较操作。
// %0 - eax(比较结果same);%1 - eax(eax 初值0);%2 - esi(名字指针);%3 - edi(目录项名指针);
// %4 - ecx(比较的字节长度值len)。
__asm__ ("cld\n\t" // 清方向位。
"fs ; repe ; cmpsb\n\t" // 用户空间执行循环比较[esi++]和[edi++]操作,
"setz %%al" // 若比较结果一样(z=0)则设置al=1(same=eax)。
: "=a" (same): "" (0), "S" ((long) name), "D" ((long) de->name), "c" (len):"cx", "di",
"si");
return same; // 返回比较结果。
}
/*
* 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.
*
* This also takes care of the few special cases due to '..'-traversal
* over a pseudo-root and a mount point.
*/
/*
* find_entry()
* 在指定的目录中寻找一个与名字匹配的目录项。返回一个含有找到目录项的高速
* 缓冲区以及目录项本身(作为一个参数 - res_dir)。并不读目录项的i 节点 - 如
* 果需要的话需自己操作。
*
* '..'目录项,操作期间也会对几种特殊情况分别处理 - 比如横越一个伪根目录以
* 及安装点。
*/
查找指定目录和文件名的目录项。
// 参数:dir - 指定目录i 节点的指针;name - 文件名;namelen - 文件名长度;
// 返回:高速缓冲区指针;res_dir - 返回的目录项结构指针;
static struct buffer_head *
find_entry (struct m_inode **dir,
const char *name, int namelen, struct dir_entry **res_dir)
{
int entries;
int block, i;
struct buffer_head *bh;
struct dir_entry *de;
struct super_block *sb;
// 如果定义了NO_TRUNCATE,则若文件名长度超过最大长度NAME_LEN,则返回。
#ifdef NO_TRUNCATE
if (namelen > NAME_LEN)
return NULL;
//如果没有定义NO_TRUNCATE,则若文件名长度超过最大长度NAME_LEN,则截短之。
#else
if (namelen > NAME_LEN)
namelen = NAME_LEN;
#endif
// 计算本目录中目录项项数entries。置空返回目录项结构指针。
entries = (*dir)->i_size / (sizeof (struct dir_entry));
*res_dir = NULL;
// 如果文件名长度等于0,则返回NULL,退出。
if (!namelen)
return NULL;
/* check for '..', as we might have to do some "magic" for it */
/* 检查目录项'..',因为可能需要对其特别处理 */
if (namelen == 2 && get_fs_byte (name) == '.'
&& get_fs_byte (name + 1) == '.')
{
/* '..' in a pseudo-root results in a faked '.' (just change namelen) */
/* 伪根中的'..'如同一个假'.'(只需改变名字长度) */
// 如果当前进程的根节点指针即是指定的目录,则将文件名修改为'.',
if ((*dir) == current->root)
namelen = 1;
// 否则如果该目录的i 节点号等于ROOT_INO(1)的话,说明是文件系统根节点。则取文件系统的超级块。
else if ((*dir)->i_num == ROOT_INO)
{
/* '..' over a mount-point results in 'dir' being exchanged for the mounted
directory-inode. NOTE! We set mounted, so that we can iput the new dir */
/* 在一个安装点上的'..'将导致目录交换到安装到文件系统的目录i 节点。
注意!由于设置了mounted 标志,因而我们能够取出该新目录 */
sb = get_super ((*dir)->i_dev);
// 如果被安装到的i 节点存在,则先释放原i 节点,然后对被安装到的i 节点进行处理。
// 让*dir 指向该被安装到的i 节点;该i 节点的引用数加1。
if (sb->s_imount)
{
iput (*dir);
(*dir) = sb->s_imount;
(*dir)->i_count++;
}
}
}
// 如果该i 节点所指向的第一个直接磁盘块号为0,则返回NULL,退出。
if (!(block = (*dir)->i_zone[0]))
return NULL;
// 从节点所在设备读取指定的目录项数据块,如果不成功,则返回NULL,退出。
if (!(bh = bread ((*dir)->i_dev, block)))
return NULL;
// 在目录项数据块中搜索匹配指定文件名的目录项,首先让de 指向数据块,并在不超过目录中目录项数
// 的条件下,循环执行搜索。
i = 0;
de = (struct dir_entry *) bh->b_data;
while (i entries)
{
// 如果当前目录项数据块已经搜索完,还没有找到匹配的目录项,则释放当前目录项数据块。
if ((char *) de >= BLOCK_SIZE + bh->b_data)
{
brelse (bh);
bh = NULL;
// 在读入下一目录项数据块。若这块为空,则只要还没有搜索完目录中的所有目录项,就跳过该块,
// 继续读下一目录项数据块。若该块不空,就让de 指向该目录项数据块,继续搜索。
if (!(block = bmap (*dir, i / DIR_ENTRIES_PER_BLOCK)) ||
!(bh = bread ((*dir)->i_dev, block)))
{
i += DIR_ENTRIES_PER_BLOCK;
continue;
}
de = (struct dir_entry *) bh->b_data;
}
// 如果找到匹配的目录项的话,则返回该目录项结构指针和该目录项数据块指针,退出。
if (match (namelen, name, de))
{
*res_dir = de;
return bh;
}
// 否则继续在目录项数据块中比较下一个目录项。
de++;
i++;
}
// 若指定目录中的所有目录项都搜索完还没有找到相应的目录项,则释放目录项数据块,返回NULL。
brelse (bh);
return NULL;
}
/*
* add_entry()
*
* adds a file entry to the specified directory, using the same
* semantics as find_entry(). It returns NULL if it failed.
*
* 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.
*/
/*
* add_entry()
* 使用与find_entry()同样的方法,往指定目录中添加一文件目录项。
* 如果失败则返回NULL。
*
* 注意!!'de'(指定目录项结构指针)的i 节点部分被设置为0 - 这表示
* 在调用该函数和往目录项中添加信息之间不能睡眠,因为若睡眠那么其它
* 人(进程)可能会已经使用了该目录项。
*/
根据指定的目录和文件名添加目录项。
// 参数:dir - 指定目录的i 节点;name - 文件名;namelen - 文件名长度;
// 返回:高速缓冲区指针;res_dir - 返回的目录项结构指针;
static struct buffer_head *
add_entry (struct m_inode *dir,
const char *name, int namelen, struct dir_entry **res_dir)
{
int block, i;
struct buffer_head *bh;
struct dir_entry *de;
*res_dir = NULL;
// 如果定义了NO_TRUNCATE,则若文件名长度超过最大长度NAME_LEN,则返回。
#ifdef NO_TRUNCATE
if (namelen > NAME_LEN)
return NULL;
//如果没有定义NO_TRUNCATE,则若文件名长度超过最大长度NAME_LEN,则截短之。
#else
if (namelen > NAME_LEN)
namelen = NAME_LEN;
#endif
// 如果文件名长度等于0,则返回NULL,退出。
if (!namelen)
return NULL;
// 如果该目录i 节点所指向的第一个直接磁盘块号为0,则返回NULL 退出。
if (!(block = dir->i_zone[0]))
return NULL;
// 如果读取该磁盘块失败,则返回NULL 并退出。
if (!(bh = bread (dir->i_dev, block)))
return NULL;
// 在目录项数据块中循环查找最后未使用的目录项。首先让目录项结构指针de 指向高速缓冲的数据块
// 开始处,也即第一个目录项。
i = 0;
de = (struct dir_entry *) bh->b_data;
while (1)
{
// 如果当前判别的目录项已经超出当前数据块,则释放该数据块,重新申请一块磁盘块block。如果
// 申请失败,则返回NULL,退出。
if ((char *) de >= BLOCK_SIZE + bh->b_data)
{
brelse (bh);
bh = NULL;
block = create_block (dir, i / DIR_ENTRIES_PER_BLOCK);
if (!block)
return NULL;
// 如果读取磁盘块返回的指针为空,则跳过该块继续。
if (!(bh = bread (dir->i_dev, block)))
{
i += DIR_ENTRIES_PER_BLOCK;
continue;
}
// 否则,让目录项结构指针de 志向该块的高速缓冲数据块开始处。
de = (struct dir_entry *) bh->b_data;
}
// 如果当前所操作的目录项序号i*目录结构大小已经超过了该目录所指出的大小i_size,则说明该第i
// 个目录项还未使用,我们可以使用它。于是对该目录项进行设置(置该目录项的i 节点指针为空)。并
// 更新该目录的长度值(加上一个目录项的长度,设置目录的i 节点已修改标志,再更新该目录的改变时
// 间为当前时间。
if (i * sizeof (struct dir_entry) >= dir->i_size)
{
de->inode = 0;
dir->i_size = (i + 1) * sizeof (struct dir_entry);
dir->i_dirt = 1;
dir->i_ctime = CURRENT_TIME;
}
// 若该目录项的i 节点为空,则表示找到一个还未使用的目录项。于是更新目录的修改时间为当前时间。
// 并从用户数据区复制文件名到该目录项的文件名字段,置相应的高速缓冲块已修改标志。返回该目录
// 项的指针以及该高速缓冲区的指针,退出。
if (!de->inode)
{
dir->i_mtime = CURRENT_TIME;
for (i = 0; i NAME_LEN; i++)
de->name[i] = (i namelen) ? get_fs_byte (name + i) : 0;
bh->b_dirt = 1;
*res_dir = de;
return bh;
}
// 如果该目录项已经被使用,则继续检测下一个目录项。
de++;
i++;
}
// 执行不到这里。也许Linus 在写这段代码时是先复制了上面find_entry()的代码,而后修改的?。
brelse (bh);
return NULL;
}
/*
* get_dir()
*
* Getdir traverses the pathname until it hits the topmost directory.
* It returns NULL on failure.
*/
/*
* get_dir()
* 该函数根据给出的路径名进行搜索,直到达到最顶端的目录。
* 如果失败则返回NULL。
*/
搜寻指定路径名的目录。
// 参数:pathname - 路径名。
// 返回:目录的i 节点指针。失败时返回NULL。
static struct m_inode *
get_dir (const char *pathname)
{
char c;
const char *thisname;
struct m_inode *inode;
struct buffer_head *bh;
int namelen, inr, idev;
struct dir_entry *de;
// 如果进程没有设定根i 节点,或者该进程根i 节点的引用为0,则系统出错,死机。
if (!current->root || !current->root->i_count)
panic ("No root inode");
// 如果进程的当前工作目录指针为空,或者该当前目录i 节点的引用计数为0,也是系统有问题,死机。
if (!current->pwd || !current->pwd->i_count)
panic ("No cwd inode");
// 如果用户指定的路径名的第1 个字符是'/',则说明路径名是绝对路径名。则从根i 节点开始操作。
if ((c = get_fs_byte (pathname)) == '/')
{
inode = current->root;
pathname++;
// 否则若第一个字符是其它字符,则表示给定的是相对路径名。应从进程的当前工作目录开始操作。
// 则取进程当前工作目录的i 节点。
}
else if (c)
inode = current->pwd;
// 否则表示路径名为空,出错。返回NULL,退出。
else
return NULL; /* empty name is bad *//* 空的路径名是错误的 */
// 将取得的i 节点引用计数增1。
inode->i_count++;
while (1)
{
// 若该i 节点不是目录节点,或者没有可进入的访问许可,则释放该i 节点,返回NULL,退出。
thisname = pathname;
if (!S_ISDIR (inode->i_mode) || !permission (inode, MAY_EXEC))
{
iput (inode);
return NULL;
}
// 从路径名开始起搜索检测字符,直到字符已是结尾符(NULL)或者是'/',此时namelen 正好是当前处理
// 目录名的长度。如果最后也是一个目录名,但其后没有加'/',则不会返回该最后目录的i 节点!
// 比如:/var/log/httpd,将只返回log/目录的i 节点。
for (namelen = 0; (c = get_fs_byte (pathname++)) && (c != '/');
namelen++)
/* nothing */ ;
// 若字符是结尾符NULL,则表明已经到达指定目录,则返回该i 节点指针,退出。
if (!c)
return inode;
// 调用查找指定目录和文件名的目录项函数,在当前处理目录中寻找子目录项。如果没有找到,则释放
// 该i 节点,并返回NULL,退出。
if (!(bh = find_entry (&inode, thisname, namelen, &de)))
{
iput (inode);
return NULL;
}
// 取该子目录项的i 节点号inr 和设备号idev,释放包含该目录项的高速缓冲块和该i 节点。
inr = de->inode;
idev = inode->i_dev;
brelse (bh);
iput (inode);
// 取节点号inr 的i 节点信息,若失败,则返回NULL,退出。否则继续以该子目录的i 节点进行操作。
if (!(inode = iget (idev, inr)))
return NULL;
}
}
/*
* dir_namei()
*
* dir_namei() returns the inode of the directory of the
* specified name, and the name within that directory.
*/
/*
* dir_namei()
* dir_namei()函数返回指定目录名的i 节点指针,以及在最顶层目录的名称。
*/
// 参数:pathname - 目录路径名;namelen - 路径名长度。
// 返回:指定目录名最顶层目录的i 节点指针和最顶层目录名及其长度。
static struct m_inode *
dir_namei (const char *pathname, int *namelen, const char **name)
{
char c;
const char *basename;
struct m_inode *dir;
// 取指定路径名最顶层目录的i 节点,若出错则返回NULL,退出。
if (!(dir = get_dir (pathname)))
return NULL;
// 对路径名pathname 进行搜索检测,查处最后一个'/'后面的名字字符串,计算其长度,并返回最顶
// 层目录的i 节点指针。
basename = pathname;
while (c = get_fs_byte (pathname++))
if (c == '/')
basename = pathname;
*namelen = pathname - basename - 1;
*name = basename;
return dir;
}
/*
* namei()
*
* is used by most simple commands to get the inode of a specified name.
* Open, link etc use their own routines, but this is enough for things
* like 'chmod' etc.
*/
/*
* namei()
* 该函数被许多简单的命令用于取得指定路径名称的i 节点。open、link 等则使用它们
* 自己的相应函数,但对于象修改模式'chmod'等这样的命令,该函数已足够用了。
*/
取指定路径名的i 节点。
// 参数:pathname - 路径名。
// 返回:对应的i 节点。
struct m_inode *
namei (const char *pathname)
{
const char *basename;
int inr, dev, namelen;
struct m_inode *dir;
struct buffer_head *bh;
struct dir_entry *de;
// 首先查找指定路径的最顶层目录的目录名及其i 节点,若不存在,则返回NULL,退出。
if (!(dir = dir_namei (pathname, &namelen, &basename)))
return NULL;
// 如果返回的最顶层名字的长度是0,则表示该路径名以一个目录名为最后一项。
if (!namelen) /* special case: '/usr/' etc */
return dir; /* 对应于'/usr/'等情况 */
// 在返回的顶层目录中寻找指定文件名的目录项的i 节点。因为如果最后也是一个目录名,但其后没
// 有加'/',则不会返回该最后目录的i 节点!比如:/var/log/httpd,将只返回log/目录的i 节点。
// 因此dir_namei()将不以'/'结束的最后一个名字当作一个文件名来看待。因此这里需要单独对这种
// 情况使用寻找目录项i 节点函数find_entry()进行处理。
bh = find_entry (&dir, basename, namelen, &de);
if (!bh)
{
iput (dir);
return NULL;
}
// 取该目录项的i 节点号和目录的设备号,并释放包含该目录项的高速缓冲区以及目录i 节点。
inr = de->inode;
dev = dir->i_dev;
brelse (bh);
iput (dir);
// 取对应节号的i 节点,修改其被访问时间为当前时间,并置已修改标志。最后返回该i 节点指针。
dir = iget (dev, inr);
if (dir)
{
dir->i_atime = CURRENT_TIME;
dir->i_dirt = 1;
}
return dir;
}
/*
* open_namei()
*
* namei for open - this is in fact almost the whole open-routine.
*/
/*
* open_namei()
* open()所使用的namei 函数 - 这其实几乎是完整的打开文件程序。
*/
文件打开namei 函数。
// 参数:pathname - 文件路径名;flag - 文件打开标志;mode - 文件访问许可属性;
// 返回:成功返回0,否则返回出错码;res_inode - 返回的对应文件路径名的的i 节点指针。
int
open_namei (const char *pathname, int flag, int mode,
struct m_inode **res_inode)
{
const char *basename;
int inr, dev, namelen;
struct m_inode *dir, *inode;
struct buffer_head *bh;
struct dir_entry *de;
// 如果文件访问许可模式标志是只读(0),但文件截0 标志O_TRUNC 却置位了,则改为只写标志。
if ((flag & O_TRUNC) && !(flag & O_ACCMODE))
flag |= O_WRONLY;
// 使用进程的文件访问许可屏蔽码,屏蔽掉给定模式中的相应位,并添上普通文件标志。
mode &= 0777 & ~current->umask;
mode |= I_REGULAR;
// 根据路径名寻找到对应的i 节点,以及最顶端文件名及其长度。
if (!(dir = dir_namei (pathname, &namelen, &basename)))
return -ENOENT;
// 如果最顶端文件名长度为0(例如'/usr/'这种路径名的情况),那么若打开操作不是创建、截0,
// 则表示打开一个目录名,直接返回该目录的i 节点,并退出。
if (!namelen)
{ /* special case: '/usr/' etc */
if (!(flag & (O_ACCMODE | O_CREAT | O_TRUNC)))
{
*res_inode = dir;
return 0;
}
// 否则释放该i 节点,返回出错码。
iput (dir);
return -EISDIR;
}
// 在dir 节点对应的目录中取文件名对应的目录项结构de 和该目录项所在的高速缓冲区。
bh = find_entry (&dir, basename, namelen, &de);
// 如果该高速缓冲指针为NULL,则表示没有找到对应文件名的目录项,因此只可能是创建文件操作。
if (!bh)
{
// 如果不是创建文件,则释放该目录的i 节点,返回出错号退出。
if (!(flag & O_CREAT))
{
iput (dir);
return -ENOENT;
}
// 如果用户在该目录没有写的权力,则释放该目录的i 节点,返回出错号退出。
if (!permission (dir, MAY_WRITE))
{
iput (dir);
return -EACCES;
}
// 在目录节点对应的设备上申请一个新i 节点,若失败,则释放目录的i 节点,并返回没有空间出错码。
inode = new_inode (dir->i_dev);
if (!inode)
{
iput (dir);
return -ENOSPC;
}
// 否则使用该新i 节点,对其进行初始设置:置节点的用户id;对应节点访问模式;置已修改标志。
inode->i_uid = current->euid;
inode->i_mode = mode;
inode->i_dirt = 1;
// 然后在指定目录dir 中添加一新目录项。
bh = add_entry (dir, basename, namelen, &de);
// 如果返回的应该含有新目录项的高速缓冲区指针为NULL,则表示添加目录项操作失败。于是将该
// 新i 节点的引用连接计数减1;并释放该i 节点与目录的i 节点,返回出错码,退出。
if (!bh)
{
inode->i_nlinks--;
iput (inode);
iput (dir);
return -ENOSPC;
}
// 初始设置该新目录项:置i 节点号为新申请到的i 节点的号码;并置高速缓冲区已修改标志。然后
// 释放该高速缓冲区,释放目录的i 节点。返回新目录项的i 节点指针,退出。
de->inode = inode->i_num;
bh->b_dirt = 1;
brelse (bh);
iput (dir);
*res_inode = inode;
return 0;
}
// 若上面在目录中取文件名对应的目录项结构操作成功(也即bh 不为NULL),取出该目录项的i 节点号
// 和其所在的设备号,并释放该高速缓冲区以及目录的i 节点。
inr = de->inode;
dev = dir->i_dev;
brelse (bh);
iput (dir);
// 如果独占使用标志O_EXCL 置位,则返回文件已存在出错码,退出。
if (flag & O_EXCL)
return -EEXIST;
// 如果取该目录项对应i 节点的操作失败,则返回访问出错码,退出。
if (!(inode = iget (dev, inr)))
return -EACCES;
// 若该i 节点是一个目录的节点并且访问模式是只读或只写,或者没有访问的许可权限,则释放该i
// 节点,返回访问权限出错码,退出。
if ((S_ISDIR (inode->i_mode) && (flag & O_ACCMODE)) ||
!permission (inode, ACC_MODE (flag)))
{
iput (inode);
return -EPERM;
}
// 更新该i 节点的访问时间字段为当前时间。
inode->i_atime = CURRENT_TIME;
// 如果设立了截0 标志,则将该i 节点的文件长度截为0。
if (flag & O_TRUNC)
truncate (inode);
// 最后返回该目录项i 节点的指针,并返回0(成功)。
*res_inode = inode;
return 0;
}
系统调用函数 - 创建一个特殊文件或普通文件节点(node)。
// 创建名称为filename,由mode 和dev 指定的文件系统节点(普通文件、设备特殊文件或命名管道)。
// 参数:filename - 路径名;mode - 指定使用许可以及所创建节点的类型;dev - 设备号。
// 返回:成功则返回0,否则返回出错码。
int
sys_mknod (const char *filename, int mode, int dev)
{
const char *basename;
int namelen;
struct m_inode *dir, *inode;
struct buffer_head *bh;
struct dir_entry *de;
// 如果不是超级用户,则返回访问许可出错码。
if (!suser ())
return -EPERM;
// 如果找不到对应路径名目录的i 节点,则返回出错码。
if (!(dir = dir_namei (filename, &namelen, &basename)))
return -ENOENT;
// 如果最顶端的文件名长度为0,则说明给出的路径名最后没有指定文件名,释放该目录i 节点,返回
// 出错码,退出。
if (!namelen)
{
iput (dir);
return -ENOENT;
}
// 如果在该目录中没有写的权限,则释放该目录的i 节点,返回访问许可出错码,退出。
if (!permission (dir, MAY_WRITE))
{
iput (dir);
return -EPERM;
}
// 如果对应路径名上最后的文件名的目录项已经存在,则释放包含该目录项的高速缓冲区,释放目录
// 的i 节点,返回文件已经存在出错码,退出。
bh = find_entry (&dir, basename, namelen, &de);
if (bh)
{
brelse (bh);
iput (dir);
return -EEXIST;
}
// 申请一个新的i 节点,如果不成功,则释放目录的i 节点,返回无空间出错码,退出。
inode = new_inode (dir->i_dev);
if (!inode)
{
iput (dir);
return -ENOSPC;
}
// 设置该i 节点的属性模式。如果要创建的是块设备文件或者是字符设备文件,则令i 节点的直接块
// 指针0 等于设备号。
inode->i_mode = mode;
if (S_ISBLK (mode) || S_ISCHR (mode))
inode->i_zone[0] = dev;
// 设置该i 节点的修改时间、访问时间为当前时间。
inode->i_mtime = inode->i_atime = CURRENT_TIME;
inode->i_dirt = 1;
// 在目录中新添加一个目录项,如果失败(包含该目录项的高速缓冲区指针为NULL),则释放目录的
// i 节点;所申请的i 节点引用连接计数复位,并释放该i 节点。返回出错码,退出。
bh = add_entry (dir, basename, namelen, &de);
if (!bh)
{
iput (dir);
inode->i_nlinks = 0;
iput (inode);
return -ENOSPC;
}
// 令该目录项的i 节点字段等于新i 节点号,置高速缓冲区已修改标志,释放目录和新的i 节点,释放
// 高速缓冲区,最后返回0(成功)。
de->inode = inode->i_num;
bh->b_dirt = 1;
iput (dir);
iput (inode);
brelse (bh);
return 0;
}
系统调用函数 - 创建目录。
// 参数:pathname - 路径名;mode - 目录使用的权限属性。
// 返回:成功则返回0,否则返回出错码。
int
sys_mkdir (const char *pathname, int mode)
{
const char *basename;
int namelen;
struct m_inode *dir, *inode;
struct buffer_head *bh, *dir_block;
struct dir_entry *de;
// 如果不是超级用户,则返回访问许可出错码。
if (!suser ())
return -EPERM;
// 如果找不到对应路径名目录的i 节点,则返回出错码。
if (!(dir = dir_namei (pathname, &namelen, &basename)))
return -ENOENT;
// 如果最顶端的文件名长度为0,则说明给出的路径名最后没有指定文件名,释放该目录i 节点,返回
// 出错码,退出。
if (!namelen)
{
iput (dir);
return -ENOENT;
}
// 如果在该目录中没有写的权限,则释放该目录的i 节点,返回访问许可出错码,退出。
if (!permission (dir, MAY_WRITE))
{
iput (dir);
return -EPERM;
}
// 如果对应路径名上最后的文件名的目录项已经存在,则释放包含该目录项的高速缓冲区,释放目录
// 的i 节点,返回文件已经存在出错码,退出。
bh = find_entry (&dir, basename, namelen, &de);
if (bh)
{
brelse (bh);
iput (dir);
return -EEXIST;
}
// 申请一个新的i 节点,如果不成功,则释放目录的i 节点,返回无空间出错码,退出。
inode = new_inode (dir->i_dev);
if (!inode)
{
iput (dir);
return -ENOSPC;
}
// 置该新i 节点对应的文件长度为32(一个目录项的大小),置节点已修改标志,以及节点的修改时间
// 和访问时间。
inode->i_size = 32;
inode->i_dirt = 1;
inode->i_mtime = inode->i_atime = CURRENT_TIME;
// 为该i 节点申请一磁盘块,并令节点第一个直接块指针等于该块号。如果申请失败,则释放对应目录
// 的i 节点;复位新申请的i 节点连接计数;释放该新的i 节点,返回没有空间出错码,退出。
if (!(inode->i_zone[0] = new_block (inode->i_dev)))
{
iput (dir);
inode->i_nlinks--;
iput (inode);
return -ENOSPC;
}
// 置该新的i 节点已修改标志。
inode->i_dirt = 1;
// 读新申请的磁盘块。若出错,则释放对应目录的i 节点;释放申请的磁盘块;复位新申请的i 节点
// 连接计数;释放该新的i 节点,返回没有空间出错码,退出。
if (!(dir_block = bread (inode->i_dev, inode->i_zone[0])))
{
iput (dir);
free_block (inode->i_dev, inode->i_zone[0]);
inode->i_nlinks--;
iput (inode);
return -ERROR;
}
// 令de 指向目录项数据块,置该目录项的i 节点号字段等于新申请的i 节点号,名字字段等于"."。
de = (struct dir_entry *) dir_block->b_data;
de->inode = inode->i_num;
strcpy (de->name, ".");
// 然后de 指向下一个目录项结构,该结构用于存放上级目录的节点号和名字".."。
de++;
de->inode = dir->i_num;
strcpy (de->name, "..");
inode->i_nlinks = 2;
// 然后设置该高速缓冲区已修改标志,并释放该缓冲区。
dir_block->b_dirt = 1;
brelse (dir_block);
// 初始化设置新i 节点的模式字段,并置该i 节点已修改标志。
inode->i_mode = I_DIRECTORY | (mode & 0777 & ~current->umask);
inode->i_dirt = 1;
// 在目录中新添加一个目录项,如果失败(包含该目录项的高速缓冲区指针为NULL),则释放目录的
// i 节点;所申请的i 节点引用连接计数复位,并释放该i 节点。返回出错码,退出。
bh = add_entry (dir, basename, namelen, &de);
if (!bh)
{
iput (dir);
free_block (inode->i_dev, inode->i_zone[0]);
inode->i_nlinks = 0;
iput (inode);
return -ENOSPC;
}
// 令该目录项的i 节点字段等于新i 节点号,置高速缓冲区已修改标志,释放目录和新的i 节点,释放
// 高速缓冲区,最后返回0(成功)。
de->inode = inode->i_num;
bh->b_dirt = 1;
dir->i_nlinks++;
dir->i_dirt = 1;
iput (dir);
iput (inode);
brelse (bh);
return 0;
}
/*
* routine to check that the specified directory is empty (for rmdir)
*/
/*
* 用于检查指定的目录是否为空的子程序(用于rmdir 系统调用函数)。
*/
检查指定目录是否是空的。
// 参数:inode - 指定目录的i 节点指针。
// 返回:0 - 是空的;1 - 不空。
static int
empty_dir (struct m_inode *inode)
{
int nr, block;
int len;
struct buffer_head *bh;
struct dir_entry *de;
// 计算指定目录中现有目录项的个数(应该起码有2 个,即"."和".."两个文件目录项)。
len = inode->i_size / sizeof (struct dir_entry);
// 如果目录项个数少于2 个或者该目录i 节点的第1 个直接块没有指向任何磁盘块号,或者相应磁盘
// 块读不出,则显示警告信息“设备dev 上目录错”,返回0(失败)。
if (len 2 || !inode->i_zone[0] ||
!(bh = bread (inode->i_dev, inode->i_zone[0])))
{
printk ("warning - bad directory on dev %04x\n", inode->i_dev);
return 0;
}
// 让de 指向含有读出磁盘块数据的高速缓冲区中第1 项目录项。
de = (struct dir_entry *) bh->b_data;
// 如果第1 个目录项的i 节点号字段值不等于该目录的i 节点号,或者第2 个目录项的i 节点号字段
// 为零,或者两个目录项的名字字段不分别等于"."和"..",则显示出错警告信息“设备dev 上目录错”
// 并返回0。
if (de[0].inode != inode->i_num || !de[1].inode ||
strcmp (".", de[0].name) || strcmp ("..", de[1].name))
{
printk ("warning - bad directory on dev %04x\n", inode->i_dev);
return 0;
}
// 令nr 等于目录项序号;de 指向第三个目录项。
nr = 2;
de += 2;
// 循环检测该目录中所有的目录项(len-2 个),看有没有目录项的i 节点号字段不为0(被使用)。
while (nr len)
{
// 如果该块磁盘块中的目录项已经检测完,则释放该磁盘块的高速缓冲区,读取下一块含有目录项的
// 磁盘块。若相应块没有使用(或已经不用,如文件已经删除等),则继续读下一块,若读不出,则出
// 错,返回0。否则让de 指向读出块的首个目录项。
if ((void *) de >= (void *) (bh->b_data + BLOCK_SIZE))
{
brelse (bh);
block = bmap (inode, nr / DIR_ENTRIES_PER_BLOCK);
if (!block)
{
nr += DIR_ENTRIES_PER_BLOCK;
continue;
}
if (!(bh = bread (inode->i_dev, block)))
return 0;
de = (struct dir_entry *) bh->b_data;
}
// 如果该目录项的i 节点号字段不等于0,则表示该目录项目前正被使用,则释放该高速缓冲区,
// 返回0,退出。
if (de->inode)
{
brelse (bh);
return 0;
}
// 否则,若还没有查询完该目录中的所有目录项,则继续检测。
de++;
nr++;
}
// 到这里说明该目录中没有找到已用的目录项(当然除了头两个以外),则返回缓冲区,返回1。
brelse (bh);
return 1;
}
系统调用函数 - 删除指定名称的目录。
// 参数: name - 目录名(路径名)。
// 返回:返回0 表示成功,否则返回出错号。
int
sys_rmdir (const char *name)
{
const char *basename;
int namelen;
struct m_inode *dir, *inode;
struct buffer_head *bh;
struct dir_entry *de;
// 如果不是超级用户,则返回访问许可出错码。
if (!suser ())
return -EPERM;
// 如果找不到对应路径名目录的i 节点,则返回出错码。
if (!(dir = dir_namei (name, &namelen, &basename)))
return -ENOENT;
// 如果最顶端的文件名长度为0,则说明给出的路径名最后没有指定文件名,释放该目录i 节点,返回
// 出错码,退出。
if (!namelen)
{
iput (dir);
return -ENOENT;
}
// 如果在该目录中没有写的权限,则释放该目录的i 节点,返回访问许可出错码,退出。
if (!permission (dir, MAY_WRITE))
{
iput (dir);
return -EPERM;
}
// 如果对应路径名上最后的文件名的目录项不存在,则释放包含该目录项的高速缓冲区,释放目录
// 的i 节点,返回文件已经存在出错码,退出。否则dir 是包含要被删除目录名的目录i 节点,de
// 是要被删除目录的目录项结构。
bh = find_entry (&dir, basename, namelen, &de);
if (!bh)
{
iput (dir);
return -ENOENT;
}
// 取该目录项指明的i 节点。若出错则释放目录的i 节点,并释放含有目录项的高速缓冲区,返回
// 出错号。
if (!(inode = iget (dir->i_dev, de->inode)))
{
iput (dir);
brelse (bh);
return -EPERM;
}
// 若该目录设置了受限删除标志并且进程的有效用户id 不等于该i 节点的用户id,则表示没有权限删
// 除该目录,于是释放包含要删除目录名的目录i 节点和该要删除目录的i 节点,释放高速缓冲区,返
// 回出错码。
if ((dir->i_mode & S_ISVTX) && current->euid &&
inode->i_uid != current->euid)
{
iput (dir);
iput (inode);
brelse (bh);
return -EPERM;
}
// 如果要被删除的目录项的i 节点的设备号不等于包含该目录项的目录的设备号,或者该被删除目录的
// 引用连接计数大于1(表示有符号连接等),则不能删除该目录,于是释放包含要删除目录名的目录
// i 节点和该要删除目录的i 节点,释放高速缓冲区,返回出错码。
if (inode->i_dev != dir->i_dev || inode->i_count > 1)
{
iput (dir);
iput (inode);
brelse (bh);
return -EPERM;
}
// 如果要被删除目录的目录项i 节点的节点号等于包含该需删除目录的i 节点号,则表示试图删除"."
// 目录。于是释放包含要删除目录名的目录i 节点和该要删除目录的i 节点,释放高速缓冲区,返回
// 出错码。
if (inode == dir)
{ /* we may not delete ".", but "../dir" is ok */
iput (inode); /* 我们不可以删除".",但可以删除"../dir" */
iput (dir);
brelse (bh);
return -EPERM;
}
// 若要被删除的目录的i 节点的属性表明这不是一个目录,则释放包含要删除目录名的目录i 节点和
// 该要删除目录的i 节点,释放高速缓冲区,返回出错码。
if (!S_ISDIR (inode->i_mode))
{
iput (inode);
iput (dir);
brelse (bh);
return -ENOTDIR;
}
// 若该需被删除的目录不空,则释放包含要删除目录名的目录i 节点和该要删除目录的i 节点,释放
// 高速缓冲区,返回出错码。
if (!empty_dir (inode))
{
iput (inode);
iput (dir);
brelse (bh);
return -ENOTEMPTY;
}
// 若该需被删除目录的i 节点的连接数不等于2,则显示警告信息。
if (inode->i_nlinks != 2)
printk ("empty directory has nlink!=2 (%d)", inode->i_nlinks);
// 置该需被删除目录的目录项的i 节点号字段为0,表示该目录项不再使用,并置含有该目录项的高速
// 缓冲区已修改标志,并释放该缓冲区。
de->inode = 0;
bh->b_dirt = 1;
brelse (bh);
// 置被删除目录的i 节点的连接数为0,并置i 节点已修改标志。
inode->i_nlinks = 0;
inode->i_dirt = 1;
// 将包含被删除目录名的目录的i 节点引用计数减1,修改其改变时间和修改时间为当前时间,并置
// 该节点已修改标志。
dir->i_nlinks--;
dir->i_ctime = dir->i_mtime = CURRENT_TIME;
dir->i_dirt = 1;
// 最后释放包含要删除目录名的目录i 节点和该要删除目录的i 节点,返回0(成功)。
iput (dir);
iput (inode);
return 0;
}
系统调用函数 - 删除文件名以及可能也删除其相关的文件。
// 从文件系统删除一个名字。如果是一个文件的最后一个连接,并且没有进程正打开该文件,则该文件
// 也将被删除,并释放所占用的设备空间。
// 参数:name - 文件名。
// 返回:成功则返回0,否则返回出错号。
int
sys_unlink (const char *name)
{
const char *basename;
int namelen;
struct m_inode *dir, *inode;
struct buffer_head *bh;
struct dir_entry *de;
// 如果找不到对应路径名目录的i 节点,则返回出错码。
if (!(dir = dir_namei (name, &namelen, &basename)))
return -ENOENT;
// 如果最顶端的文件名长度为0,则说明给出的路径名最后没有指定文件名,释放该目录i 节点,返回
// 出错码,退出。
if (!namelen)
{
iput (dir);
return -ENOENT;
}
// 如果在该目录中没有写的权限,则释放该目录的i 节点,返回访问许可出错码,退出。
if (!permission (dir, MAY_WRITE))
{
iput (dir);
return -EPERM;
}
// 如果对应路径名上最后的文件名的目录项不存在,则释放包含该目录项的高速缓冲区,释放目录
// 的i 节点,返回文件已经存在出错码,退出。否则dir 是包含要被删除目录名的目录i 节点,de
// 是要被删除目录的目录项结构。
bh = find_entry (&dir, basename, namelen, &de);
if (!bh)
{
iput (dir);
return -ENOENT;
}
// 取该目录项指明的i 节点。若出错则释放目录的i 节点,并释放含有目录项的高速缓冲区,返回
// 出错号。
if (!(inode = iget (dir->i_dev, de->inode)))
{
iput (dir);
brelse (bh);
return -ENOENT;
}
// 如果该目录设置了受限删除标志并且用户不是超级用户,并且进程的有效用户id 不等于被删除文件
// 名i 节点的用户id,并且进程的有效用户id 也不等于目录i 节点的用户id,则没有权限删除该文件
// 名。则释放该目录i 节点和该文件名目录项的i 节点,释放包含该目录项的缓冲区,返回出错号。
if ((dir->i_mode & S_ISVTX) && !suser () &&
current->euid != inode->i_uid && current->euid != dir->i_uid)
{
iput (dir);
iput (inode);
brelse (bh);
return -EPERM;
}
// 如果该指定文件名是一个目录,则也不能删除,释放该目录i 节点和该文件名目录项的i 节点,释放
// 包含该目录项的缓冲区,返回出错号。
if (S_ISDIR (inode->i_mode))
{
iput (inode);
iput (dir);
brelse (bh);
return -EPERM;
}
// 如果该i 节点的连接数已经为0,则显示警告信息,修正其为1。
if (!inode->i_nlinks)
{
printk ("Deleting nonexistent file (%04x:%d), %d\n",
inode->i_dev, inode->i_num, inode->i_nlinks);
inode->i_nlinks = 1;
}
// 将该文件名的目录项中的i 节点号字段置为0,表示释放该目录项,并设置包含该目录项的缓冲区
// 已修改标志,释放该高速缓冲区。
de->inode = 0;
bh->b_dirt = 1;
brelse (bh);
// 该i 节点的连接数减1,置已修改标志,更新改变时间为当前时间。最后释放该i 节点和目录的i 节
// 点,返回0(成功)。
inode->i_nlinks--;
inode->i_dirt = 1;
inode->i_ctime = CURRENT_TIME;
iput (inode);
iput (dir);
return 0;
}
系统调用函数 - 为文件建立一个文件名。
// 为一个已经存在的文件创建一个新连接(也称为硬连接 - hard link)。
// 参数:oldname - 原路径名;newname - 新的路径名。
// 返回:若成功则返回0,否则返回出错号。
int
sys_link (const char *oldname, const char *newname)
{
struct dir_entry *de;
struct m_inode *oldinode, *dir;
struct buffer_head *bh;
const char *basename;
int namelen;
// 取原文件路径名对应的i 节点oldinode。如果为0,则表示出错,返回出错号。
oldinode = namei (oldname);
if (!oldinode)
return -ENOENT;
// 如果原路径名对应的是一个目录名,则释放该i 节点,返回出错号。
if (S_ISDIR (oldinode->i_mode))
{
iput (oldinode);
return -EPERM;
}
// 查找新路径名的最顶层目录的i 节点,并返回最后的文件名及其长度。如果目录的i 节点没有找到,
// 则释放原路径名的i 节点,返回出错号。
dir = dir_namei (newname, &namelen, &basename);
if (!dir)
{
iput (oldinode);
return -EACCES;
}
// 如果新路径名中不包括文件名,则释放原路径名i 节点和新路径名目录的i 节点,返回出错号。
if (!namelen)
{
iput (oldinode);
iput (dir);
return -EPERM;
}
// 如果新路径名目录的设备号与原路径名的设备号不一样,则也不能建立连接,于是释放新路径名
// 目录的i 节点和原路径名的i 节点,返回出错号。
if (dir->i_dev != oldinode->i_dev)
{
iput (dir);
iput (oldinode);
return -EXDEV;
}
// 如果用户没有在新目录中写的权限,则也不能建立连接,于是释放新路径名目录的i 节点和原路径名
// 的i 节点,返回出错号。
if (!permission (dir, MAY_WRITE))
{
iput (dir);
iput (oldinode);
return -EACCES;
}
// 查询该新路径名是否已经存在,如果存在,则也不能建立连接,于是释放包含该已存在目录项的高速
// 缓冲区,释放新路径名目录的i 节点和原路径名的i 节点,返回出错号。
bh = find_entry (&dir, basename, namelen, &de);
if (bh)
{
brelse (bh);
iput (dir);
iput (oldinode);
return -EEXIST;
}
// 在新目录中添加一个目录项。若失败则释放该目录的i 节点和原路径名的i 节点,返回出错号。
bh = add_entry (dir, basename, namelen, &de);
if (!bh)
{
iput (dir);
iput (oldinode);
return -ENOSPC;
}
// 否则初始设置该目录项的i 节点号等于原路径名的i 节点号,并置包含该新添目录项的高速缓冲区
// 已修改标志,释放该缓冲区,释放目录的i 节点。
de->inode = oldinode->i_num;
bh->b_dirt = 1;
brelse (bh);
iput (dir);
// 将原节点的应用计数加1,修改其改变时间为当前时间,并设置i 节点已修改标志,最后释放原
// 路径名的i 节点,并返回0(成功)。
oldinode->i_nlinks++;
oldinode->i_ctime = CURRENT_TIME;
oldinode->i_dirt = 1;
iput (oldinode);
return 0;
}
linux 0.11 namei.c 注释
最新推荐文章于 2024-06-21 13:50:47 发布