Linux 内核学习笔记：进程 2 的创建及执行（第 1 部分） —— 打开设备文件

前边的 4 篇博文将进程 1 的创建以及执行阐述完毕，接下来几篇博文开始阐述进程 2 的创建及执行。

几个容易混淆的变量

在上篇博文中就碰到了这几个变量： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// fs/super.c ----------------------------------
// super_block 存储的是某一逻辑设备上文件系统的核心信息
struct super_block super_block[NR_SUPER];	// NR_SUPER = 8

// fs/inode.c ----------------------------------
// inode_table 是操作系统用来控制同时打开不同文件的最大数
struct m_inode inode_table[NR_INODE]={{0,},};	// NR_INODE = 32

// fs/file_table.c -----------------------------
struct file file_table[NR_FILE];	// NR_FILE = 64

// include/linux/sched.h -----------------------
struct task_struct {
	......
	struct file * filp[NR_OPEN];	// NR_OPEN = 20
	......
};

这四者的关系可用图表示如下：

打开标准输入设备文件

对于 Linux 而言，一切皆文件，打开设备文件跟打开一般文件的过程是一样的。在上一博文 Linux 内核学习笔记：进程 1 的创建及执行（第 4 部分）“文件目录项结构”部分，我们举了一个打开 /usr/bin/vi 文件的例子。打开设备文件的流程跟那个例子一样，不过那个例子比较简要，省略了好多细节，所以接下来就把这些细节都详细叙述一下。

在上一博文 Linux 内核学习笔记：进程 1 的创建及执行（第 4 部分）我们说到，进程 1 已经返回到 init 函数执行： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// init/main.c ---------------------------------
int main(void)
{
	......
	if (!fork()) {		// fork 在子进程（进程 1） 返回 0
		init();		// 在子进程（进程 1）开始执行
	}
}

void init(void)
{
	int pid,i;

	setup((void *) &drive_info);
	(void) open("/dev/tty0",O_RDWR,0);
	(void) dup(0);
	(void) dup(0);
	printf("%d buffers = %d bytes buffer space\n\r",NR_BUFFERS,
		NR_BUFFERS*BLOCK_SIZE);
	......
}

调用 sys_open

open 函数定义如下： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// lib/open.c ----------------------------------
// 若成功，返回文件句柄（即文件描述符）；否则返回 -1
int open(const char * filename, int flag, ...)
{
	register int res;
	va_list arg;

	va_start(arg,flag);
	__asm__("int $0x80"
		:"=a" (res)
		:"0" (__NR_open),"b" (filename),"c" (flag),
		"d" (va_arg(arg,int)));
	if (res>=0)
		return res;
	errno = -res;
	return -1;
}

上述代码表明，open 函数实际还是通过 int 0x80 软中断调用系统调用总入口 _system_call，再经 call _sys_call_table(,%eax,4) 调用具体的服务程序 sys_open： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
// fs/open.c -----------------------------------
int sys_open(const char * filename,int flag,int mode)
{
	struct m_inode * inode;
	struct file * f;
	int i,fd;

	mode &= 0777 & ~current->umask;

	// 在进程 1 的 filp[20] 查找一个可用空闲项
	for(fd=0 ; fd<NR_OPEN ; fd++)
		if (!current->filp[fd])
			break;
	if (fd>=NR_OPEN)
		return -EINVAL;
	current->close_on_exec &= ~(1<<fd);

	// 在内核的 file_table[64] 查找一个可用的空闲项
	f=0+file_table;
	for (i=0 ; i<NR_FILE ; i++,f++)
		if (!f->f_count) break;
	if (i>=NR_FILE)
		return -EINVAL;
	// 将进程 1 的 filp[20] 和内核的 file_table[64] 相挂接，并增加引用计数
	(current->filp[fd]=f)->f_count++;

	// 获取文件 i 节点
	if ((i=open_namei(filename,flag,mode,&inode))<0) {
		current->filp[fd]=NULL;
		f->f_count=0;
		return i;
	}
	......
}

调用 open_namei

通过 open_namei 函数，能够最终获得标准输入设备 tty0 的 i 节点。open_namei 函数定义如下： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// fs/namei.c ----------------------------------
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;

	if ((flag & O_TRUNC) && !(flag & O_ACCMODE))
		flag |= O_WRONLY;
	mode &= 0777 & ~current->umask;
	mode |= I_REGULAR;

	// dir_namei 函数返回参数：
	// basename -> 最终文件名指针；namelen -> 最终文件名长度；dir -> “最终文件所在目录”（注意不是文件的）的 i 节点指针
	if (!(dir = dir_namei(pathname,&namelen,&basename)))
		return -ENOENT;
	if (!namelen) {			/* special case: '/usr/' etc */
		if (!(flag & (O_ACCMODE|O_CREAT|O_TRUNC))) {
			*res_inode=dir;
			return 0;
		}
		iput(dir);
		return -EISDIR;
	}
	bh = find_entry(&dir,basename,namelen,&de);
	......
}

