linux内核情景分析之execve()

用来描述用户态的cpu寄存器在内核栈中保存情况.可以获取用户空间的信息

    

  1. struct pt_regs {
    2. 

  2. long ebx;                  //可执行文件路径的指针（regs.ebx中
    3. 

  3. long ecx;                  //命令行参数的指针（regs.ecx中）
    4. 

  4. long edx;                  //环境变量的指针（regs.edx中）。
    5. 

  5. long esi;
    6. 

  6. long edi;
    7. 

  7. long ebp;
    8. 

  8. long eax;
    9. 

  9. int xds;
    10. 

  10. int xes;
    11. 

  11. long orig_eax;
    12. 

  12. long eip;
    13. 

  13. int xcs;
    14. 

  14. long eflags;
    15. 

  15. long esp;
    16. 

  16. int xss;
    17. 

  17. };
    18. 



    

  1. asmlinkage int sys_execve(struct pt_regs regs)
    2. 

  2. {
    3. 

  3. 	int error;
    4. 

  4. 	char * filename;
    5. 

  5. filename = getname((char *) regs.ebx);//ebx为"/bin/echo"，把字符串从用户空间拷贝到系统空间
    6. 

  6. 	error = PTR_ERR(filename);//判断是否出错
    7. 

  7. 	if (IS_ERR(filename))
    8. 

  8. 		goto out;
    9. 

  9.                       //文件名   参数           NULL 传入副本
    10. 

  10. 	error = do_execve(filename, (char **) regs.ecx, (char **) regs.edx, &regs);//ecx为args，edx为NULL
    11. 

  11. 	if (error == 0)
    12. 

  12. 		current->ptrace &= ~PT_DTRACE;
    13. 

  13. 	putname(filename);//将之前为文件名分配的空间释放掉
    14. 

  14. out:
    15. 

  15. 	return error;
    16. 

  16. }
    17.

linux内核每种被注册的可执行程序格式都用linux_bin_fmt来存储,其中记录了可执行程序的加载和执行函数,同时我们需要一种方法来保存可执行程序的信息, 比如可执行文件的路径, 运行的参数和环境变量等信息，即linux_bin_prm结构

    

  1. /*
    2. 

  2. * This structure is used to hold the arguments that are used when loading binaries.
    3. 

  3. */
    4. 

  4. struct linux_binprm {
    5. 

  5.     char buf[BINPRM_BUF_SIZE];  // 保存可执行文件的头128字节
    6. 

  6. #ifdef CONFIG_MMU
    7. 

  7.     struct vm_area_struct *vma;
    8. 

  8.     unsigned long vma_pages;
    9. 

  9. #else
    10. 

  10. # define MAX_ARG_PAGES  32
    11. 

  11.     struct page *page[MAX_ARG_PAGES];
    12. 

  12. #endif
    13. 

  13.     struct mm_struct *mm;
    14. 

  14.     unsigned long p; /* current top of mem , 当前内存页最高地址*/
    15. 

  15.     unsigned int
    16. 

  16.             cred_prepared:1,/* true if creds already prepared (multiple
    17. 

  17.                              * preps happen for interpreters) */
    18. 

  18.             cap_effective:1;/* true if has elevated effective capabilities,
    19. 

  19.                              * false if not; except for init which inherits
    20. 

  20.                              * its parent‘s caps anyway */
    21. 

  21. #ifdef __alpha__
    22. 

  22.     unsigned int taso:1;
    23. 

  23. #endif
    24. 

  24.     unsigned int recursion_depth; /* only for search_binary_handler() */
    25. 

  25.     struct file * file;         /*  要执行的文件  */
    26. 

  26.     struct cred *cred;      /* new credentials */
    27. 

  27.     int unsafe;             /* how unsafe this exec is (mask of LSM_UNSAFE_*) */
    28. 

  28.     unsigned int per_clear; /* bits to clear in current->personality */
    29. 

  29.     int argc, envc;     /*  命令行参数和环境变量数目  */
    30. 

  30.     const char * filename;  /* Name of binary as seen by procps, 要执行的文件的名称  */
    31. 

  31.     const char * interp;    /* Name of the binary really executed. Most
    32. 

  32.                                of the time same as filename, but could be
    33. 

  33.                                different for binfmt_{misc,script} 要执行的文件的真实名称，通常和filename相同  */
    34. 

  34.     unsigned interp_flags;
    35. 

  35.     unsigned interp_data;
    36. 

  36.     unsigned long loader, exec;
    37. 

  37. };
    38. 



    

    2. 

  2. int do_execve(char * filename, char ** argv, char ** envp, struct pt_regs * regs)
    3. 

  3. {
    4. 

  4. 	struct linux_binprm bprm;//存储可执行文件信息
    5. 

  5. 	struct file *file;
    6. 

  6. 	int retval;
    7. 

  7. 	int i;
    8. 

    9. 

  9. 	file = open_exec(filename);//打开目标文件 /bin/echo
    10. 

    11. 

  11. 	retval = PTR_ERR(file);
    12. 

  12. 	if (IS_ERR(file))
    13. 

  13. 		return retval;
    14. 

    15. 

  15. 	bprm.p = PAGE_SIZE*MAX_ARG_PAGES-sizeof(void *);//1024*32减去一个指针的大小,当前页最高地址
    16. 

  16. 	memset(bprm.page, 0, MAX_ARG_PAGES*sizeof(bprm.page[0])); //page指针数组初始化为0
    17. 

    18. 

  18. 	bprm.file = file;
    19. 

  19. 	bprm.filename = filename;
    20. 

  20. 	bprm.sh_bang = 0;//可执行文件属性.0表示二进制
    21. 

  21. 	bprm.loader = 0;
    22. 

  22. 	bprm.exec = 0;//参数的起始地址(从上往下方向)
    23. 

  23. 	if ((bprm.argc = count(argv, bprm.p / sizeof(void *))) < 0) {//对指针数组argv[]中参数的个数进行计数，而bprm.p / sizeof(void *)表示允许的最大值，由于agrv[]是在用户空间而不在系统空间
    24. 

  24. 		allow_write_access(file);//防止其他进程在读入可执行文件期间通过内存映射改变它的内容
    25. 

  25. 		fput(file);
    26. 

  26. 		return bprm.argc;
    27. 

  27. 	 }
    28. 

    29. 

  29.    	if ((bprm.envc = count(envp, bprm.p / sizeof(void *))) < 0) {//同上环境变量
    30. 

  30. 		allow_write_access(file);
    31. 

  31. 		fput(file);
    32. 

  32. 		return bprm.envc;
    33. 

  33. 	}
    34. 

    35. 

  35. 	retval = prepare_binprm(&bprm);//见下面的代码,为bprm结构做准备,读取128个字节到缓冲区
    36. 

  36. 	if (retval < 0) 
    37. 

  37. 		goto out; 
    38. 

    39. 

  39.    	retval = copy_strings_kernel(1, &bprm.filename, &bprm);//由于bprm.filename已经在系统空间了，所以copy_strings_kernel从系统空间中拷贝
    40. 

  40. 	if (retval < 0) 
    41. 

  41. 		goto out; 
    42. 

    43. 

  43. 	bprm.exec = bprm.p;//参数的起始地址
    44. 

  44. 	retval = copy_strings(bprm.envc, envp, &bprm);//从用户空间拷贝，参考copy_strings_kernel
    45. 

  45. 	if (retval < 0) 
    46. 

  46. 		goto out; 
    47. 

    48. 

  48. 	retval = copy_strings(bprm.argc, argv, &bprm);//从用户空间拷贝，参考copy_strings_kernel
    49. 

  49. 	if (retval < 0) 
    50. 

  50. 		goto out; 
    51. 

    52. 

  52. 	retval = search_binary_handler(&bprm,regs);//已经从可执行文件头部读入了128个字节存放在bprm的缓冲区，而且运行所需的参数和环境变量也已经搜集在bprm中，现在就由formats队列中的成员逐个来认领，谁要识别到它代表的可执行文件格式，运行的时候就交给它
    53. 

  53. 	if (retval >= 0)
    54. 

  54. 		/* execve success */
    55. 

  55. 		return retval;
    56. 

    57. 

  57. out:
    58. 

  58. 	/*出错,返回inode和释放argv的页 Something went wrong, return the inode and free the argument pages*/
    59. 

  59. 	allow_write_access(bprm.file);
    60. 

  60. 	if (bprm.file)
    61. 

  61. 		fput(bprm.file);//释放文件对象
    62. 

    63. 

  63. 	for (i = 0 ; i < MAX_ARG_PAGES ; i++) {
    64. 

  64. 		struct page * page = bprm.page[i];
    65. 

  65. 		if (page)
    66. 

  66. 			__free_page(page);
    67. 

  67. 	}
    68. 

    69. 

  69. 	return retval;
    70. 

  70. }
    71.

