linux内核情景分析之execve()

用来描述用户态的cpu寄存器在内核栈中保存情况.可以获取用户空间的信息
  1. struct pt_regs {
  2. long ebx;                  //可执行文件路径的指针（regs.ebx中
  3. long ecx;                  //命令行参数的指针（regs.ecx中）
  4. long edx;                  //环境变量的指针（regs.edx中）。
  5. long esi;
  6. long edi;
  7. long ebp;
  8. long eax;
  9. int xds;
  10. int xes;
  11. long orig_eax;
  12. long eip;
  13. int xcs;
  14. long eflags;
  15. long esp;
  16. int xss;
  17. };

  1. asmlinkage int sys_execve(struct pt_regs regs)
  2. {
  3. 	int error;
  4. 	char * filename;
  5. 	filename = getname((char *) regs.ebx);//ebx为"/bin/echo"，把字符串从用户空间拷贝到系统空间
  6. 	error = PTR_ERR(filename);//判断是否出错
  7. 	if (IS_ERR(filename))
  8. 		goto out;
  9.                       //文件名   参数           NULL 传入副本
  10. 	error = do_execve(filename, (char **) regs.ecx, (char **) regs.edx, &regs);//ecx为args，edx为NULL
  11. 	if (error == 0)
  12. 		current->ptrace &= ~PT_DTRACE;
  13. 	putname(filename);//将之前为文件名分配的空间释放掉
  14. out:
  15. 	return error;
  16. }

linux内核每种被注册的可执行程序格式都用linux_bin_fmt来存储,其中记录了可执行程序的加载和执行函数,同时我们需要一种方法来保存可执行程序的信息, 比如可执行文件的路径, 运行的参数和环境变量等信息，即linux_bin_prm结构
  1. /*
  2. * This structure is used to hold the arguments that are used when loading binaries.
  3. */
  4. struct linux_binprm {
  5.     char buf[BINPRM_BUF_SIZE];  // 保存可执行文件的头128字节
  6. #ifdef CONFIG_MMU
  7.     struct vm_area_struct *vma;
  8.     unsigned long vma_pages;
  9. #else
  10. # define MAX_ARG_PAGES  32
  11.     struct page *page[MAX_ARG_PAGES];
  12. #endif
  13.     struct mm_struct *mm;
  14.     unsigned long p; /* current top of mem , 当前内存页最高地址*/
  15.     unsigned int
  16.             cred_prepared:1,/* true if creds already prepared (multiple
  17.                              * preps happen for interpreters) */
  18.             cap_effective:1;/* true if has elevated effective capabilities,
  19.                              * false if not; except for init which inherits
  20.                              * its parent's caps anyway */
  21. #ifdef __alpha__
  22.     unsigned int taso:1;
  23. #endif
  24.     unsigned int recursion_depth; /* only for search_binary_handler() */
  25.     struct file * file;         /*  要执行的文件  */
  26.     struct cred *cred;      /* new credentials */
  27.     int unsafe;             /* how unsafe this exec is (mask of LSM_UNSAFE_*) */
  28.     unsigned int per_clear; /* bits to clear in current->personality */
  29.     int argc, envc;     /*  命令行参数和环境变量数目  */
  30.     const char * filename;  /* Name of binary as seen by procps, 要执行的文件的名称  */
  31.     const char * interp;    /* Name of the binary really executed. Most
  32.                                of the time same as filename, but could be
  33.                                different for binfmt_{misc,script} 要执行的文件的真实名称，通常和filename相同  */
  34.     unsigned interp_flags;
  35.     unsigned interp_data;
  36.     unsigned long loader, exec;
  37. };

  2. int do_execve(char * filename, char ** argv, char ** envp, struct pt_regs * regs)
  3. {
  4. 	struct linux_binprm bprm;//存储可执行文件信息
  5. 	struct file *file;
  6. 	int retval;
  7. 	int i;
  9. 	file = open_exec(filename);//打开目标文件 /bin/echo
  11. 	retval = PTR_ERR(file);
  12. 	if (IS_ERR(file))
  13. 		return retval;
  15. 	bprm.p = PAGE_SIZE*MAX_ARG_PAGES-sizeof(void *);//1024*32减去一个指针的大小,当前页最高地址
  16. 	memset(bprm.page, 0, MAX_ARG_PAGES*sizeof(bprm.page[0])); //page指针数组初始化为0
  18. 	bprm.file = file;
  19. 	bprm.filename = filename;
  20. 	bprm.sh_bang = 0;//可执行文件属性.0表示二进制
  21. 	bprm.loader = 0;
  22. 	bprm.exec = 0;//参数的起始地址(从上往下方向)
  23. 	if ((bprm.argc = count(argv, bprm.p / sizeof(void *))) < 0) {//对指针数组argv[]中参数的个数进行计数，而bprm.p / sizeof(void *)表示允许的最大值，由于agrv[]是在用户空间而不在系统空间
  24. 		allow_write_access(file);//防止其他进程在读入可执行文件期间通过内存映射改变它的内容
  25. 		fput(file);
  26. 		return bprm.argc;
  27. 	 }
  29.    	if ((bprm.envc = count(envp, bprm.p / sizeof(void *))) < 0) {//同上环境变量
  30. 		allow_write_access(file);
  31. 		fput(file);
  32. 		return bprm.envc;
  33. 	}
  35. 	retval = prepare_binprm(&bprm);//见下面的代码,为bprm结构做准备,读取128个字节到缓冲区
  36. 	if (retval < 0) 
  37. 		goto out; 
  39.    	retval = copy_strings_kernel(1, &bprm.filename, &bprm);//由于bprm.filename已经在系统空间了，所以copy_strings_kernel从系统空间中拷贝
  40. 	if (retval < 0) 
  41. 		goto out; 
  43. 	bprm.exec = bprm.p;//参数的起始地址
  44. 	retval = copy_strings(bprm.envc, envp, &bprm);//从用户空间拷贝，参考copy_strings_kernel
  45. 	if (retval < 0) 
  46. 		goto out; 
  48. 	retval = copy_strings(bprm.argc, argv, &bprm);//从用户空间拷贝，参考copy_strings_kernel
  49. 	if (retval < 0) 
  50. 		goto out; 
  52. 	retval = search_binary_handler(&bprm,regs);//已经从可执行文件头部读入了128个字节存放在bprm的缓冲区，而且运行所需的参数和环境变量也已经搜集在bprm中，现在就由formats队列中的成员逐个来认领，谁要识别到它代表的可执行文件格式，运行的时候就交给它
  53. 	if (retval >= 0)
  54. 		/* execve success */
  55. 		return retval;
  57. out:
  58. 	/*出错,返回inode和释放argv的页 Something went wrong, return the inode and free the argument pages*/
  59. 	allow_write_access(bprm.file);
  60. 	if (bprm.file)
  61. 		fput(bprm.file);//释放文件对象
  63. 	for (i = 0 ; i < MAX_ARG_PAGES ; i++) {
  64. 		struct page * page = bprm.page[i];
  65. 		if (page)
  66. 			__free_page(page);
  67. 	}
  69. 	return retval;
  70. }