调用 dir_namei

dir_namei 函数定义如下： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
// fs/namei.c ----------------------------------
static struct m_inode * dir_namei(const char * pathname,
	int * namelen, const char ** name)
{
	char c;
	const char * basename;
	struct m_inode * dir;

	if (!(dir = get_dir(pathname)))
		return NULL;

	// 取出最终（设备）文件名。在这里是 tty0
	basename = pathname;
	while (c=get_fs_byte(pathname++))
		if (c=='/')
			basename=pathname;
	*namelen = pathname-basename-1;	// 最终（设备）文件名长度
	*name = basename;		// 最终（设备）文件名。name 是个二级指针
	return dir;			// 最终（设备）文件名 i 节点
}

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;

	if (!current->root || !current->root->i_count)
		panic("No root inode");
	if (!current->pwd || !current->pwd->i_count)
		panic("No pwd inode");
	if ((c=get_fs_byte(pathname))=='/') {	// 这里识别出 /dev/tty0 的第一个字符'/'
		inode = current->root;		// 在根目录
		pathname++;			// 指针指向下一个字符
	} else if (c)	// 在当前目录
		inode = current->pwd;
	else	// 非法，返回
		return NULL;	/* empty name is bad */
	inode->i_count++;	// i 节点引用计数加 1

	// 下边的循环是将整个路径（绝对或相对）解析，找到最终设备文件 tty0 的 i 节点
	while (1) {
		thisname = pathname;
		if (!S_ISDIR(inode->i_mode) || !permission(inode,MAY_EXEC)) {
			iput(inode);
			return NULL;
		}

		// 从路径名开始起遍历字符串，直到字符已是结尾符 '\0' 或者是 '/'
		for(namelen=0;(c=get_fs_byte(pathname++))&&(c!='/');namelen++)
			/* nothing */ ;
		if (!c)	// 如果字符是结尾符 '\0'，则表明已经到达指定目录，返回“该文件所在目录”（注意不是文件的）的 i 节点指针
			return inode;

		// 查找指定目录
		if (!(bh = find_entry(&inode,thisname,namelen,&de))) {
			iput(inode);
			return NULL;
		}
		inr = de->inode;	// 将目录项中的 i 节点编号取出
		idev = inode->i_dev;
		brelse(bh);
		iput(inode);	// 释放该 i 节点（只是 inode->i_count--）。对于 inode_table[32] 而言，每次打开的文件的 i 节点
				// 信息都要存放在 inode_table[32] 中。当 inode->i_count = 0 的时候，该 i 节点所在 inode_table[32] 的
				// 位置就空出来，可以给其他文件的 i 节点使用
				// 对根目录 '/' 或者当前目录而言，在进入该循环前就已经将该 i 节点引用计数加 1（inode->i_count++）

		// 继续对该子目录的 i 节点进行操作
		// iget 函数涉及到在 inode_table 上申请空闲项，并将磁盘块中的 i 节点信息拷贝进该空闲项
		if (!(inode = iget(idev,inr)))
			return NULL;
	}
}

// include/asm/segment.h -----------------------
extern inline unsigned char get_fs_byte(const char * addr)
{
	unsigned register char _v;

	// 返回 fs:[addr] 处的一个字节
	__asm__ ("movb %%fs:%1,%0":"=r" (_v):"m" (*addr));
	return _v;
}

find_entry 函数在 get_dir 函数中被调用，其定义如下： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
// fs/namei.c ----------------------------------
/*
 *	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.
 */