分析prepare_binprm

    

    2. 

  2. int prepare_binprm(struct linux_binprm *bprm)
    3. 

  3. {
    4. 

  4. 	int mode;
    5. 

  5. 	struct inode * inode = bprm->file->f_dentry->d_inode;//获取打开的文件节点
    6. 

    7. 

  7. 	mode = inode->i_mode;//类型
    8. 

  8. 	/* Huh? We had already checked for MAY_EXEC, WTF do we check this? */
    9. 

  9. 	if (!(mode & 0111))	/* with at least _one_ execute bit set最少可执行状态 */
    10. 

  10. 		return -EACCES;
    11. 

  11. 	if (bprm->file->f_op == NULL)//针对文件操作不允许为空
    12. 

  12. 		return -EACCES;
    13. 

    14. 

  14. 	bprm->e_uid = current->euid;//继承uid
    15. 

  15. 	bprm->e_gid = current->egid;//继承gid
    16. 

    17. 

  17. 	if(!IS_NOSUID(inode)) {//是否是SUID
    18. 

  18. 		/* Set-uid? */
    19. 

  19. 		if (mode & S_ISUID)//如果有SUID.那就设置
    20. 

  20. 			bprm->e_uid = inode->i_uid;
    21. 

    22. 

  22. 		/* Set-gid? */
    23. 

  23. 		/*
    24. 

  24. 		 * If setgid is set but no group execute bit then this
    25. 

  25. 		 * is a candidate for mandatory locking, not a setgid
    26. 

  26. 		 * executable.
    27. 

  27. 		 */
    28. 

  28. 		if ((mode & (S_ISGID | S_IXGRP)) == (S_ISGID | S_IXGRP))
    29. 

  29. 			bprm->e_gid = inode->i_gid;
    30. 

  30. 	}
    31. 

    32. 

  32. 	/* We don‘t have VFS support for capabilities yet */
    33. 

  33. 	cap_clear(bprm->cap_inheritable);
    34. 

  34. 	cap_clear(bprm->cap_permitted);
    35. 

  35. 	cap_clear(bprm->cap_effective);
    36. 

    37. 

  37. 	/*  To support inheritance of root-permissions and suid-root
    38. 

  38.          *  executables under compatibility mode, we raise all three
    39. 

  39.          *  capability sets for the file.
    40. 

  40.          *
    41. 

  41.          *  If only the real uid is 0, we only raise the inheritable
    42. 

  42.          *  and permitted sets of the executable file.
    43. 

  43.          */
    44. 

    45. 

  45. 	if (!issecure(SECURE_NOROOT)) {
    46. 

  46. 		if (bprm->e_uid == 0 || current->uid == 0) {
    47. 

  47. 			cap_set_full(bprm->cap_inheritable);
    48. 

  48. 			cap_set_full(bprm->cap_permitted);
    49. 

  49. 		}
    50. 

  50. 		if (bprm->e_uid == 0) 
    51. 

  51. 			cap_set_full(bprm->cap_effective);
    52. 

  52. 	}
    53. 

    54. 

  54. 	memset(bprm->buf,0,BINPRM_BUF_SIZE);//从可执行文件中读入开头的128个字节到linux_binprm结构bprm中的缓冲区
    55. 

  55. 	return kernel_read(bprm->file,0,bprm->buf,BINPRM_BUF_SIZE);
    56. 

  56. }
    57.

inux内核对所支持的每种可执行的程序类型都有个struct linux_binfmt的数据结构，定义如下