分析prepare_binprm
  2. int prepare_binprm(struct linux_binprm *bprm)
  3. {
  4. 	int mode;
  5. 	struct inode * inode = bprm->file->f_dentry->d_inode;//获取打开的文件节点
  7. 	mode = inode->i_mode;//类型
  8. 	/* Huh? We had already checked for MAY_EXEC, WTF do we check this? */
  9. 	if (!(mode & 0111))	/* with at least _one_ execute bit set最少可执行状态 */
  10. 		return -EACCES;
  11. 	if (bprm->file->f_op == NULL)//针对文件操作不允许为空
  12. 		return -EACCES;
  14. 	bprm->e_uid = current->euid;//继承uid
  15. 	bprm->e_gid = current->egid;//继承gid
  17. 	if(!IS_NOSUID(inode)) {//是否是SUID
  18. 		/* Set-uid? */
  19. 		if (mode & S_ISUID)//如果有SUID.那就设置
  20. 			bprm->e_uid = inode->i_uid;
  22. 		/* Set-gid? */
  23. 		/*
  24. 		 * If setgid is set but no group execute bit then this
  25. 		 * is a candidate for mandatory locking, not a setgid
  26. 		 * executable.
  27. 		 */
  28. 		if ((mode & (S_ISGID | S_IXGRP)) == (S_ISGID | S_IXGRP))
  29. 			bprm->e_gid = inode->i_gid;
  30. 	}
  32. 	/* We don't have VFS support for capabilities yet */
  33. 	cap_clear(bprm->cap_inheritable);
  34. 	cap_clear(bprm->cap_permitted);
  35. 	cap_clear(bprm->cap_effective);
  37. 	/*  To support inheritance of root-permissions and suid-root
  38.          *  executables under compatibility mode, we raise all three
  39.          *  capability sets for the file.
  40.          *
  41.          *  If only the real uid is 0, we only raise the inheritable
  42.          *  and permitted sets of the executable file.
  43.          */
  45. 	if (!issecure(SECURE_NOROOT)) {
  46. 		if (bprm->e_uid == 0 || current->uid == 0) {
  47. 			cap_set_full(bprm->cap_inheritable);
  48. 			cap_set_full(bprm->cap_permitted);
  49. 		}
  50. 		if (bprm->e_uid == 0) 
  51. 			cap_set_full(bprm->cap_effective);
  52. 	}
  54. 	memset(bprm->buf,0,BINPRM_BUF_SIZE);//从可执行文件中读入开头的128个字节到linux_binprm结构bprm中的缓冲区
  55. 	return kernel_read(bprm->file,0,bprm->buf,BINPRM_BUF_SIZE);
  56. }