static struct buffer_head * find_entry(struct m_inode ** dir,
	const char * name, int namelen, struct dir_entry ** res_dir)	// res_dir 是返回参数
{
	int entries;
	int block,i;
	struct buffer_head * bh;
	struct dir_entry * de;
	struct super_block * sb;

#ifdef NO_TRUNCATE
	if (namelen > NAME_LEN)
		return NULL;
#else
	if (namelen > NAME_LEN)
		namelen = NAME_LEN;
#endif
	entries = (*dir)->i_size / (sizeof (struct dir_entry));	// 计算目录文件中总共有多少个目录项
	*res_dir = 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;
		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 */
			sb=get_super((*dir)->i_dev);
			if (sb->s_imount) {
				iput(*dir);
				(*dir)=sb->s_imount;
				(*dir)->i_count++;
			}
		}
	}

	// 读取目录项所在的（第 1 个）逻辑块到缓冲块
	if (!(block = (*dir)->i_zone[0]))
		return NULL;
	if (!(bh = bread((*dir)->i_dev,block)))
		return NULL;

	i = 0;
	de = (struct dir_entry *) bh->b_data;
	while (i < entries) {
		if ((char *)de >= BLOCK_SIZE+bh->b_data) {
			brelse(bh);
			bh = NULL; 
			// 1. bmap：block map，根据 i 节点信息取出 i/DIR_ENTRIES_PER_BLOCK 在设备（虚拟盘）上对应的逻辑块号
			// 申请到磁盘块时，bmap 返回磁盘块号；否则返回 0
			// 2. 申请到磁盘块后，就开始将该磁盘块读入缓冲块；如果成功读入，则从该缓冲块开始遍历；否则继续申请磁盘块
			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++;
	}
	brelse(bh);
	return NULL;
}

/*
 * 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.
 */
static int match(int len,const char * name,struct dir_entry * de)
{
	register int same __asm__("ax");

	if (!de || !de->inode || len > NAME_LEN)
		return 0;
	// de->name[len]：如果目录项中文件名长度超过 len
	if (len < NAME_LEN && de->name[len])
		return 0;
	// 字符串比较
	__asm__("cld\n\t"
		"fs ; repe ; cmpsb\n\t"
		"setz %%al"
		:"=a" (same)
		:"0" (0),"S" ((long) name),"D" ((long) de->name),"c" (len)
		:"cx","di","si");
	return same;
}

返回 open_namei

dir_namei 函数执行完毕就返回 open_namei 函数： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
// fs/namei.c ----------------------------------
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;

	......
	// dir_namei 函数返回参数：
	// basename -> 最终文件名指针；namelen -> 最终文件名长度；dir -> “最终文件所在目录”（注意不是文件的）的 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;
		}
		iput(dir);
		return -EISDIR;
	}

	// 在 dir 节点对应的目录中，取文件名对应的目录项结构 de 和该目录项所在的缓冲块
	bh = find_entry(&dir,basename,namelen,&de);
	// 如果该缓冲块头指针为 NULL，表示没有找到对应文件名的目录项，因此只能是创建文件操作
	if (!bh) {
		......
	}

	// 如果该缓冲块头指针不为 NULL，取出文件名对应的目录项中的 i 节点及文件所在的设备号。
	// 并释放该缓冲块和“文件所在目录”的 i 节点
	// 注：要区别 “文件所在目录的 i 节点” 和 文件自身的 i 节点
	inr = de->inode;
	dev = dir->i_dev;
	brelse(bh);
	iput(dir);

	if (flag & O_EXCL)
		return -EEXIST;

	// iget 函数涉及到在 inode_table 上申请空闲项，并将磁盘块中的 i 节点信息拷贝进该空闲项
	if (!(inode=iget(dev,inr)))
		return -EACCES;

	if ((S_ISDIR(inode->i_mode) && (flag & O_ACCMODE)) ||
	    !permission(inode,ACC_MODE(flag))) {
		iput(inode);
		return -EPERM;
	}
	inode->i_atime = CURRENT_TIME;
	if (flag & O_TRUNC)
		truncate(inode);

	// 最后返回最终文件的 i 节点和返回 0
	*res_inode = inode;
	return 0;
}

返回 sys_open