search_binary_handler，已经从可执行文件头部读入了128个字节存放在bprm的缓冲区，而且运行所需的参数和环境变量也已经搜集在bprm中，现在就由formats队列中的成员逐个来认领，谁要识别到它代表的可执行文件格式，运行的时候就交给它，代码如下

    

  1. struct linux_binfmt {
    2. 

  2.     struct list_head lh;
    3. 

  3.     struct module *module;
    4. 

  4.     int (*load_binary)(struct linux_binprm *);//通过读存放在可执行文件中的信息为当前进程建立一个新的执行环境
    5. 

  5.     int (*load_shlib)(struct file *);//用于动态的把一个共享库捆绑到一个已经在运行的进程, 这是由uselib()系统调用激活的
    6. 

  6.     int (*core_dump)(struct coredump_params *cprm);//在名为core的文件中, 存放当前进程的执行上下文. 这个文件通常是在进程接收到一个缺省操作为”dump”的信号时被创建的, 其格式取决于被执行程序的可执行类型
    7. 

  7.     unsigned long min_coredump;     /* minimal dump size */
    8. 

  8.  };
    9. 



    

    2. 

  2. int search_binary_handler(struct linux_binprm *bprm,struct pt_regs *regs)
    3. 

  3. {
    4. 

  4. 	int try,retval=0;
    5. 

  5. 	struct linux_binfmt *fmt;
    6. 

  6.         ......
    7. 

  7. //一共2层循环,外出循环式为了安装了模块后再试一次
    8. 

  8. 	for (try=0; try<2; try++) {
    9. 

  9. 		read_lock(&binfmt_lock);
    10. 

  10. //所有的linux_binfmt对象都处于一个链表中, 第一个元素的地址存放在formats变量中
    11. 

  11. 		for (fmt = formats ; fmt ; fmt = fmt->next) {
    12. 

  12. 			int (*fn)(struct linux_binprm *, struct pt_regs *) = fmt->load_binary;
    13. 

  13. 			if (!fn)//是否是可执行文件
    14. 

  14. 				continue;
    15. 

  15. 			if (!try_inc_mod_count(fmt->module))//是否是动态安装库
    16. 

  16. 				continue;
    17. 

  17. 			read_unlock(&binfmt_lock);
    18. 

  18. 			retval = fn(bprm, regs);//加载,如果谁都不认识,返回-ENOEXEC表示对不上号
    19. 

  19. 			if (retval >= 0) {
    20. 

  20. 				put_binfmt(fmt);
    21. 

  21. 				allow_write_access(bprm->file);
    22. 

  22. 				if (bprm->file)
    23. 

  23. 					fput(bprm->file);
    24. 

  24. 				bprm->file = NULL;
    25. 

  25. 				current->did_exec = 1;
    26. 

  26. 				return retval;
    27. 

  27. 			}
    28. 

  28. 			read_lock(&binfmt_lock);
    29. 

  29. 			put_binfmt(fmt);
    30. 

  30. 			if (retval != -ENOEXEC)//只要不是对不上号，就退出循环
    31. 

  31. 				break;
    32. 

  32. 			if (!bprm->file) {
    33. 

  33. 				read_unlock(&binfmt_lock);
    34. 

  34. 				return retval;
    35. 

  35. 			}
    36. 

  36. 		}
    37. 

  37. 		read_unlock(&binfmt_lock);
    38. 

  38. 		if (retval != -ENOEXEC) {
    39. 

  39. 			break;
    40. 

  40. #ifdef CONFIG_KMOD
    41. 

  41. 		}else{
    42. 

  42. #define printable(c) (((c)==‘\t‘) || ((c)==‘\n‘) || (0x20<=(c) && (c)<=0x7e))
    43. 

  43. 			char modname[20];
    44. 

  44. 			if (printable(bprm->buf[0]) &&
    45. 

  45. 			    printable(bprm->buf[1]) &&
    46. 

  46. 			    printable(bprm->buf[2]) &&
    47. 

  47. 			    printable(bprm->buf[3]))
    48. 

  48. 				break; /* -ENOEXEC */
    49. 

  49. 			sprintf(modname, "binfmt-%04x", *(unsigned short *)(&bprm->buf[2]));
    50. 

  50. 			request_module(modname);//试着将相应的模块装入，一共进行两次循环，正是为了在安装了模块以后再来试一次
    51. 

  51. #endif
    52. 

  52. 		}
    53. 

  53. 	}
    54. 

  54. 	return retval;
    55. 

  55. }
    56. 



    

    2. 

  2. struct exec
    3. 

  3. {
    4. 

  4.   unsigned long a_info;		/* Use macros N_MAGIC, etc for access */
    5. 

  5.   unsigned a_text;		/* length of text, in bytes */
    6. 

  6.   unsigned a_data;		/* length of data, in bytes */
    7. 

  7.   unsigned a_bss;		/* length of uninitialized data area for file, in bytes */
    8. 

  8.   unsigned a_syms;		/* length of symbol table data in file, in bytes */
    9. 

  9.   unsigned a_entry;		/* start address */
    10. 

  10.   unsigned a_trsize;		/* length of relocation info for text, in bytes */
    11. 

  11.   unsigned a_drsize;		/* length of relocation info for data, in bytes */
    12. 

  12. };
    13.