inux内核对所支持的每种可执行的程序类型都有个struct linux_binfmt的数据结构，定义如下 
search_binary_handler，已经从可执行文件头部读入了128个字节存放在bprm的缓冲区，而且运行所需的参数和环境变量也已经搜集在bprm中，现在就由formats队列中的成员逐个来认领，谁要识别到它代表的可执行文件格式，运行的时候就交给它，代码如下
  1. struct linux_binfmt {
  2.     struct list_head lh;
  3.     struct module *module;
  4.     int (*load_binary)(struct linux_binprm *);//通过读存放在可执行文件中的信息为当前进程建立一个新的执行环境
  5.     int (*load_shlib)(struct file *);//用于动态的把一个共享库捆绑到一个已经在运行的进程, 这是由uselib()系统调用激活的
  6.     int (*core_dump)(struct coredump_params *cprm);//在名为core的文件中, 存放当前进程的执行上下文. 这个文件通常是在进程接收到一个缺省操作为”dump”的信号时被创建的, 其格式取决于被执行程序的可执行类型
  7.     unsigned long min_coredump;     /* minimal dump size */
  8.  };


  2. int search_binary_handler(struct linux_binprm *bprm,struct pt_regs *regs)
  3. {
  4. 	int try,retval=0;
  5. 	struct linux_binfmt *fmt;
  6.         ......
  7. //一共2层循环,外出循环式为了安装了模块后再试一次
  8. 	for (try=0; try<2; try++) {
  9. 		read_lock(&binfmt_lock);
  10. //所有的linux_binfmt对象都处于一个链表中, 第一个元素的地址存放在formats变量中
  11. 		for (fmt = formats ; fmt ; fmt = fmt->next) {
  12. 			int (*fn)(struct linux_binprm *, struct pt_regs *) = fmt->load_binary;
  13. 			if (!fn)//是否是可执行文件
  14. 				continue;
  15. 			if (!try_inc_mod_count(fmt->module))//是否是动态安装库
  16. 				continue;
  17. 			read_unlock(&binfmt_lock);
  18. 			retval = fn(bprm, regs);//加载,如果谁都不认识,返回-ENOEXEC表示对不上号
  19. 			if (retval >= 0) {
  20. 				put_binfmt(fmt);
  21. 				allow_write_access(bprm->file);
  22. 				if (bprm->file)
  23. 					fput(bprm->file);
  24. 				bprm->file = NULL;
  25. 				current->did_exec = 1;
  26. 				return retval;
  27. 			}
  28. 			read_lock(&binfmt_lock);
  29. 			put_binfmt(fmt);
  30. 			if (retval != -ENOEXEC)//只要不是对不上号，就退出循环
  31. 				break;
  32. 			if (!bprm->file) {
  33. 				read_unlock(&binfmt_lock);
  34. 				return retval;
  35. 			}
  36. 		}
  37. 		read_unlock(&binfmt_lock);
  38. 		if (retval != -ENOEXEC) {
  39. 			break;
  40. #ifdef CONFIG_KMOD
  41. 		}else{
  42. #define printable(c) (((c)=='\t') || ((c)=='\n') || (0x20<=(c) && (c)<=0x7e))
  43. 			char modname[20];
  44. 			if (printable(bprm->buf[0]) &&
  45. 			    printable(bprm->buf[1]) &&
  46. 			    printable(bprm->buf[2]) &&
  47. 			    printable(bprm->buf[3]))
  48. 				break; /* -ENOEXEC */
  49. 			sprintf(modname, "binfmt-%04x", *(unsigned short *)(&bprm->buf[2]));
  50. 			request_module(modname);//试着将相应的模块装入，一共进行两次循环，正是为了在安装了模块以后再来试一次
  51. #endif
  52. 		}
  53. 	}
  54. 	return retval;
  55. }
     
  2. struct exec
  3. {
  4.   unsigned long a_info;		/* Use macros N_MAGIC, etc for access */
  5.   unsigned a_text;		/* length of text, in bytes */
  6.   unsigned a_data;		/* length of data, in bytes */
  7.   unsigned a_bss;		/* length of uninitialized data area for file, in bytes */
  8.   unsigned a_syms;		/* length of symbol table data in file, in bytes */
  9.   unsigned a_entry;		/* start address */
  10.   unsigned a_trsize;		/* length of relocation info for text, in bytes */
  11.   unsigned a_drsize;		/* length of relocation info for data, in bytes */
  12. };

    我们假设/bin/echo是a.out格式。所以fn(bprm, regs)，执行的代码是load_aout_binary。
  1. static int load_aout_binary(struct linux_binprm * bprm, struct pt_regs * regs)
  2. {
  3. 	struct exec ex;
  4. 	unsigned long error;
  5. 	unsigned long fd_offset;
  6. 	unsigned long rlim;
  7. 	int retval;
  9. 	ex = *((struct exec *) bprm->buf);		//128字节可执行文件头部
  10. 	if ((N_MAGIC(ex) != ZMAGIC && N_MAGIC(ex) != OMAGIC &&
  11. 	     N_MAGIC(ex) != QMAGIC && N_MAGIC(ex) != NMAGIC) ||
  12. 	    N_TRSIZE(ex) || N_DRSIZE(ex) ||
  13. 	    bprm->file->f_dentry->d_inode->i_size < ex.a_text+ex.a_data+N_SYMSIZE(ex)+N_TXTOFF(ex)) {
  14. 		return -ENOEXEC;//匹配不会返回-ENOEXEC
  15. 	}
  17. 	fd_offset = N_TXTOFF(ex);//根据代码的特性取得代码段在目标文件中的起始位置
  19. 	/* Check initial limits. This avoids letting people circumvent
  20. 	 * size limits imposed on them by creating programs with large
  21. 	 * arrays in the data or bss.
  22. 	 */
  23. 	rlim = current->rlim[RLIMIT_DATA].rlim_cur;//获取限制条件
  24. 	if (rlim >= RLIM_INFINITY)
  25. 		rlim = ~0;
  26. 	if (ex.a_data + ex.a_bss > rlim)//代码段和bss段的总和不能超过限制
  27. 		return -ENOMEM;
  29. 	/* Flush all traces of the currently running executable */
  30. 	retval = flush_old_exec(bprm);//到了"与过去告别"的时候了，这种"告别过去"意味着放弃从父进程"继承"下来的全部用户空间，不管是通过复制还是通过指针共享继承下来的
  31. 	if (retval)
  32. 		return retval;
  34. 	/* OK, This is the point of no return */
  35. #if !defined(__sparc__)
  36. 	set_personality(PER_LINUX);
  37. #else
  38. 	set_personality(PER_SUNOS);
  39. #if !defined(__sparc_v9__)
  40. 	memcpy(current->thread.core_exec, &ex, sizeof(struct exec));
  41. #endif
  42. #endif
  44. 	current->mm->end_code = ex.a_text +
  45. 		(current->mm->start_code = N_TXTADDR(ex));//代码段起始和结束地址，详细请看紧邻本代码段的相关代码
  46. 	current->mm->end_data = ex.a_data +
  47. 		(current->mm->start_data = N_DATADDR(ex));//数据段起始和结束地址，数据段起始地址就是代码段结束地址
  48. 	current->mm->brk = ex.a_bss +
  49. 		(current->mm->start_brk = N_BSSADDR(ex));//bss段起始和结束地址，bss起始地址就是数据段结束地址
  51. 	current->mm->rss = 0;
  52. 	current->mm->mmap = NULL;
  53. 	compute_creds(bprm);//确定是否具有其权限
  54.  	current->flags &= ~PF_FORKNOEXEC;
  55. #ifdef __sparc__
  56. 	if (N_MAGIC(ex) == NMAGIC) {//其他格式
  57. 		loff_t pos = fd_offset;//elf代码段偏移地址
  58. 		/* Fuck me plenty... */
  59. 		error = do_brk(N_TXTADDR(ex), ex.a_text);
  60. 		bprm->file->f_op->read(bprm->file, (char *) N_TXTADDR(ex),
  61. 			  ex.a_text, &pos);
  62. 		error = do_brk(N_DATADDR(ex), ex.a_data);
  63. 		bprm->file->f_op->read(bprm->file, (char *) N_DATADDR(ex),
  64. 			  ex.a_data, &pos);
  65. 		goto beyond_if;
  66. 	}
  67. #endif
  69. 	if (N_MAGIC(ex) == OMAGIC) {//如果魔术是OMAGIC
  70. 		unsigned long text_addr, map_size;
  71. 		loff_t pos;
  73. 		text_addr = N_TXTADDR(ex);//代码段起始地址
  75. #if defined(__alpha__) || defined(__sparc__)
  76. 		pos = fd_offset;//根据代码的特性取得代码段在目标文件中的起始位置
  77. 		map_size = ex.a_text+ex.a_data + PAGE_SIZE - 1;//代码段和数据段的大小
  78. #else
  79. 		pos = 32;
  80. 		map_size = ex.a_text+ex.a_data;
  81. #endif
  83. 		error = do_brk(text_addr & PAGE_MASK, map_size);//为正文段和数据段合在一起分配空间
  84. 		if (error != (text_addr & PAGE_MASK)) {//出错
  85. 			send_sig(SIGKILL, current, 0);//杀死当前进程
  86. 			return error;
  87. 		}
  89. 		error = bprm->file->f_op->read(bprm->file, (char *)text_addr,
  90. 			  ex.a_text+ex.a_data, &pos);//然后就把这两部分从文件中读进来，这样就有了vm_struct结构，对应的页目录表项，页表项，页面，而且页面已经放入了文件中的代码段和数据段
  91. 		if (error < 0) {
  92. 			send_sig(SIGKILL, current, 0);
  93. 			return error;
  94. 		}
  95. 			 
  96. 		flush_icache_range(text_addr, text_addr+ex.a_text+ex.a_data);
  97. 	} else {//如果魔术不是OMAGIC
  98. 		static unsigned long error_time, error_time2;
  99. 		if ((ex.a_text & 0xfff || ex.a_data & 0xfff) &&
  100. 		    (N_MAGIC(ex) != NMAGIC) && (jiffies-error_time2) > 5*HZ)
  101. 		{
  102. 			printk(KERN_NOTICE "executable not page aligned\n");
  103. 			error_time2 = jiffies;
  104. 		}
  106. 		if ((fd_offset & ~PAGE_MASK) != 0 &&
  107. 		    (jiffies-error_time) > 5*HZ)
  108. 		{
  109. 			printk(KERN_WARNING 
  110. 			       "fd_offset is not page aligned. Please convert program: %s\n",
  111. 			       bprm->file->f_dentry->d_name.name);
  112. 			error_time = jiffies;
  113. 		}
  115. 		if (!bprm->file->f_op->mmap||((fd_offset & ~PAGE_MASK) != 0)) {//如果没有mmap函数或者代码段及数据段的长度不与页面大小对齐
  116. 			loff_t pos = fd_offset;
  117. 			do_brk(N_TXTADDR(ex), ex.a_text+ex.a_data);//和上面的方式一样，正文段和数据段合在一起分配空间
  118. 			bprm->file->f_op->read(bprm->file,(char *)N_TXTADDR(ex),
  119. 					ex.a_text+ex.a_data, &pos);//然后就把这两部分从文件中读进来，这样就有了vm_struct结构，对应的页目录表项，页表项，页面，而且页面已经放入了文件中的代码段和数据段
  120. 			flush_icache_range((unsigned long) N_TXTADDR(ex),
  121. 					   (unsigned long) N_TXTADDR(ex) +
  122. 					   ex.a_text+ex.a_data);
  123. 			goto beyond_if;
  124. 		}
  126. 		down(current->mm->mmap_sem);
  127. 		error = do_mmap(bprm->file, N_TXTADDR(ex), ex.a_text,//如果有mmap,将文件的代码段映射到进程的用户空间
  128. 			PROT_READ | PROT_EXEC,
  129. 			MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE | MAP_EXECUTABLE,
  130. 			fd_offset);
  131. 		up(current->mm->mmap_sem);
  133. 		if (error != N_TXTADDR(ex)) {
  134. 			send_sig(SIGKILL, current, 0);
  135. 			return error;
  136. 		}
  138. 		down(current->mm->mmap_sem);
  139.  		error = do_mmap(bprm->file, N_DATADDR(ex), ex.a_data,///如果有mmap,将文件的数据段映射到进程的用户空间
  140. 				PROT_READ | PROT_WRITE | PROT_EXEC,
  141. 				MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE | MAP_EXECUTABLE,
  142. 				fd_offset + ex.a_text);//数据段在文件中的偏移是fd_offset + ex.a_text
  143. 		up(current->mm->mmap_sem);
  144. 		if (error != N_DATADDR(ex)) {
  145. 			send_sig(SIGKILL, current, 0);
  146. 			return error;
  147. 		}
  148. 	}
  149. beyond_if:
  150. 	set_binfmt(&aout_format);//current->binfmt = aout_format;
  152. 	set_brk(current->mm->start_brk, current->mm->brk);//为可执行文件的bss段分配空间并建立起页面映射
  154. 	retval = setup_arg_pages(bprm); //在用户空间的堆栈区顶部为进程建立起一个虚拟区间，并将执行参数以及环境变量所占的物理页面与此虚拟区间建立起映射
  155. 	if (retval < 0) { 
  156. 		/* Someone check-me: is this error path enough? */ 
  157. 		send_sig(SIGKILL, current, 0); 
  158. 		return retval;
  159. 	}
  161. 	current->mm->start_stack =
  162. 		(unsigned long) create_aout_tables((char *) bprm->p, bprm);//把一些变量放入用户堆栈中，返回的是STACK_TOP减去图中参数所占空间，也就是堆栈开始的虚拟地址
  163. #ifdef __alpha__
  164. 	regs->gp = ex.a_gpvalue;
  165. #endif
  166.                        //起始地址  ,栈指针
  167. 	start_thread(regs, ex.a_entry, current->mm->start_stack);//设置系统堆栈中的eip，esp
  168. 	if (current->ptrace & PT_PTRACED)
  169. 		send_sig(SIGTRAP, current, 0);
  170. 	return 0;
  171. }