open_namei 函数返回后，跳转到 sys_open 函数执行： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
// fs/open.c -----------------------------------
int sys_open(const char * filename,int flag,int mode)
{
	struct m_inode * inode;
	struct file * f;
	int i,fd;

	mode &= 0777 & ~current->umask;

	// 在进程 1 的 filp[20] 查找一个可用空闲项
	for(fd=0 ; fd<NR_OPEN ; fd++)
		if (!current->filp[fd])
			break;
	if (fd>=NR_OPEN)
		return -EINVAL;
	current->close_on_exec &= ~(1<<fd);

	// 在内核的 file_table[64] 查找一个可用的空闲项
	f=0+file_table;
	for (i=0 ; i<NR_FILE ; i++,f++)
		if (!f->f_count) break;
	if (i>=NR_FILE)
		return -EINVAL;
	// 将进程 1 的 filp[20] 和内核的 file_table[64] 相挂接，并增加引用计数
	(current->filp[fd]=f)->f_count++;

	// 获取文件 i 节点
	if ((i=open_namei(filename,flag,mode,&inode))<0) {
		current->filp[fd]=NULL;
		f->f_count=0;
		return i;
	}
/* ttys are somewhat special (ttyxx major==4, tty major==5) */
	if (S_ISCHR(inode->i_mode))	// 通过检测 tty0 文件的 i 节点属性，得知它是设备文件
		if (MAJOR(inode->i_zone[0])==4) {	// 得知设备号是 4
			if (current->leader && current->tty<0) {
				// 设置当前进程的 tty 号为该 i 节点的子设备号
				current->tty = MINOR(inode->i_zone[0]);
				// 设置当前进程 tty 对应的 tty 表项的父进程组号为进程的父进程组号
				tty_table[current->tty].pgrp = current->pgrp;
			}
		} else if (MAJOR(inode->i_zone[0])==5)
			if (current->tty<0) {
				iput(inode);
				current->filp[fd]=NULL;
				f->f_count=0;
				return -EPERM;
			}
/* Likewise with block-devices: check for floppy_change */
	if (S_ISBLK(inode->i_mode))
		check_disk_change(inode->i_zone[0]);
	f->f_mode = inode->i_mode;	// 用该 i 节点属性设置文件属性
	f->f_flags = flag;		// 用 flag 参数，设置文件标识
	f->f_count = 1; 		// 将文件引用计数加 1
	f->f_inode = inode;		// 文件与 i 节点建立联系
	f->f_pos = 0;			// 将文件读写指针设置为 0
	return (fd);	
}

打开标准输出、标准错误输出设备文件

打开标准输入设备文件完毕后，跳转到 init 函数继续执行，打开标准输出、标准错误输出设备文件： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
// init/main.c ---------------------------------
int main(void)
{
	......
	if (!fork()) {		// fork 在子进程（进程 1） 返回 0
		init();		// 在子进程（进程 1）开始执行
	}
}

void init(void)
{
	int pid,i;

	setup((void *) &drive_info);
	(void) open("/dev/tty0",O_RDWR,0);
	(void) dup(0);	// 复制标准输入设备文件句柄，建立“标准输出设备文件”。标准输入设备文件句柄为 0.
	(void) dup(0);	// 继续复制标准输入设备文件句柄，建立“标准错误输出设备文件”。
	printf("%d buffers = %d bytes buffer space\n\r",NR_BUFFERS,
		NR_BUFFERS*BLOCK_SIZE);
	......
}

// lib/dup.c -----------------------------------
_syscall1(int,dup,int,fd)

// include/unistd.h ----------------------------
#define _syscall1(type,name,atype,a) \
type name(atype a) \	// _syscall1(int,dup,int,fd) -> int dup(int fd)
{ \
long __res; \
__asm__ volatile ("int $0x80" \
	: "=a" (__res) \
	: "0" (__NR_##name),"b" ((long)(a))); \	// 系统调用处理程序 _system_call “call _sys_call_table(,%eax,4)”之前的 “pushl %ebx”说明了
						// ebx 将作为 sys_dup 函数的参数。在这里，也即 fd 是 sys_dup 函数传入的参数
if (__res >= 0) \
	return (type) __res; \
errno = -__res; \
return -1; \
}

跟 open 函数类似，dup 通过系统调用总入口 _system_call 调用具体的服务程序 sys_dup： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
// fs/fcntl.c ----------------------------------
int sys_dup(unsigned int fildes)
{
	return dupfd(fildes,0);
}

static int dupfd(unsigned int fd, unsigned int arg)
{
	if (fd >= NR_OPEN || !current->filp[fd])
		return -EBADF;
	if (arg >= NR_OPEN)
		return -EINVAL;

	// 在进程的 filp[20] 申请一个空闲项。标准输出设备文件申请到的是 filp[1]（即句柄为 1），
	// 标准错误输出设备文件申请到的是 filp[2]（即句柄为 2）.
	while (arg < NR_OPEN)
		if (current->filp[arg])
			arg++;
		else
			break;
	if (arg >= NR_OPEN)
		return -EMFILE;

	current->close_on_exec &= ~(1<<arg);

	// 复制文件句柄，建立标准输出设备，并相应增加文件引用计数。
	// 标准输出设备文件复制后，f_count = 2
	// 标准错误输出设备文件复制后，f_count = 3
	(current->filp[arg] = current->filp[fd])->f_count++;

	return arg;
}

注：在 Linux 中，我们经常称文件句柄为文件描述符，其大小表示进程描述符中 file[20] 的下标。

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

谢宏峰，毕业于暨南大学（2009 - 2013）、中国科学院（2013 - 2016），现就职于深信服科技，从事 OpenStack 开发。