我们假设/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. 

  2. {
    3. 

  3. 	struct exec ex;
    4. 

  4. 	unsigned long error;
    5. 

  5. 	unsigned long fd_offset;
    6. 

  6. 	unsigned long rlim;
    7. 

  7. 	int retval;
    8. 

    9. 

  9. 	ex = *((struct exec *) bprm->buf);		//128字节可执行文件头部
    10. 

  10. 	if ((N_MAGIC(ex) != ZMAGIC && N_MAGIC(ex) != OMAGIC &&
    11. 

  11. 	     N_MAGIC(ex) != QMAGIC && N_MAGIC(ex) != NMAGIC) ||
    12. 

  12. 	    N_TRSIZE(ex) || N_DRSIZE(ex) ||
    13. 

  13. 	    bprm->file->f_dentry->d_inode->i_size < ex.a_text+ex.a_data+N_SYMSIZE(ex)+N_TXTOFF(ex)) {
    14. 

  14. 		return -ENOEXEC;//匹配不会返回-ENOEXEC
    15. 

  15. 	}
    16. 

    17. 

  17. 	fd_offset = N_TXTOFF(ex);//根据代码的特性取得代码段在目标文件中的起始位置
    18. 

    19. 

  19. 	/* Check initial limits. This avoids letting people circumvent
    20. 

  20. 	 * size limits imposed on them by creating programs with large
    21. 

  21. 	 * arrays in the data or bss.
    22. 

  22. 	 */
    23. 

  23. 	rlim = current->rlim[RLIMIT_DATA].rlim_cur;//获取限制条件
    24. 

  24. 	if (rlim >= RLIM_INFINITY)
    25. 

  25. 		rlim = ~0;
    26. 

  26. 	if (ex.a_data + ex.a_bss > rlim)//代码段和bss段的总和不能超过限制
    27. 

  27. 		return -ENOMEM;
    28. 

    29. 

  29. 	/* Flush all traces of the currently running executable */
    30. 

  30. 	retval = flush_old_exec(bprm);//到了"与过去告别"的时候了，这种"告别过去"意味着放弃从父进程"继承"下来的全部用户空间，不管是通过复制还是通过指针共享继承下来的
    31. 

  31. 	if (retval)
    32. 

  32. 		return retval;
    33. 

    34. 

  34. 	/* OK, This is the point of no return */
    35. 

  35. #if !defined(__sparc__)
    36. 

  36. 	set_personality(PER_LINUX);
    37. 

  37. #else
    38. 

  38. 	set_personality(PER_SUNOS);
    39. 

  39. #if !defined(__sparc_v9__)
    40. 

  40. 	memcpy(current->thread.core_exec, &ex, sizeof(struct exec));
    41. 

  41. #endif
    42. 

  42. #endif
    43. 

    44. 

  44. 	current->mm->end_code = ex.a_text +
    45. 

  45. 		(current->mm->start_code = N_TXTADDR(ex));//代码段起始和结束地址，详细请看紧邻本代码段的相关代码
    46. 

  46. 	current->mm->end_data = ex.a_data +
    47. 

  47. 		(current->mm->start_data = N_DATADDR(ex));//数据段起始和结束地址，数据段起始地址就是代码段结束地址
    48. 

  48. 	current->mm->brk = ex.a_bss +
    49. 

  49. 		(current->mm->start_brk = N_BSSADDR(ex));//bss段起始和结束地址，bss起始地址就是数据段结束地址
    50. 

    51. 

  51. 	current->mm->rss = 0;
    52. 

  52. 	current->mm->mmap = NULL;
    53. 

  53. 	compute_creds(bprm);//确定是否具有其权限
    54. 

  54.  	current->flags &= ~PF_FORKNOEXEC;
    55. 

  55. #ifdef __sparc__
    56. 

  56. 	if (N_MAGIC(ex) == NMAGIC) {//其他格式
    57. 

  57. 		loff_t pos = fd_offset;//elf代码段偏移地址
    58. 

  58. 		/* Fuck me plenty... */
    59. 

  59. 		error = do_brk(N_TXTADDR(ex), ex.a_text);
    60. 

  60. 		bprm->file->f_op->read(bprm->file, (char *) N_TXTADDR(ex),
    61. 

  61. 			  ex.a_text, &pos);
    62. 

  62. 		error = do_brk(N_DATADDR(ex), ex.a_data);
    63. 

  63. 		bprm->file->f_op->read(bprm->file, (char *) N_DATADDR(ex),
    64. 

  64. 			  ex.a_data, &pos);
    65. 

  65. 		goto beyond_if;
    66. 

  66. 	}
    67. 

  67. #endif
    68. 

    69. 

  69. 	if (N_MAGIC(ex) == OMAGIC) {//如果魔术是OMAGIC
    70. 

  70. 		unsigned long text_addr, map_size;
    71. 

  71. 		loff_t pos;
    72. 

    73. 

  73. 		text_addr = N_TXTADDR(ex);//代码段起始地址
    74. 

    75. 

  75. #if defined(__alpha__) || defined(__sparc__)
    76. 

  76. 		pos = fd_offset;//根据代码的特性取得代码段在目标文件中的起始位置
    77. 

  77. 		map_size = ex.a_text+ex.a_data + PAGE_SIZE - 1;//代码段和数据段的大小
    78. 

  78. #else
    79. 

  79. 		pos = 32;
    80. 

  80. 		map_size = ex.a_text+ex.a_data;
    81. 

  81. #endif
    82. 

    83. 

  83. 		error = do_brk(text_addr & PAGE_MASK, map_size);//为正文段和数据段合在一起分配空间
    84. 

  84. 		if (error != (text_addr & PAGE_MASK)) {//出错
    85. 

  85. 			send_sig(SIGKILL, current, 0);//杀死当前进程
    86. 

  86. 			return error;
    87. 

  87. 		}
    88. 

    89. 

  89. 		error = bprm->file->f_op->read(bprm->file, (char *)text_addr,
    90. 

  90. 			  ex.a_text+ex.a_data, &pos);//然后就把这两部分从文件中读进来，这样就有了vm_struct结构，对应的页目录表项，页表项，页面，而且页面已经放入了文件中的代码段和数据段
    91. 

  91. 		if (error < 0) {
    92. 

  92. 			send_sig(SIGKILL, current, 0);
    93. 

  93. 			return error;
    94. 

  94. 		}
    95. 

  95. 			 
    96. 

  96. 		flush_icache_range(text_addr, text_addr+ex.a_text+ex.a_data);
    97. 

  97. 	} else {//如果魔术不是OMAGIC
    98. 

  98. 		static unsigned long error_time, error_time2;
    99. 

  99. 		if ((ex.a_text & 0xfff || ex.a_data & 0xfff) &&
    100. 

  100. 		    (N_MAGIC(ex) != NMAGIC) && (jiffies-error_time2) > 5*HZ)
    101. 

  101. 		{
    102. 

  102. 			printk(KERN_NOTICE "executable not page aligned\n");
    103. 

  103. 			error_time2 = jiffies;
    104. 

  104. 		}
    105. 

    106. 

  106. 		if ((fd_offset & ~PAGE_MASK) != 0 &&
    107. 

  107. 		    (jiffies-error_time) > 5*HZ)
    108. 

  108. 		{
    109. 

  109. 			printk(KERN_WARNING 
    110. 

  110. 			       "fd_offset is not page aligned. Please convert program: %s\n",
    111. 

  111. 			       bprm->file->f_dentry->d_name.name);
    112. 

  112. 			error_time = jiffies;
    113. 

  113. 		}
    114. 

    115. 

  115. 		if (!bprm->file->f_op->mmap||((fd_offset & ~PAGE_MASK) != 0)) {//如果没有mmap函数或者代码段及数据段的长度不与页面大小对齐
    116. 

  116. 			loff_t pos = fd_offset;
    117. 

  117. 			do_brk(N_TXTADDR(ex), ex.a_text+ex.a_data);//和上面的方式一样，正文段和数据段合在一起分配空间
    118. 

  118. 			bprm->file->f_op->read(bprm->file,(char *)N_TXTADDR(ex),
    119. 

  119. 					ex.a_text+ex.a_data, &pos);//然后就把这两部分从文件中读进来，这样就有了vm_struct结构，对应的页目录表项，页表项，页面，而且页面已经放入了文件中的代码段和数据段
    120. 

  120. 			flush_icache_range((unsigned long) N_TXTADDR(ex),
    121. 

  121. 					   (unsigned long) N_TXTADDR(ex) +
    122. 

  122. 					   ex.a_text+ex.a_data);
    123. 

  123. 			goto beyond_if;
    124. 

  124. 		}
    125. 

    126. 

  126. 		down(current->mm->mmap_sem);
    127. 

  127. 		error = do_mmap(bprm->file, N_TXTADDR(ex), ex.a_text,//如果有mmap,将文件的代码段映射到进程的用户空间
    128. 

  128. 			PROT_READ | PROT_EXEC,
    129. 

  129. 			MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE | MAP_EXECUTABLE,
    130. 

  130. 			fd_offset);
    131. 

  131. 		up(current->mm->mmap_sem);
    132. 

    133. 

  133. 		if (error != N_TXTADDR(ex)) {
    134. 

  134. 			send_sig(SIGKILL, current, 0);
    135. 

  135. 			return error;
    136. 

  136. 		}
    137. 

    138. 

  138. 		down(current->mm->mmap_sem);
    139. 

  139.  		error = do_mmap(bprm->file, N_DATADDR(ex), ex.a_data,///如果有mmap,将文件的数据段映射到进程的用户空间
    140. 

  140. 				PROT_READ | PROT_WRITE | PROT_EXEC,
    141. 

  141. 				MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE | MAP_EXECUTABLE,
    142. 

  142. 				fd_offset + ex.a_text);//数据段在文件中的偏移是fd_offset + ex.a_text
    143. 

  143. 		up(current->mm->mmap_sem);
    144. 

  144. 		if (error != N_DATADDR(ex)) {
    145. 

  145. 			send_sig(SIGKILL, current, 0);
    146. 

  146. 			return error;
    147. 

  147. 		}
    148. 

  148. 	}
    149. 

  149. beyond_if:
    150. 

  150. 	set_binfmt(&aout_format);//current->binfmt = aout_format;
    151. 

    152. 

  152. 	set_brk(current->mm->start_brk, current->mm->brk);//为可执行文件的bss段分配空间并建立起页面映射
    153. 

    154. 

  154. 	retval = setup_arg_pages(bprm); //在用户空间的堆栈区顶部为进程建立起一个虚拟区间，并将执行参数以及环境变量所占的物理页面与此虚拟区间建立起映射
    155. 

  155. 	if (retval < 0) { 
    156. 

  156. 		/* Someone check-me: is this error path enough? */ 
    157. 

  157. 		send_sig(SIGKILL, current, 0); 
    158. 

  158. 		return retval;
    159. 

  159. 	}
    160. 

    161. 

  161. 	current->mm->start_stack =
    162. 

  162. 		(unsigned long) create_aout_tables((char *) bprm->p, bprm);//把一些变量放入用户堆栈中，返回的是STACK_TOP减去图中参数所占空间，也就是堆栈开始的虚拟地址
    163. 

  163. #ifdef __alpha__
    164. 

  164. 	regs->gp = ex.a_gpvalue;
    165. 

  165. #endif
    166. 

  166.                        //起始地址  ,栈指针
    167. 

  167. 	start_thread(regs, ex.a_entry, current->mm->start_stack);//设置系统堆栈中的eip，esp
    168. 

  168. 	if (current->ptrace & PT_PTRACED)
    169. 

  169. 		send_sig(SIGTRAP, current, 0);
    170. 

  170. 	return 0;
    171. 

  171. }
    172.