复制信号处理函数指针数组,放弃用户空间或者不跟父进程共享内存空间,如果此进程实际为一个线程组的线程,那就从线程组中脱离,改变信号处理模式为默认处理,关闭file文件对象
  1. int flush_old_exec(struct linux_binprm * bprm)
  2. {
  3. 	char * name;
  4. 	int i, ch, retval;
  5. 	struct signal_struct * oldsig;
  7. 	/*
  8. 	 * Make sure we have a private signal table
  9. 	 */
  10. 	oldsig = current->sig;//获取当前进程信号处理函数
  11. 	retval = make_private_signals();//如果子进程通过指针来共享父进程的信号处理表，就要把它复制过来
  12. 	if (retval) goto flush_failed;
  14. 	/* 
  15. 	 * Release all of the old mmap stuff
  16. 	 */
  17. 	retval = exec_mmap();//从父进程继承下来的用户空间就是在这里放弃的
  18. 	if (retval) goto mmap_failed;
  20. 	/* This is the point of no return */
  21. 	release_old_signals(oldsig);//如果子进程通过指针来共享父进程的信号处理表，那么就要减少oldsig->count的计数
  23. 	current->sas_ss_sp = current->sas_ss_size = 0;
  25. 	if (current->euid == current->uid && current->egid == current->gid)
  26. 		current->dumpable = 1;
  27. 	name = bprm->filename;
  28. 	for (i=0; (ch = *(name++)) != '\0';) {
  29. 		if (ch == '/')
  30. 			i = 0;
  31. 		else
  32. 			if (i < 15)
  33. 				current->comm[i++] = ch;
  34. 	}
  35. 	current->comm[i] = '\0';//comm[]，用于保存进程所执行的程序名，所以还要把bprm->filename的目标程序路径名的最后一段抄过去
  37. 	flush_thread();//不用关心
  39. 	de_thread(current);//如果当前进程是一个线程,从线程组中脱离出来
  41. 	if (bprm->e_uid != current->euid || bprm->e_gid != current->egid || 
  42. 	    permission(bprm->file->f_dentry->d_inode,MAY_READ))
  43. 		current->dumpable = 0;
  45. 	/* An exec changes our domain. We are no longer part of the thread
  46. 	   group */
  47. 	   
  48. 	current->self_exec_id++;
  49. 			
  50. 	flush_signal_handlers(current);//原来指向用户空间子程序的，现在设为SIG_DEL，表示采取预设的响应方式
  51. 	flush_old_files(current->files);//对原有已打开文件的处理
  53. 	return 0;
  55. mmap_failed:
  56. flush_failed:
  57. 	spin_lock_irq(current->sigmask_lock);
  58. 	if (current->sig != oldsig)
  59. 		kfree(current->sig);
  60. 	current->sig = oldsig;
  61. 	spin_unlock_irq(current->sigmask_lock);
  62. 	return retval;
  63. }
