2022-2023-1 20222823 《Linux内核原理与分析》 第七周作业

一、操作系统内核三大功能分别是进程管理，内存管理，文件系统。
其中最核心的是进程管理，而pid是系统区别进程的编号。

二、do_fork函数的参数：

clone_flags：子进程创建相关标志，通过此标志可以对父进程的资源进行有选择的复制

stack_start：子进程用户态堆栈的地址

regs：指向pt_regs结构体的指针

stack_size：用户态栈的大小，通常是不必要的，总被设置为0

parent_tidptr和child_tidptr：父进程子进程用户态下的pid地址

三、实验

（一）首先清空原来的menu文件夹，克隆一个新的menu

然后将test_fork.c文件改为test.c用以测试，再make一下，保证更新过

正常运行，输入help命令，可以使用fork

ls
cd ~/LinuxKernel
rm menu 
-rf git clone https://github.com/mengning/menu.git 
cd menu
mv test_fork.c test.c 
make rootfs

 

 (二) 再打开一个新的命令行，输入qemu -kernel linux-3.18.6/arch/x86/boot/bzImage -initrd rootfs.img -S -s让MenuOs停下方便调试

 （三）再打开一个终端，进入gdb

 （四）设置六个断点

 （五）最后用c进行调试

四、实验分析

fork函数通过ox80中断（系统调用）来陷入内核，然后进入系统提供的相应系统调用来完成进程的创建过程

fork、vfork、和clone三个系统调用都可以创建一个新的进程，而且都是通过do_fork来实现进程的创建。

在do_fork中首先调用copy_process为子进程复制一份进程信息。

调用dup_task_struct复制当前的task_struct。

（一）do_fork

long do_fork(unsigned long clone_flags,
	      unsigned long stack_start,
	      unsigned long stack_size,
	      int __user *parent_tidptr,
	      int __user *child_tidptr)
{
	struct task_struct *p; //进程描述符结构体指针
	int trace = 0;
	long nr; //总的pid数量
 
	/*
	 * Determine whether and which event to report to ptracer.  When
	 * called from kernel_thread or CLONE_UNTRACED is explicitly
	 * requested, no event is reported; otherwise, report if the event
	 * for the type of forking is enabled.
	 */
	if (!(clone_flags & CLONE_UNTRACED)) {
		if (clone_flags & CLONE_VFORK)
			trace = PTRACE_EVENT_VFORK;
		else if ((clone_flags & CSIGNAL) != SIGCHLD)
			trace = PTRACE_EVENT_CLONE;
		else
			trace = PTRACE_EVENT_FORK;
 
		if (likely(!ptrace_event_enabled(current, trace)))
			trace = 0;
	}
 
	// 复制进程描述符，返回创建的task_struct的指针
	p = copy_process(clone_flags, stack_start, stack_size,
			 child_tidptr, NULL, trace);
	/*
	 * Do this prior waking up the new thread - the thread pointer
	 * might get invalid after that point, if the thread exits quickly.
	 */
	if (!IS_ERR(p)) {
		struct completion vfork;
		struct pid *pid;
 
		trace_sched_process_fork(current, p);
 
		// 取出task结构体内的pid
		pid = get_task_pid(p, PIDTYPE_PID);
		nr = pid_vnr(pid);
 
		if (clone_flags & CLONE_PARENT_SETTID)
			put_user(nr, parent_tidptr);
 
		// 如果使用的是vfork，那么必须采用某种完成机制，确保父进程后运行
		if (clone_flags & CLONE_VFORK) {
			p->vfork_done = &vfork;
			init_completion(&vfork);
			get_task_struct(p);
		}
 
		// 将子进程添加到调度器的队列，使得子进程有机会获得CPU
		wake_up_new_task(p);
 
		/* forking complete and child started to run, tell ptracer */
		if (unlikely(trace))
			ptrace_event_pid(trace, pid);
 
		// 如果设置了 CLONE_VFORK 则将父进程插入等待队列，并挂起父进程直到子进程释放自己的内存空间
		// 保证子进程优先于父进程运行
		if (clone_flags & CLONE_VFORK) {
			if (!wait_for_vfork_done(p, &vfork))
				ptrace_event_pid(PTRACE_EVENT_VFORK_DONE, pid);
		}
 
		put_pid(pid);
	} else {
		nr = PTR_ERR(p);
	}
	return nr;
}