复制信号处理函数指针数组,放弃用户空间或者不跟父进程共享内存空间,如果此进程实际为一个线程组的线程,那就从线程组中脱离,改变信号处理模式为默认处理,关闭file文件对象

    

  1. int flush_old_exec(struct linux_binprm * bprm)
    2. 

  2. {
    3. 

  3. 	char * name;
    4. 

  4. 	int i, ch, retval;
    5. 

  5. 	struct signal_struct * oldsig;
    6. 

    7. 

  7. 	/*
    8. 

  8. 	 * Make sure we have a private signal table
    9. 

  9. 	 */
    10. 

  10. 	oldsig = current->sig;//获取当前进程信号处理函数
    11. 

  11. 	retval = make_private_signals();//如果子进程通过指针来共享父进程的信号处理表，就要把它复制过来
    12. 

  12. 	if (retval) goto flush_failed;
    13. 

    14. 

  14. 	/* 
    15. 

  15. 	 * Release all of the old mmap stuff
    16. 

  16. 	 */
    17. 

  17. 	retval = exec_mmap();//从父进程继承下来的用户空间就是在这里放弃的
    18. 

  18. 	if (retval) goto mmap_failed;
    19. 

    20. 

  20. 	/* This is the point of no return */
    21. 

  21. 	release_old_signals(oldsig);//如果子进程通过指针来共享父进程的信号处理表，那么就要减少oldsig->count的计数
    22. 

    23. 

  23. 	current->sas_ss_sp = current->sas_ss_size = 0;
    24. 

    25. 

  25. 	if (current->euid == current->uid && current->egid == current->gid)
    26. 

  26. 		current->dumpable = 1;
    27. 

  27. 	name = bprm->filename;
    28. 

  28. 	for (i=0; (ch = *(name++)) != ‘\0‘;) {
    29. 

  29. 		if (ch == ‘/‘)
    30. 

  30. 			i = 0;
    31. 

  31. 		else
    32. 

  32. 			if (i < 15)
    33. 

  33. 				current->comm[i++] = ch;
    34. 

  34. 	}
    35. 

  35. 	current->comm[i] = ‘\0‘;//comm[]，用于保存进程所执行的程序名，所以还要把bprm->filename的目标程序路径名的最后一段抄过去
    36. 

    37. 

  37. 	flush_thread();//不用关心
    38. 

    39. 

  39. 	de_thread(current);//如果当前进程是一个线程,从线程组中脱离出来
    40. 

    41. 

  41. 	if (bprm->e_uid != current->euid || bprm->e_gid != current->egid || 
    42. 

  42. 	    permission(bprm->file->f_dentry->d_inode,MAY_READ))
    43. 

  43. 		current->dumpable = 0;
    44. 

    45. 

  45. 	/* An exec changes our domain. We are no longer part of the thread
    46. 

  46. 	   group */
    47. 

  47. 	   
    48. 

  48. 	current->self_exec_id++;
    49. 

  49. 			
    50. 

  50. 	flush_signal_handlers(current);//原来指向用户空间子程序的，现在设为SIG_DEL，表示采取预设的响应方式
    51. 

  51. 	flush_old_files(current->files);//对原有已打开文件的处理
    52. 

    53. 

  53. 	return 0;
    54. 

    55. 

  55. mmap_failed:
    56. 

  56. flush_failed:
    57. 

  57. 	spin_lock_irq(current->sigmask_lock);
    58. 

  58. 	if (current->sig != oldsig)
    59. 

  59. 		kfree(current->sig);
    60. 

  60. 	current->sig = oldsig;
    61. 

  61. 	spin_unlock_irq(current->sigmask_lock);
    62. 

  62. 	return retval;
    63. 

  63. }
    64.