flush_old_exec中的make_private_signal
  1. static inline int make_private_signals(void)
  2. {
  3. 	struct signal_struct * newsig;
  5. 	if (atomic_read(current->sig->count) <= 1)//如果只是把父进程的信号处理表指针复制过来，而通过这指针来共享父进程的信号处理表，那么current->sig->count大于1
  6. 		return 0;
  7. 	newsig = kmem_cache_alloc(sigact_cachep, GFP_KERNEL);//自立门户，和copy_sighand()基本相同
  8. 	if (newsig == NULL)
  9. 		return -ENOMEM;
  10. 	spin_lock_init(&newsig->siglock);
  11. 	atomic_set(&newsig->count, 1);
  12. 	memcpy(newsig->action, current->sig->action, sizeof(newsig->action));//拷贝
  13. 	spin_lock_irq(current->sigmask_lock);
  14. 	current->sig = newsig;//获得新的
  15. 	spin_unlock_irq(current->sigmask_lock);
  16. 	return 0;
  17. }
flush_old_exec的exec_mmap函数
  2. static int exec_mmap(void)
  3. {
  4. 	struct mm_struct * mm, * old_mm;
  6. 	old_mm = current->mm;
  7. 	if (old_mm && atomic_read(&old_mm->mm_users) == 1) {//如果共享计数为1时，表明对此空间的使用是独占的，也就是说这是从父进程复制过来的
  8. 		flush_cache_mm(old_mm);//释放缓存
  9. 		mm_release();//针对vfork.父进程减少信号量休眠,以后让子进程up将其唤醒
  10. 		exit_mmap(old_mm);//释放mm_struct数据结构以下的所有vm_area_struct数据结构(但是不包括mm_struct结构本身),并将页面表项设置为0
  11. 		flush_tlb_mm(old_mm);//释放tlb的缓存
  12. 		return 0;
  13. 	}
  15. 	mm = mm_alloc();//如果只是将指向mm_struct数据结构的指针复制给子进程，让子进程通过这个指针来共享父进程的用户空间，那就可以跳过释放用户空间这一步，直接就为子进程分配新的用户空间
  16. 	if (mm) {
  17. 		struct mm_struct *active_mm = current->active_mm;//
  19. 		if (init_new_context(current, mm)) {//空语句
  20. 			mmdrop(mm);
  21. 			return -ENOMEM;
  22. 		}
  24. 		/* Add it to the list of mm's */
  25. 		spin_lock(&mmlist_lock);
  26. 		list_add(&mm->mmlist, &init_mm.mmlist);
  27. 		spin_unlock(&mmlist_lock);
  29. 		task_lock(current);
  30. 		current->mm = mm;//新分配空户空间初始化
  31. 		current->active_mm = mm;//新分配的空户空间
  32. 		task_unlock(current);
  33. 		activate_mm(active_mm, mm);//切换到新的的用户空间
  34. 		mm_release();//将父进程唤醒
  35. 		if (old_mm) {
  36. 			if (active_mm != old_mm) BUG();//如果不一致,说明线程成为了进程
  37. 			mmput(old_mm);//减少mm->mm_users计数，因为已经不共享了
  38. 			return 0;
  39. 		}
  40. 		mmdrop(active_mm);//如果已经没有进程使用这空间.将旧的空间给释放掉
  41. 		return 0;
  42. 	}
  43. 	return -ENOMEM;
  44. }

 根据close_on_exec位图，里面存储着表示哪些文件在执行一个新目标程序时应予关闭的信息。根据这个位图的指示将这些文件关闭，并且将此位图清成全0。
  1. static inline void flush_old_files(struct files_struct * files)
  2. {
  3. 	long j = -1;
  5. 	write_lock(&files->file_lock);
  6. 	for (;;) {
  7. 		unsigned long set, i;
  9. 		j++;
  10. 		i = j * __NFDBITS;
  11. 		if (i >= files->max_fds || i >= files->max_fdset)
  12. 			break;
  13. 		set = files->close_on_exec->fds_bits[j];
  14. 		if (!set)
  15. 			continue;
  16. 		files->close_on_exec->fds_bits[j] = 0;
  17. 		write_unlock(&files->file_lock);
  18. 		for ( ; set ; i++,set >>= 1) {
  19. 			if (set & 1) {
  20. 				sys_close(i);
  21. 			}
  22. 		}
  23. 		write_lock(&files->file_lock);
  25. 	}
  26. 	write_unlock(&files->file_lock);
  27. }

  2. void mmput(struct mm_struct *mm)
  3. {
  4. 	if (atomic_dec_and_lock(&mm->mm_users, &mmlist_lock)) {//减去1,是否为0
  5. 		list_del(&mm->mmlist);
  6. 		spin_unlock(&mmlist_lock);
  7. 		exit_mmap(mm);//将页表设置为0
  8. 		mmdrop(mm);//将页表项与页表,本身mm_struct全部释放
  9. 	}
  10. }


  1. int setup_arg_pages(struct linux_binprm *bprm)
  2. {
  3. 	unsigned long stack_base;
  4. 	struct vm_area_struct *mpnt;
  5. 	int i;
  8. 	stack_base = STACK_TOP - MAX_ARG_PAGES*PAGE_SIZE;//STACK_TOP为3GB
  11. 	bprm->p += stack_base;//bprm->p原来是MAX_ARG_PAGES*PAGE_SIZE-参数的数量，现在加上STACK_TOP - MAX_ARG_PAGES*PAGE_SIZE，最后是STACK_TOP - 参数的数量
  12. 	if (bprm->loader)
  13. 		bprm->loader += stack_base;
  14. 	bprm->exec += stack_base;
  17. 	mpnt = kmem_cache_alloc(vm_area_cachep, SLAB_KERNEL);//从slab中获取一页
  18. 	if (!mpnt) 
  19. 		return -ENOMEM; 
  20. 	
  21. 	down(¤t->mm->mmap_sem);
  22. 	{
  23. 		mpnt->vm_mm = current->mm;//内存描述符
  24. 		mpnt->vm_start = PAGE_MASK & (unsigned long) bprm->p;//堆栈段开始地址
  25. 		mpnt->vm_end = STACK_TOP;//堆栈段结束地址
  26. 		mpnt->vm_page_prot = PAGE_COPY;
  27. 		mpnt->vm_flags = VM_STACK_FLAGS;
  28. 		mpnt->vm_ops = NULL;
  29. 		mpnt->vm_pgoff = 0;
  30. 		mpnt->vm_file = NULL;
  31. 		mpnt->vm_private_data = (void *) 0;
  32. 		insert_vm_struct(current->mm, mpnt);//插入
  33. 		current->mm->total_vm = (mpnt->vm_end - mpnt->vm_start) >> PAGE_SHIFT;
  34. 	} 
  37. 	for (i = 0 ; i < MAX_ARG_PAGES ; i++) {
  38. 		struct page *page = bprm->page[i];//从page[0]开始
  39. 		if (page) {
  40. 			bprm->page[i] = NULL;
  41. 			current->mm->rss++;
  42. 			put_dirty_page(current,page,stack_base);//建立从堆栈虚拟空间到页面之前的映射
  43. 		}
  44. 		stack_base += PAGE_SIZE;//加一个页面的长度，4096个字节
  45. 	}
  46. 	up(&current->mm->mmap_sem);
  47. 	
  48. 	return 0;
  49. }


  2. static unsigned long * create_aout_tables(char * p, struct linux_binprm * bprm)
  3. {
  4. 	char **argv, **envp;
  5. 	unsigned long * sp;
  6. 	int argc = bprm->argc;//程序参数个数
  7. 	int envc = bprm->envc;//环境字符串个数
  8.     //sp指向当前堆栈页面的栈顶指针
  9.     sp = (unsigned long *) ((-(unsigned long)sizeof(char *)) & (unsigned long) p);
  10. #ifdef __sparc__
  11. 	/* This imposes the proper stack alignment for a new process. */
  12. 	sp = (unsigned long *) (((unsigned long) sp) & ~7);
  13. 	if ((envc+argc+3)&1) --sp;
  14. #endif
  15. #ifdef __alpha__
  16. /* whee.. test-programs are so much fun. */
  17. 	put_user(0, --sp);
  18. 	put_user(0, --sp);
  19. 	if (bprm->loader) {
  20. 		put_user(0, --sp);
  21. 		put_user(0x3eb, --sp);
  22. 		put_user(bprm->loader, --sp);
  23. 		put_user(0x3ea, --sp);
  24. 	}
  25. 	put_user(bprm->exec, --sp);
  26. 	put_user(0x3e9, --sp);
  27. #endif
  28. //sp减去envc+1作为环境字符串指针数组的起始地址,最后一个数组元素为0
  29. 	sp -= envc+1;
  30. 	envp = (char **) sp;//指向环境字符串数组的起始地址
  31. 	sp -= argc+1;//同上
  32. 	argv = (char **) sp;
  33. #if defined(__i386__) || defined(__mc68000__) || defined(__arm__)
  34. //栈顶sp继续向低地址放扩展,存放envp,argv,argc
  35. 	put_user((unsigned long) envp,--sp);
  36. 	put_user((unsigned long) argv,--sp);
  37. #endif
  38. 	put_user(argc,--sp);
  39. 	current->mm->arg_start = (unsigned long) p;
  40. //循环对堆栈中的环境字符串指针数组初始化
  41. 	while (argc-->0) {
  42. 		char c;
  43. 		put_user(p,argv++);
  44. 		do {
  45. 			get_user(c,p++);
  46. 		} while (c);
  47. 	}
  48. 	put_user(NULL,argv);
  49. 	current->mm->arg_end = current->mm->env_start = (unsigned long) p;//env_start和arg_end
  50. 	while (envc-->0) {
  51. 		char c;
  52. 		put_user(p,envp++);
  53. 		do {
  54. 			get_user(c,p++);
  55. 		} while (c);
  56. 	}
  57. 	put_user(NULL,envp);
  58. 	current->mm->env_end = (unsigned long) p;//env_end
  59. 	return sp;//返回的是STACK_TOP减去图中参数所占空间
  60. }





来自为知笔记(Wiz)


posted on 2016-10-27 11:00  笨拙的菜鸟  阅读(1107)  评论(0)  编辑  收藏  举报

导航