(二) dum_task_struct

static struct task_struct *dup_task_struct(struct task_struct *orig)
{
	struct task_struct *tsk;
	struct thread_info *ti;
	int node = tsk_fork_get_node(orig);
	int err;

	// 分配一个task_struct结点
	tsk = alloc_task_struct_node(node);
	if (!tsk)
		return NULL;

	// 分配一个thread_info结点，其实内部分配了一个union，包含进程的内核栈
	// 此时ti的值为栈底，在x86下为union的高地址处。
	ti = alloc_thread_info_node(tsk, node);
	if (!ti)
		goto free_tsk;

	err = arch_dup_task_struct(tsk, orig);
	if (err)
		goto free_ti;

	// 将栈底的值赋给新结点的stack
	tsk->stack = ti; 
    ...
	/*
	 * One for us, one for whoever does the "release_task()" (usually
	 * parent)
	 */
	// 将进程描述符的使用计数器置为2
	atomic_set(&tsk->usage, 2);
#ifdef CONFIG_BLK_DEV_IO_TRACE
	tsk->btrace_seq = 0;
#endif
	tsk->splice_pipe = NULL;
	tsk->task_frag.page = NULL;

	account_kernel_stack(ti, 1);

	// 返回新申请的结点
	return tsk;

free_ti:
	free_thread_info(ti);
free_tsk:
	free_task_struct(tsk);
	return NULL;
}

(三) copy_thread

// 初始化子进程的内核栈
int copy_thread(unsigned long clone_flags, unsigned long sp,
	unsigned long arg, struct task_struct *p)
{

	// 取出子进程的寄存器信息
	struct pt_regs *childregs = task_pt_regs(p);
	struct task_struct *tsk;
	int err;

	// 栈顶 空栈
	p->thread.sp = (unsigned long) childregs;
	p->thread.sp0 = (unsigned long) (childregs+1);
	memset(p->thread.ptrace_bps, 0, sizeof(p->thread.ptrace_bps));

	// 如果是创建的内核线程
	if (unlikely(p->flags & PF_KTHREAD)) {
		/* kernel thread */
		memset(childregs, 0, sizeof(struct pt_regs));
		// 内核线程开始执行的位置
		p->thread.ip = (unsigned long) ret_from_kernel_thread;
		task_user_gs(p) = __KERNEL_STACK_CANARY;
		childregs->ds = __USER_DS;
		childregs->es = __USER_DS;
		childregs->fs = __KERNEL_PERCPU;
		childregs->bx = sp;	/* function */
		childregs->bp = arg;
		childregs->orig_ax = -1;
		childregs->cs = __KERNEL_CS | get_kernel_rpl();
		childregs->flags = X86_EFLAGS_IF | X86_EFLAGS_FIXED;
		p->thread.io_bitmap_ptr = NULL;
		return 0;
	}

	// 将当前进程的寄存器信息复制给子进程
	*childregs = *current_pt_regs();
	// 子进程的eax置为0，所以fork的子进程返回值为0
	childregs->ax = 0;
	if (sp)
		childregs->sp = sp;

	// 子进程从ret_from_fork开始执行
	p->thread.ip = (unsigned long) ret_from_fork;
	task_user_gs(p) = get_user_gs(current_pt_regs());

	p->thread.io_bitmap_ptr = NULL;
	tsk = current;
	err = -ENOMEM;

	// 如果父进程使用IO权限位图，那么子进程获得该位图的一个拷贝
	if (unlikely(test_tsk_thread_flag(tsk, TIF_IO_BITMAP))) {
		p->thread.io_bitmap_ptr = kmemdup(tsk->thread.io_bitmap_ptr,
						IO_BITMAP_BYTES, GFP_KERNEL);
		if (!p->thread.io_bitmap_ptr) {
			p->thread.io_bitmap_max = 0;
			return -ENOMEM;
		}
		set_tsk_thread_flag(p, TIF_IO_BITMAP);
	}
	...
	return err;
}

六、问题与解决方法

一开始menu不能正常make，后来发现发现自己的路径和实验楼上的有差别

解决方法是进入menu中的makefile文件中修改路径，修改成自己的路径