flush_old_exec中的make_private_signal

    

  1. static inline int make_private_signals(void)
    2. 

  2. {
    3. 

  3. 	struct signal_struct * newsig;
    4. 

    5. 

  5. 	if (atomic_read(current->sig->count) <= 1)//如果只是把父进程的信号处理表指针复制过来，而通过这指针来共享父进程的信号处理表，那么current->sig->count大于1
    6. 

  6. 		return 0;
    7. 

  7. 	newsig = kmem_cache_alloc(sigact_cachep, GFP_KERNEL);//自立门户，和copy_sighand()基本相同
    8. 

  8. 	if (newsig == NULL)
    9. 

  9. 		return -ENOMEM;
    10. 

  10. 	spin_lock_init(&newsig->siglock);
    11. 

  11. 	atomic_set(&newsig->count, 1);
    12. 

  12. 	memcpy(newsig->action, current->sig->action, sizeof(newsig->action));//拷贝
    13. 

  13. 	spin_lock_irq(current->sigmask_lock);
    14. 

  14. 	current->sig = newsig;//获得新的
    15. 

  15. 	spin_unlock_irq(current->sigmask_lock);
    16. 

  16. 	return 0;
    17. 

  17. }
    18.

flush_old_exec的exec_mmap函数

    

    2. 

  2. static int exec_mmap(void)
    3. 

  3. {
    4. 

  4. 	struct mm_struct * mm, * old_mm;
    5. 

    6. 

  6. 	old_mm = current->mm;
    7. 

  7. 	if (old_mm && atomic_read(&old_mm->mm_users) == 1) {//如果共享计数为1时，表明对此空间的使用是独占的，也就是说这是从父进程复制过来的
    8. 

  8. 		flush_cache_mm(old_mm);//释放缓存
    9. 

  9. 		mm_release();//针对vfork.父进程减少信号量休眠,以后让子进程up将其唤醒
    10. 

  10. 		exit_mmap(old_mm);//释放mm_struct数据结构以下的所有vm_area_struct数据结构(但是不包括mm_struct结构本身),并将页面表项设置为0
    11. 

  11. 		flush_tlb_mm(old_mm);//释放tlb的缓存
    12. 

  12. 		return 0;
    13. 

  13. 	}
    14. 

    15. 

  15. 	mm = mm_alloc();//如果只是将指向mm_struct数据结构的指针复制给子进程，让子进程通过这个指针来共享父进程的用户空间，那就可以跳过释放用户空间这一步，直接就为子进程分配新的用户空间
    16. 

  16. 	if (mm) {
    17. 

  17. 		struct mm_struct *active_mm = current->active_mm;//
    18. 

    19. 

  19. 		if (init_new_context(current, mm)) {//空语句
    20. 

  20. 			mmdrop(mm);
    21. 

  21. 			return -ENOMEM;
    22. 

  22. 		}
    23. 

    24. 

  24. 		/* Add it to the list of mm‘s */
    25. 

  25. 		spin_lock(&mmlist_lock);
    26. 

  26. 		list_add(&mm->mmlist, &init_mm.mmlist);
    27. 

  27. 		spin_unlock(&mmlist_lock);
    28. 

    29. 

  29. 		task_lock(current);
    30. 

  30. 		current->mm = mm;//新分配空户空间初始化
    31. 

  31. 		current->active_mm = mm;//新分配的空户空间
    32. 

  32. 		task_unlock(current);
    33. 

  33. 		activate_mm(active_mm, mm);//切换到新的的用户空间
    34. 

  34. 		mm_release();//将父进程唤醒
    35. 

  35. 		if (old_mm) {
    36. 

  36. 			if (active_mm != old_mm) BUG();//如果不一致,说明线程成为了进程
    37. 

  37. 			mmput(old_mm);//减少mm->mm_users计数，因为已经不共享了
    38. 

  38. 			return 0;
    39. 

  39. 		}
    40. 

  40. 		mmdrop(active_mm);//如果已经没有进程使用这空间.将旧的空间给释放掉
    41. 

  41. 		return 0;
    42. 

  42. 	}
    43. 

  43. 	return -ENOMEM;
    44. 

  44. }
    45.

根据close_on_exec位图，里面存储着表示哪些文件在执行一个新目标程序时应予关闭的信息。根据这个位图的指示将这些文件关闭，并且将此位图清成全0。

    

  1. static inline void flush_old_files(struct files_struct * files)
    2. 

  2. {
    3. 

  3. 	long j = -1;
    4. 

    5. 

  5. 	write_lock(&files->file_lock);
    6. 

  6. 	for (;;) {
    7. 

  7. 		unsigned long set, i;
    8. 

    9. 

  9. 		j++;
    10. 

  10. 		i = j * __NFDBITS;
    11. 

  11. 		if (i >= files->max_fds || i >= files->max_fdset)
    12. 

  12. 			break;
    13. 

  13. 		set = files->close_on_exec->fds_bits[j];
    14. 

  14. 		if (!set)
    15. 

  15. 			continue;
    16. 

  16. 		files->close_on_exec->fds_bits[j] = 0;
    17. 

  17. 		write_unlock(&files->file_lock);
    18. 

  18. 		for ( ; set ; i++,set >>= 1) {
    19. 

  19. 			if (set & 1) {
    20. 

  20. 				sys_close(i);
    21. 

  21. 			}
    22. 

  22. 		}
    23. 

  23. 		write_lock(&files->file_lock);
    24. 

    25. 

  25. 	}
    26. 

  26. 	write_unlock(&files->file_lock);
    27. 

  27. }
    28. 



    

    2. 

  2. void mmput(struct mm_struct *mm)
    3. 

  3. {
    4. 

  4. 	if (atomic_dec_and_lock(&mm->mm_users, &mmlist_lock)) {//减去1,是否为0
    5. 

  5. 		list_del(&mm->mmlist);
    6. 

  6. 		spin_unlock(&mmlist_lock);
    7. 

  7. 		exit_mmap(mm);//将页表设置为0
    8. 

  8. 		mmdrop(mm);//将页表项与页表,本身mm_struct全部释放
    9. 

  9. 	}
    10. 

  10. }
    11. 



    

  1. int setup_arg_pages(struct linux_binprm *bprm)
    2. 

  2. {
    3. 

  3. 	unsigned long stack_base;
    4. 

  4. 	struct vm_area_struct *mpnt;
    5. 

  5. 	int i;
    6. 

    7. 

    8. 

  8. 	stack_base = STACK_TOP - MAX_ARG_PAGES*PAGE_SIZE;//STACK_TOP为3GB
    9. 

    10. 

    11. 

  11. 	bprm->p += stack_base;//bprm->p原来是MAX_ARG_PAGES*PAGE_SIZE-参数的数量，现在加上STACK_TOP - MAX_ARG_PAGES*PAGE_SIZE，最后是STACK_TOP - 参数的数量
    12. 

  12. 	if (bprm->loader)
    13. 

  13. 		bprm->loader += stack_base;
    14. 

  14. 	bprm->exec += stack_base;
    15. 

    16. 

    17. 

  17. 	mpnt = kmem_cache_alloc(vm_area_cachep, SLAB_KERNEL);//从slab中获取一页
    18. 

  18. 	if (!mpnt) 
    19. 

  19. 		return -ENOMEM; 
    20. 

  20. 	
    21. 

  21. 	down(¤t->mm->mmap_sem);
    22. 

  22. 	{
    23. 

  23. 		mpnt->vm_mm = current->mm;//内存描述符
    24. 

  24. 		mpnt->vm_start = PAGE_MASK & (unsigned long) bprm->p;//堆栈段开始地址
    25. 

  25. 		mpnt->vm_end = STACK_TOP;//堆栈段结束地址
    26. 

  26. 		mpnt->vm_page_prot = PAGE_COPY;
    27. 

  27. 		mpnt->vm_flags = VM_STACK_FLAGS;
    28. 

  28. 		mpnt->vm_ops = NULL;
    29. 

  29. 		mpnt->vm_pgoff = 0;
    30. 

  30. 		mpnt->vm_file = NULL;
    31. 

  31. 		mpnt->vm_private_data = (void *) 0;
    32. 

  32. 		insert_vm_struct(current->mm, mpnt);//插入
    33. 

  33. 		current->mm->total_vm = (mpnt->vm_end - mpnt->vm_start) >> PAGE_SHIFT;
    34. 

  34. 	} 
    35. 

    36. 

    37. 

  37. 	for (i = 0 ; i < MAX_ARG_PAGES ; i++) {
    38. 

  38. 		struct page *page = bprm->page[i];//从page[0]开始
    39. 

  39. 		if (page) {
    40. 

  40. 			bprm->page[i] = NULL;
    41. 

  41. 			current->mm->rss++;
    42. 

  42. 			put_dirty_page(current,page,stack_base);//建立从堆栈虚拟空间到页面之前的映射
    43. 

  43. 		}
    44. 

  44. 		stack_base += PAGE_SIZE;//加一个页面的长度，4096个字节
    45. 

  45. 	}
    46. 

  46. 	up(&current->mm->mmap_sem);
    47. 

  47. 	
    48. 

  48. 	return 0;
    49. 

  49. }
    50. 



    

    2. 

  2. static unsigned long * create_aout_tables(char * p, struct linux_binprm * bprm)
    3. 

  3. {
    4. 

  4. 	char **argv, **envp;
    5. 

  5. 	unsigned long * sp;
    6. 

  6. 	int argc = bprm->argc;//程序参数个数
    7. 

  7. 	int envc = bprm->envc;//环境字符串个数
    8. 

  8. //sp指向当前堆栈页面的栈顶指针
    9. 

  9. sp = (unsigned long *) ((-(unsigned long)sizeof(char *)) & (unsigned long) p);
    10. 

  10. #ifdef __sparc__
    11. 

  11. 	/* This imposes the proper stack alignment for a new process. */
    12. 

  12. 	sp = (unsigned long *) (((unsigned long) sp) & ~7);
    13. 

  13. 	if ((envc+argc+3)&1) --sp;
    14. 

  14. #endif
    15. 

  15. #ifdef __alpha__
    16. 

  16. /* whee.. test-programs are so much fun. */
    17. 

  17. 	put_user(0, --sp);
    18. 

  18. 	put_user(0, --sp);
    19. 

  19. 	if (bprm->loader) {
    20. 

  20. 		put_user(0, --sp);
    21. 

  21. 		put_user(0x3eb, --sp);
    22. 

  22. 		put_user(bprm->loader, --sp);
    23. 

  23. 		put_user(0x3ea, --sp);
    24. 

  24. 	}
    25. 

  25. 	put_user(bprm->exec, --sp);
    26. 

  26. 	put_user(0x3e9, --sp);
    27. 

  27. #endif
    28. 

  28. //sp减去envc+1作为环境字符串指针数组的起始地址,最后一个数组元素为0
    29. 

  29. 	sp -= envc+1;
    30. 

  30. 	envp = (char **) sp;//指向环境字符串数组的起始地址
    31. 

  31. 	sp -= argc+1;//同上
    32. 

  32. 	argv = (char **) sp;
    33. 

  33. #if defined(__i386__) || defined(__mc68000__) || defined(__arm__)
    34. 

  34. //栈顶sp继续向低地址放扩展,存放envp,argv,argc
    35. 

  35. 	put_user((unsigned long) envp,--sp);
    36. 

  36. 	put_user((unsigned long) argv,--sp);
    37. 

  37. #endif
    38. 

  38. 	put_user(argc,--sp);
    39. 

  39. 	current->mm->arg_start = (unsigned long) p;
    40. 

  40. //循环对堆栈中的环境字符串指针数组初始化
    41. 

  41. 	while (argc-->0) {
    42. 

  42. 		char c;
    43. 

  43. 		put_user(p,argv++);
    44. 

  44. 		do {
    45. 

  45. 			get_user(c,p++);
    46. 

  46. 		} while (c);
    47. 

  47. 	}
    48. 

  48. 	put_user(NULL,argv);
    49. 

  49. 	current->mm->arg_end = current->mm->env_start = (unsigned long) p;//env_start和arg_end
    50. 

  50. 	while (envc-->0) {
    51. 

  51. 		char c;
    52. 

  52. 		put_user(p,envp++);
    53. 

  53. 		do {
    54. 

  54. 			get_user(c,p++);
    55. 

  55. 		} while (c);
    56. 

  56. 	}
    57. 

  57. 	put_user(NULL,envp);
    58. 

  58. 	current->mm->env_end = (unsigned long) p;//env_end
    59. 

  59. 	return sp;//返回的是STACK_TOP减去图中参数所占空间
    60. 

  60. }
    61.

来自为知笔记(Wiz)

时间： 2024-11-12 14:59:54

linux内核情景分析之execve()的相关文章

Linux内核情景分析的alloc_pages

NUMA结构的alloc_pages ==================== mm/numa.c 43 43 ==================== 43 #ifdef CONFIG_DISCONTIGMEM ==================== mm/numa.c 91 128 ==================== 91 /* 92 * This can be refined. Currently, tries to do round robin, instead 93 * sho

Linux内核情景分析之异常访问,用户堆栈的扩展

情景假设: 在堆内存中申请了一块内存,然后释放掉该内存,然后再去访问这块内存.也就是所说的野指针访问. 当cpu产生页面错误时,会把失败的线性地址放在cr2寄存器.线性地址缺页异常的4种情况 1.如果cpu访问的行现地址在内核态,那么很可能访问的是非连续区,需要vmalloc_fault处理. 2.缺页异常发生在中断或者内核线程时,直接失败,因为不可修改页表 3.地址在一个区间内,那就可能是已经物理地址映射了但权限问题(错误处理)或者其物理地址没有分配(分配物理内存) 4.如果找到一个在线性地址

linux内核情景分析之exit与Wait

//第一层系统调用 asmlinkage long sys_exit(int error_code) { do_exit((error_code&0xff)<<8); } 其主体是do_exit,接下来我们来看看do_exit的实现 NORET_TYPE void do_exit(long code) { struct task_struct *tsk = current;//获取当前进程描述符 if (in_interrupt())//禁止中断时调用do_exit panic(&qu

linux内核情景分析之强制性调度

从系统调用返回到用户空间是否调度,从ret_with_reschedule可看出,是否真正调度,取决于当前进程的pcb中的need_resched是否设置为1,那如何设置为1取决于以下几种情况: 时间中断处理程序,发现当前进程运行时间过长:每次发生时间中断,都要递减该进程的时间片,一旦count为0,强制调度,剥夺当前进程运行 void update_process_times(int user_tick) { struct task_struct *p = current; int cpu =

Linux源代码情景分析读书笔记 物理页面的分配

函数 alloc_pages流程图 Linux源代码情景分析读书笔记 物理页面的分配,布布扣,bubuko.com

linux 内核源代码分析 - 获取数组的大小

#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) 測试程序: #include<stdio.h> #include<stdlib.h> struct dev { int a; char b; float c; }; struct dev devs[]= { { 1,'a',7.0, }, { 1,'a',7.0, }, { 1,'a',7.0, }, }; int main() { printf("int is %d \

Linux内核源代码分析方法

Linux内核源代码分析方法   一.内核源代码之我见 Linux内核代码的庞大令不少人"望而生畏",也正由于如此,使得人们对Linux的了解仅处于泛泛的层次.假设想透析Linux,深入操作系统的本质,阅读内核源代码是最有效的途径.我们都知道,想成为优秀的程序猿,须要大量的实践和代码的编写.编程固然重要,可是往往仅仅编程的人非常easy把自己局限在自己的知识领域内.假设要扩展自己知识的广度,我们须要多接触其它人编写的代码,尤其是水平比我们更高的人编写的代码.通过这样的途径,我们能够跳出

Linux内核Crash分析

转载自:http://linux.cn/article-3475-1.html 在工作中经常会遇到一些内核crash的情况,本文就是根据内核出现crash后的打印信息,对其进行了分析,使用的内核版本为:Linux2.6.32. 每一个进程的生命周期内,其生命周期的范围为几毫秒到几个月.一般都是和内核有交互,例如用户空间程序使用系统调用进入内核空间.这时使用的不再是用户空 间的栈空间,使用对应的内核栈空间.对每一个进程来说,Linux内核都会把两个不同的数据结构紧凑的存放在一个单独为进程分配的存储

linux内核与分析 心得与体会

作业目录: (1)计算机是如何工作的:http://www.cnblogs.com/20135335hs/p/5213394.html (2)操作系统是如何工作的:http://www.cnblogs.com/20135335hs/p/5248078.html (3)Linux系统启动过程:http://www.cnblogs.com/20135335hs/p/5271708.html (4)系统调用的方法:http://www.cnblogs.com/20135335hs/p/5297310.