思享工具箱

insmod过程详解【转】

摘要：
R=blog/article&uid=27717694&id=3971861 I.前言：对于一些当前编译的模块，当系统上需要insmod时，可能会报告各种错误。

转自：http://blog.csdn.net/chrovery/article/details/51088425

  1. 转自http://blog.chinaunix.net/xmlrpc.php?r=blog/article&uid=27717694&id=3971861
  3. 一、前言
  4. 对于现在编译的一些module要insmod在系统上时，可能会报各种各样的错误。这些错误仔细研读内核源码，都能找出原因。2.6 内核以前的insmod部分主要依赖于modutils源码包，在用户层基本将工作完成，加载过程参考前一篇文章。2.6 内核以后的做法是将大部分的原来用户级操作纳入内核中来处理，无论是逻辑上还是代码量上都比原来减少了许多，通过busybox中的insmod命令与内核接入。把这套源代码弄明白，就不会出现加载模块时出现的各种各样的错误，可以写一些patch代码，修正这些内核要检查的项，比如vermagic和crc等等。

  6. 二、相关结构

  8. 1.模块依赖关系
  9. struct module_use{
  10. struct list_head source_list;
  11. struct list_head target_list;
  12. struct module*source,*target;
  13. };

  15. 2.模块状态
  16. enum module_state{
  17. MODULE_STATE_LIVE,/*Normal state.*/
  18. MODULE_STATE_COMING,/*Full formed,running module_init.*/
  19. MODULE_STATE_GOING,/*Going away.*/
  20. MODULE_STATE_UNFORMED,/*Still setting it up.*/
  21. };

  23. 3.模块计数
  24. struct module_ref{
  25. unsigned long incs;
  26. unsigned long decs;
  27. }__attribute((aligned(2*sizeof(unsigned long))));

  29. 4.模块结构
  30. struct module
  31. {
  32. enum module_state state;
  33. /*Member of list of modules*/
  34. struct list_head list;
  35. /*Unique handleforthis module*/
  36. char name[MODULE_NAME_LEN];
  37. /*Sysfs stuff.*/
  38. struct module_kobject mkobj;
  39. struct module_attribute*modinfo_attrs;
  40. constchar*version;
  41. constchar*srcversion;
  42. struct kobject*holders_dir;
  43. /*Exported symbols*/
  44. conststruct kernel_symbol*syms;
  45. constunsigned long*crcs;
  46. unsignedintnum_syms;
  47. /*Kernel parameters.*/
  48. struct kernel_param*kp;
  49. unsignedintnum_kp;
  50. /*GPL-only exported symbols.*/
  51. unsignedintnum_gpl_syms;
  52. conststruct kernel_symbol*gpl_syms;
  53. constunsigned long*gpl_crcs;

  55. #ifdef CONFIG_UNUSED_SYMBOLS
  56. /*unused exported symbols.*/
  57. conststruct kernel_symbol*unused_syms;
  58. constunsigned long*unused_crcs;
  59. unsignedintnum_unused_syms;
  60. /*GPL-only,unused exported symbols.*/
  61. unsignedintnum_unused_gpl_syms;
  62. conststruct kernel_symbol*unused_gpl_syms;
  63. constunsigned long*unused_gpl_crcs;
  64. #endif

  66. #ifdef CONFIG_MODULE_SIG
  67. /*Signature was verified.*/
  68. bool sig_ok;
  69. #endif

  71. /*symbols that will be GPL-onlyinthe near future.*/
  72. conststruct kernel_symbol*gpl_future_syms;
  73. constunsigned long*gpl_future_crcs;
  74. unsignedintnum_gpl_future_syms;

  76. /*Exception table*/
  77. unsignedintnum_exentries;
  78. struct exception_table_entry*extable;

  80. /*Startupfunction.*/
  81. int(*init)(void);

  83. /*Ifthisisnon-NULL,vfree after init()returns*/
  84. void*module_init;

  86. /*Hereisthe actual code+data,vfree'donunload.*/
  87. void*module_core;

  89. /*Here are the sizes of the initandcore sections*/
  90. unsignedintinit_size,core_size;

  92. /*The size of the executable codeineachsection.*/
  93. unsignedintinit_text_size,core_text_size;

  95. /*Size of RO sections of the module(text+rodata)*/
  96. unsignedintinit_ro_size,core_ro_size;

  98. /*Arch-specific module values*/
  99. struct mod_arch_specific arch;

  101. unsignedinttaints;/*same bits as kernel:tainted*/

  103. #ifdef CONFIG_GENERIC_BUG
  104. /*SupportforBUG*/
  105. unsigned num_bugs;
  106. struct list_head bug_list;
  107. struct bug_entry*bug_table;
  108. #endif

  110. #ifdef CONFIG_KALLSYMS
  111. Elf_Sym*symtab,*core_symtab;
  112. unsignedintnum_symtab,core_num_syms;
  113. char*strtab,*core_strtab;

  115. /*Section attributes*/
  116. struct module_sect_attrs*sect_attrs;

  118. /*Notes attributes*/
  119. struct module_notes_attrs*notes_attrs;
  120. #endif

  122. char*args;

  124. #ifdef CONFIG_SMP
  125. /*Per-cpu data.*/
  126. void __percpu*percpu;
  127. unsignedintpercpu_size;
  128. #endif

  130. #ifdef CONFIG_TRACEPOINTS
  131. unsignedintnum_tracepoints;
  132. struct tracepoint*const*tracepoints_ptrs;
  133. #endif

  135. #ifdef HAVE_JUMP_LABEL
  136. struct jump_entry*jump_entries;
  137. unsignedintnum_jump_entries;
  138. #endif

  140. #ifdef CONFIG_TRACING
  141. unsignedintnum_trace_bprintk_fmt;
  142. constchar**trace_bprintk_fmt_start;
  143. #endif

  145. #ifdef CONFIG_EVENT_TRACING
  146. struct ftrace_event_call**trace_events;
  147. unsignedintnum_trace_events;
  148. #endif

  150. #ifdef CONFIG_FTRACE_MCOUNT_RECORD
  151. unsignedintnum_ftrace_callsites;
  152. unsigned long*ftrace_callsites;
  153. #endif

  155. #ifdef CONFIG_MODULE_UNLOAD
  156. /*What modules dependonme?*/
  157. struct list_head source_list;
  158. /*What modulesdoI dependon?*/
  159. struct list_head target_list;

  161. /*Whoiswaitingforustobe unloaded*/
  162. struct task_struct*waiter;

  164. /*Destructionfunction.*/
  165. void(*exit)(void);
  166. struct module_ref __percpu*refptr;
  167. #endif

  169. #ifdef CONFIG_CONSTRUCTORS
  170. /*Constructor functions.*/
  171. ctor_fn_t*ctors;
  172. unsignedintnum_ctors;
  173. #endif
  174. };

  176. 5.ELF文件信息结构
  177. struct load_info{
  178. Elf_Ehdr*hdr;//指向elf头
  179. unsigned longlen;
  180. Elf_Shdr*sechdrs;//指向节区头
  181. char*secstrings;//指向字符串节区中节区名称所在的地址
  182. char*strtab;//指向字符串节区的内容所在地址
  183. unsigned long symoffs;
  184. unsigned long stroffs;
  185. struct _ddebug*debug;
  186. unsignedintnum_debug;
  187. bool sig_ok;//模块签名检查
  188. struct{
  189. unsignedintsym;//模块的符号表节区索引号
  190. unsignedintstr;//模块的字符串节区索引号
  191. unsignedintmod;//模块的".gnu.linkonce.this_module"节区索引号
  192. unsignedintvers;//模块的"__versions"节区索引号
  193. unsignedintinfo;//模块的.modinfo节区索引号
  194. unsignedintpcpu;
  195. }index;
  196. };

  198. 三、源代码解析
  199. //busybox中insmod.c文件中
  200. intinsmod_main(intargc UNUSED_PARAM,char**argv)
  201. {
  202. char*filename;
  203. intrc;

  205. IF_FEATURE_2_4_MODULES(
  206. getopt32(argv,INSMOD_OPTS INSMOD_ARGS);
  207. argv+=optind-1;
  208. );

  210. //取得要加载模块的路径名
  211. filename=*++argv;
  212. if(!filename)
  213. bb_show_usage();

  215. rc=bb_init_module(filename,parse_cmdline_module_options(argv,0));
  216. if(rc)
  217. bb_error_msg("can't insert '%s': %s",filename,moderror(rc));

  219. return rc;
  220. }

  222. char*FAST_FUNC parse_cmdline_module_options(char**argv,intquote_spaces)
  223. {
  224. char*options;
  225. intoptlen;

  227. options=xzalloc(1);
  228. optlen=0;

  230. //遍历模块名后边的模块参数
  231. while(*++argv){
  232. constchar*fmt;
  233. constchar*var;
  234. constchar*val;

  236. var=*argv;
  237. //为options分配空间
  238. options=xrealloc(options,optlen+2+strlen(var)+2);
  239. fmt="%.*s%s ";
  240. //若'='存在于var中，则返回'='在var中出现的第一个位置的指针，否则返回字符串var末尾的空字符。
  241. val=strchrnul(var,'=');
  242. if(quote_spaces){//为0
  243. if(*val){/*has var=val format.skip'='*/
  244. val++;
  245. if(strchr(val,''))
  246. fmt="%.*s"%s" ";
  247. }
  248. }
  249. //模块参数按格式存入options，"%.*s%s "中“*”对应(int)(val-var)，第一个s对应var，表示在var字符串中去除(int)(val-var)个字符显示，即=前边的字符被去除。实际上只是将val字符串(即=后边的字符串)存入options指针指向的地址。
  250. optlen+=sprintf(options+optlen,fmt,(int)(val-var),var,val);
  251. }

  253. return options;
  254. }

  256. intFAST_FUNC bb_init_module(constchar*filename,constchar*options)
  257. {
  258. size_t image_size;
  259. char*image;
  260. intrc;
  261. bool mmaped;

  263. if(!options)
  264. options="";

  266. //若是2.6以前的版本调用bb_init_module_24()，这种处理就是以前modutils对模块的加载处理。这里要研究的是2.6以后的模块加载处理
  267. #ifENABLE_FEATURE_2_4_MODULES
  268. if(get_linux_version_code()<KERNEL_VERSION(2,6,0))
  269. return bb_init_module_24(filename,options);
  270. #endif

  272. image_size=INT_MAX-4095;//初始化为文件的最大值
  273. mmaped=0;

  275. //把模块文件映射进内存，并返回映射空间的大小image_size
  276. image=try_to_mmap_module(filename,&image_size);
  277. if(image){
  278. mmaped=1;
  279. }else{
  280. errno=ENOMEM;/*may be changed by e.g.open errors below*/
  281. image=xmalloc_open_zipped_read_close(filename,&image_size);
  282. if(!image)
  283. return-errno;
  284. }
  285. errno=0;

  287. //系统调用,对应内核函数是sys_init_module()函数，进入到内核空间
  288. init_module(image,image_size,options);
  289. rc=errno;
  290. if(mmaped)
  291. munmap(image,image_size);
  292. else
  293. free(image);
  294. return rc;
  295. }

  297. void*FAST_FUNC try_to_mmap_module(constchar*filename,size_t*image_size_p)
  298. {
  299. void*image;
  300. struct stat st;
  301. intfd;

  303. //打开模块.ko文件，获得文件描述符
  304. fd=xopen(filename,O_RDONLY);
  305. //由文件描述符取得文件状态
  306. fstat(fd,&st);
  307. image=NULL;

  309. //文件的size是否超过设定的文件最大值
  310. if(st.st_size<=*image_size_p){
  311. size_t image_size=st.st_size;//文件size
  312. //以只读的方式将.ko文件映射到内存中，返回在内存中的起始地址
  313. image=mmap(NULL,image_size,PROT_READ,MAP_PRIVATE,fd,0);
  314. if(image==MAP_FAILED){
  315. image=NULL;
  316. }
  317. //检查一下.ko文件的开头是否为ELF标准格式
  318. elseif(*(uint32_t*)image!=SWAP_BE32(0x7f454C46)){
  319. munmap(image,image_size);
  320. image=NULL;
  321. }else{
  322. *image_size_p=image_size;//返回文件size
  323. }
  324. }
  325. close(fd);
  326. return image;
  327. }

  329. //sys_init_module(void __user*umod,unsigned longlen,constchar __user*uargs)
  330. //umod:是一个指针，指向用户地址空间中的区域，模块的二进制代码位于其中。
  331. //len:该区域的长度。
  332. //uargs:是一个指针，指定了模块的参数。
  333. SYSCALL_DEFINE3(init_module,void __user*,umod,unsigned long,len,constchar __user*,uargs)
  334. {
  335. interr;
  336. struct load_info info={};

  338. //是否有权限加载模块：capable(CAP_SYS_MODULE)
  339. err=may_init_module();
  340. if(err)
  341. returnerr;

  343. pr_debug("init_module: umod=%p, len=%lu, uargs=%p ",umod,len,uargs);

  345. //将用户空间的.ko文件的内存映像(elf格式)拷贝到内核空间，并填充info结构中
  346. err=copy_module_from_user(umod,len,&info);
  347. if(err)
  348. returnerr;

  350. //模块的主要操作
  351. return load_module(&info,uargs,0);
  352. }

  354. staticintcopy_module_from_user(constvoid __user*umod,unsigned longlen,struct load_info*info)
  355. {
  356. interr;

  358. //模块文件映射到用户空间的size(即.ko文件本身的size)
  359. info->len=len;
  360. if(info->len<sizeof(*(info->hdr)))
  361. return-ENOEXEC;

  363. err=security_kernel_module_from_file(NULL);
  364. if(err)
  365. returnerr;

  367. //在内核空间为模块分配内存，并将该内存的起始地址付给成员hdr，即该成员现在指向的是整个模块内存
  368. info->hdr=vmalloc(info->len);
  369. if(!info->hdr)
  370. return-ENOMEM;

  372. //将用户空间的.ko文件的内存映像(elf格式)拷贝到内核空间info->hdr处
  373. if(copy_from_user(info->hdr,umod,info->len)!=0){
  374. vfree(info->hdr);
  375. return-EFAULT;
  376. }
  377. return 0;
  378. }

  380. staticintload_module(struct load_info*info,constchar __user*uargs,intflags)
  381. {
  382. struct module*mod;
  383. longerr;

  385. err=module_sig_check(info);//检查证书
  386. if(err)
  387. goto free_copy;
  388. err=elf_header_check(info);//检查elf头
  389. if(err)
  390. goto free_copy;

  392. //布置模块，并分配相关的内存，把相关节区复制到最终镜像中
  393. mod=layout_and_allocate(info,flags);
  394. if(IS_ERR(mod)){
  395. err=PTR_ERR(mod);
  396. goto free_copy;
  397. }

  399. //因为前边已将模块镜像复制到了内核空间的内存中，module对象也指向对应的位置，然后将此module对象添加到modules链表中
  400. err=add_unformed_module(mod);
  401. if(err)
  402. goto free_module;

  404. #ifdef CONFIG_MODULE_SIG
  405. mod->sig_ok=info->sig_ok;
  406. if(!mod->sig_ok){
  407. printk_once(KERN_NOTICE
  408. "%s: module verification failed: signature and/or"
  409. " required key missing - tainting kernel ",mod->name);
  410. add_taint_module(mod,TAINT_FORCED_MODULE,LOCKDEP_STILL_OK);
  411. }
  412. #endif

  414. //为节区pcpu分配空间，用于多处理器，此处不考虑
  415. err=percpu_modalloc(mod,info);
  416. if(err)
  417. goto unlink_mod;

  419. //模块计数加1，并初始化模块链表
  420. err=module_unload_init(mod);
  421. if(err)
  422. goto unlink_mod;

  424. //找到其余节区地址，初始化module对象相关指针
  425. find_module_sections(mod,info);

  427. //检查license和version
  428. err=check_module_license_and_versions(mod);
  429. if(err)
  430. goto free_unload;

  432. //根据.modinfo段设置模块信息
  433. setup_modinfo(mod,info);

  435. //根据前边设置的模块在内核的起始地址，节区的起始地址已经更新，但是节区中符号的地址还未进行更新，这里根据节区的内存地址更新符号地址
  436. err=simplify_symbols(mod,info);
  437. if(err<0)
  438. goto free_modinfo;

  440. //对模块中的重定位节区做重定位操作
  441. err=apply_relocations(mod,info);
  442. if(err<0)
  443. goto free_modinfo;

  445. err=post_relocation(mod,info);
  446. if(err<0)
  447. goto free_modinfo;

  449. //Flush the instruction cache，no care
  450. flush_module_icache(mod);

  452. //把可选参数从用户空间复制到内核空间
  453. mod->args=strndup_user(uargs,~0UL>>1);
  454. if(IS_ERR(mod->args)){
  455. err=PTR_ERR(mod->args);
  456. goto free_arch_cleanup;
  457. }

  459. //处理用于debug节区
  460. dynamic_debug_setup(info->debug,info->num_debug);

  462. //确认是否有重定义符号，并且设置模块状态为正在运行
  463. err=complete_formation(mod,info);
  464. if(err)
  465. goto ddebug_cleanup;

  467. /*Moduleisreadytoexecute:parsing args maydothat.*/
  468. //分析参数是否有效
  469. err=parse_args(mod->name,mod->args,mod->kp,mod->num_kp,-32768,32767,unknown_module_param_cb);
  470. if(err<0)
  471. goto bug_cleanup;

  473. //sysfs文件系统相关,在sysfs中创建模块相应的项
  474. err=mod_sysfs_setup(mod,info,mod->kp,mod->num_kp);
  475. if(err<0)
  476. goto bug_cleanup;

  478. //释放临时模块镜像和其他临时辅助内存区
  479. free_copy(info);

  481. /**/
  482. trace_module_load(mod);

  484. //调用do_init_module开始运行模块
  485. return do_init_module(mod);

  487. bug_cleanup:
  488. /*module_bug_cleanup needs module_mutex protection*/
  489. mutex_lock(&module_mutex);
  490. module_bug_cleanup(mod);
  491. mutex_unlock(&module_mutex);
  492. ddebug_cleanup:
  493. dynamic_debug_remove(info->debug);
  494. synchronize_sched();
  495. kfree(mod->args);
  496. free_arch_cleanup:
  497. module_arch_cleanup(mod);
  498. free_modinfo:
  499. free_modinfo(mod);
  500. free_unload:
  501. module_unload_free(mod);
  502. unlink_mod:
  503. mutex_lock(&module_mutex);
  504. /*Unlink carefully:kallsyms could be walking list.*/
  505. list_del_rcu(&mod->list);
  506. wake_up_all(&module_wq);
  507. mutex_unlock(&module_mutex);
  508. free_module:
  509. module_deallocate(mod,info);
  510. free_copy:
  511. free_copy(info);
  512. returnerr;
  513. }

  515. staticintmodule_sig_check(struct load_info*info)
  516. {
  517. //#define MODULE_SIG_STRING"~Module signature appended~ "
  518. interr=-ENOKEY;
  519. constunsigned long markerlen=sizeof(MODULE_SIG_STRING)-1;
  520. constvoid*mod=info->hdr;
  521. //elf文件长度是否大于签名字符串长度，并且比较该elf格式的模块文件是否在文件末尾有signature string。若有的话则将该文件长度减去该字符串长度，并确认该签名是module类型。
  522. if(info->len>markerlen&&memcmp(mod+info->len-markerlen,MODULE_SIG_STRING,markerlen)==0)
  523. {
  524. info->len-=markerlen;//模块长度减去签名字符串的长度
  525. err=mod_verify_sig(mod,&info->len);//验证模块签名
  526. }
  527. if(!err){
  528. info->sig_ok=true;
  529. return 0;
  530. }

  532. /*Nothaving a signatureisonly anerrorifwe're strict.*/
  533. if(err<0&&fips_enabled)
  534. panic("Module verification failed with error %d in FIPS mode ",err);
  535. if(err==-ENOKEY&&!sig_enforce)
  536. err=0;
  537. returnerr;
  538. }

  540. struct module_signature{
  541. u8 algo;/*Public-key crypto algorithm[enum pkey_algo]*/
  542. u8 hash;/*Digest algorithm[enum pkey_hash_algo]*/
  543. u8 id_type;/*Key identifier type[enum pkey_id_type]*/
  544. u8 signer_len;/*Length of signer's name*/
  545. u8 key_id_len;/*Length of key identifier*/
  546. u8 __pad[3];
  547. __be32 sig_len;/*Length of signature data*/
  548. };

  550. intmod_verify_sig(constvoid*mod,unsigned long*_modlen)
  551. {
  552. //mod是模块文件起始地址，_modlen是模块文件的大小（去掉了最后的签名字符串长度）
  553. struct public_key_signature*pks;
  554. struct module_signature ms;
  555. struct key*key;
  556. constvoid*sig;
  557. size_t modlen=*_modlen,sig_len;
  558. intret;

  560. pr_devel("==>%s(,%zu) ",__func__,modlen);

  562. //检查长度
  563. if(modlen<=sizeof(ms))
  564. return-EBADMSG;

  566. //如果.ko文件最后有签名字符串的话，则签名字符串之上有一个module_signature结构，读出这个结构的内容
  567. memcpy(&ms,mod+(modlen-sizeof(ms)),sizeof(ms));
  568. modlen-=sizeof(ms);//相应修改模块文件长度

  570. sig_len=be32_to_cpu(ms.sig_len);//获得签名数据长度
  571. if(sig_len>=modlen)
  572. return-EBADMSG;
  573. modlen-=sig_len;//模块文件长度再减去签名数据长度

  575. if((size_t)ms.signer_len+ms.key_id_len>=modlen)
  576. return-EBADMSG;
  577. //模块文件长度再减去签名人名字长度和key长度
  578. modlen-=(size_t)ms.signer_len+ms.key_id_len;

  580. *_modlen=modlen;//去掉签名验证的信息后返回模块真实size
  581. //文件指针移到签名信息处
  582. sig=mod+modlen;

  584. /*Forthe moment,only support RSAandX.509 identifiers*/
  585. if(ms.algo!=PKEY_ALGO_RSA||ms.id_type!=PKEY_ID_X509)
  586. return-ENOPKG;

  588. if(ms.hash>=PKEY_HASH__LAST||!pkey_hash_algo[ms.hash])
  589. return-ENOPKG;

  591. //将signer name和key identifier从文件sig处读出来,返回key
  592. key=request_asymmetric_key(sig,ms.signer_len,sig+ms.signer_len,ms.key_id_len);
  593. if(IS_ERR(key))
  594. return PTR_ERR(key);

  596. //Digest the module contents.
  597. pks=mod_make_digest(ms.hash,mod,modlen);
  598. if(IS_ERR(pks)){
  599. ret=PTR_ERR(pks);
  600. goto error_put_key;
  601. }

  603. //Extract an MPIarrayfrom the signature data.This represents the actual signature.Eachraw MPIisprefaced by a BE 2-byte value indicating the size of the MPIinbytes.RSA signatures only have one MPI,so currently we only read one.
  604. ret=mod_extract_mpi_array(pks,sig+ms.signer_len+ms.key_id_len,sig_len);
  605. if(ret<0)
  606. goto error_free_pks;

  608. //Initiate the use of an asymmetric keytoverify a signature
  609. //key:The asymmetric keytoverify against
  610. //sig:The signaturetocheck
  611. ret=verify_signature(key,pks);
  612. pr_devel("verify_signature() = %d ",ret);

  614. error_free_pks:
  615. mpi_free(pks->rsa.s);
  616. kfree(pks);
  617. error_put_key:
  618. key_put(key);
  619. pr_devel("<==%s() = %d ",__func__,ret);
  620. return ret;
  621. }

  623. staticintelf_header_check(struct load_info*info)
  624. {
  625. if(info->len<sizeof(*(info->hdr)))
  626. return-ENOEXEC;

  628. //检查elf文件头，以及文件类型(.ko文件必是可重定位文件),架构以及节区大小是否设置正确
  629. if(memcmp(info->hdr->e_ident,ELFMAG,SELFMAG)!=0||info->hdr->e_type!=ET_REL
  630. ||!elf_check_arch(info->hdr)||info->hdr->e_shentsize!=sizeof(Elf_Shdr))
  631. return-ENOEXEC;

  633. //检查节区的偏移地址
  634. if(info->hdr->e_shoff>=info->len
  635. ||(info->hdr->e_shnum*sizeof(Elf_Shdr)>info->len-info->hdr->e_shoff))
  636. return-ENOEXEC;

  638. return 0;
  639. }

  641. static struct module*layout_and_allocate(struct load_info*info,intflags)
  642. {
  643. struct module*mod;
  644. interr;

  646. //设置info结构，并检查module_layout的crc值，并返回一个存储在.gnu.linkonce.this_module节区中的struct module结构，该module的起始地址正是.gnu.linkonce.this_module节区起始地址
  647. mod=setup_load_info(info,flags);
  648. if(IS_ERR(mod))
  649. returnmod;

  651. //检查.modinfo节区中的信息，包括version magic
  652. err=check_modinfo(mod,info,flags);
  653. if(err)
  654. return ERR_PTR(err);

  656. //什么也不做，返回0
  657. err=module_frob_arch_sections(info->hdr,info->sechdrs,info->secstrings,mod);
  658. if(err<0)
  659. return ERR_PTR(err);

  661. //移除SHF_ALLOC标志
  662. info->sechdrs[info->index.pcpu].sh_flags&=~(unsigned long)SHF_ALLOC;

  664. //只有节区头部设置了SHF_ALLOC标志，才最终存于内存中，且内存分为init部分和core部分
  665. layout_sections(mod,info);

  667. //为symbol section以及跟它相关的string table布置位置，更新相关size
  668. layout_symtab(mod,info);

  670. //为mod指向的临时镜像中标记了SHF_ALLOC节区分配内存，并从临时镜像复制到最终的位置，并且修改节区的起始地址
  671. err=move_module(mod,info);
  672. if(err)
  673. return ERR_PTR(err);

  675. //因为前边已将模块靠诶到最终的内存位置，所以各个节区的起始地址已经改变，之前mod指向的地址已经无效，所以重新将新的“.gnu.linkonce.this_module”节区的起始地址（指向一个module对象）赋给mod对象
  676. mod=(void*)info->sechdrs[info->index.mod].sh_addr;

  678. //扫描检查内存泄露？？？
  679. kmemleak_load_module(mod,info);
  680. returnmod;
  681. }

  683. static struct module*setup_load_info(struct load_info*info)
  684. {
  685. unsignedinti;
  686. interr;
  687. struct module*mod;

  689. //找到节区头部表开始地址
  690. info->sechdrs=(void*)info->hdr+info->hdr->e_shoff;
  691. //找到节区名称的字符串节区的起始地址
  692. info->secstrings=(void*)info->hdr+info->sechdrs[info->hdr->e_shstrndx].sh_offset;

  694. //根据elf格式的.ko文件拷贝到内核空间内存中的虚拟地址为基地址(即(void*)info->hdr)，重写节区在内存映像中节区第一个字节应处的位置
  695. err=rewrite_section_headers(info);
  696. if(err)
  697. return ERR_PTR(err);

  699. /*遍历所有节区找到符号表（类型为 SHT_SYMTAB 的唯一段）和相关的符号字符串表的位置，
  700. 前者的 sh_link 即为后者的段索引*/
  701. for(i=1;i<info->hdr->e_shnum;i++){
  702. if(info->sechdrs[i].sh_type==SHT_SYMTAB){
  703. //找到符号表节区.symtab索引
  704. info->index.sym=i;
  705. //找到符号表字符串节区索引，即.strtab节区
  706. info->index.str=info->sechdrs[i].sh_link;
  707. //字符串节区内容开始地址
  708. info->strtab=(char*)info->hdr+info->sechdrs[info->index.str].sh_offset;
  709. break;
  710. }
  711. }

  713. //在.gnu.linkonce.this_module节区中，有一个struct module的实例，此结构大部分成员是NULL，编译器只是初始化了name,init,exit和arch等几个成员。
  714. info->index.mod=find_sec(info,".gnu.linkonce.this_module");
  715. if(!info->index.mod){
  716. printk(KERN_WARNING"No module found in object ");
  717. return ERR_PTR(-ENOEXEC);
  718. }

  720. //mod指向 struct module的实例，该实例中提供了模块的名称和指向初始化以及清理函数的指针，但其他成员仍然初始化为NULL或 0.将该模块的地址暂时设为临时映像中节区给出的地址,后边会对module的地址再做出修正.
  721. mod=(void*)info->sechdrs[info->index.mod].sh_addr;

  723. if(info->index.sym==0){
  724. printk(KERN_WARNING"%s: module has no symbols (stripped?) ",mod->name);
  725. return ERR_PTR(-ENOEXEC);
  726. }

  728. //查找".data..percpu"节区索引号
  729. info->index.pcpu=find_pcpusec(info);

  731. //检查模块中“module_layout”符号的crc值，若失败则打印著名模块加载错误“Exec formaterror”
  732. if(!check_modstruct_version(info->sechdrs,info->index.vers,mod))
  733. return ERR_PTR(-ENOEXEC);

  735. returnmod;
  736. }

  738. staticintrewrite_section_headers(struct load_info*info,intflags)
  739. {
  740. unsignedinti;
  741. info->sechdrs[0].sh_addr=0;//节区0地址是0，表示此节区不出现在内存映像中
  742. for(i=1;i<info->hdr->e_shnum;i++){
  743. Elf_Shdr*shdr=&info->sechdrs[i];
  744. //判断节区size
  745. if(shdr->sh_type!=SHT_NOBITS&&info->len<shdr->sh_offset+shdr->sh_size){
  746. printk(KERN_ERR"Module len %lu truncated ",info->len);
  747. return-ENOEXEC;
  748. }

  750. //在elf文件拷贝到内核空间的基地址基础上重新设置节区在内核空间的起始地址，shdr->sh_addr表示节区在内存映像中节区第一个字节应处的位置
  751. shdr->sh_addr=(size_t)info->hdr+shdr->sh_offset;
  752. #ifndef CONFIG_MODULE_UNLOAD
  753. /*Don't load.exitsections*/
  754. if(strstarts(info->secstrings+shdr->sh_name,".exit"))
  755. shdr->sh_flags&=~(unsigned long)SHF_ALLOC;
  756. #endif
  757. }

  759. //找到__versions和.modinfo节区，并记录节区索引
  760. if(flags&MODULE_INIT_IGNORE_MODVERSIONS)
  761. info->index.vers=0;
  762. else
  763. info->index.vers=find_sec(info,"__versions");
  764. info->index.info=find_sec(info,".modinfo");
  765. //这两个节区清楚SHF_ALLOC标志，表示此节区在进程执行过程中不占用内存
  766. info->sechdrs[info->index.info].sh_flags&=~(unsigned long)SHF_ALLOC;
  767. info->sechdrs[info->index.vers].sh_flags&=~(unsigned long)SHF_ALLOC;
  768. return 0;
  769. }

  771. static inlineintcheck_modstruct_version(Elf_Shdr*sechdrs,unsignedintversindex,struct module*mod)
  772. {
  773. constunsigned long*crc;

  775. //查找系统内核中“module_layout”符号,并返回该符号的crc值
  776. if(!find_symbol(VMLINUX_SYMBOL_STR(module_layout),NULL,&crc,true,false))
  777. BUG();

  779. //系统中“module_layout”符号的crc值与模块中的“module_layout”符号crc值是否一致
  780. return check_version(sechdrs,versindex,VMLINUX_SYMBOL_STR(module_layout),mod,crc,NULL);
  781. }

  783. //查找符号使用的结构体
  784. struct find_symbol_arg{
  785. //输入
  786. constchar*name;//要查找的符号名
  787. bool gplok;//如果为真，则表示内核模块支持GPL许可
  788. bool warn;//警告信息标志

  790. //输出
  791. struct module*owner;//该符号所属的模块
  792. constunsigned long*crc;//该符号的crc值
  793. conststruct kernel_symbol*sym;//符号结构
  794. };

  796. conststruct kernel_symbol*find_symbol(constchar*name,struct module**owner,constunsigned long**crc,bool gplok,bool warn)
  797. {
  798. //设置查找符号参数结构
  799. struct find_symbol_arg fsa;
  800. fsa.name=name;
  801. fsa.gplok=gplok;
  802. fsa.warn=warn;

  804. //查找符号，填写符号参数结构的输出部分
  805. if(each_symbol_section(find_symbol_in_section,&fsa)){
  806. if(owner)//NULL,下边不需赋值
  807. *owner=fsa.owner;

  809. if(crc)//得到该符号的crc值
  810. *crc=fsa.crc;

  812. //返回以name命名的内核符号结构
  813. return fsa.sym;
  814. }

  816. //没有找到内核符号，返回NULL
  817. pr_debug("Failed to find symbol %s ",name);
  818. returnNULL;
  819. }

  821. bool each_symbol_section(bool(*fn)(conststruct symsearch*arr,struct module*owner,void*data),void*data)
  822. {
  823. struct module*mod;
  824. //第一部分在内核导出的符号表中查找对应的符号，找到就返回对应的符号信息，否则，再进行第二部分查找.
  825. /*struct symsearch{
  826. conststruct kernel_symbol*start,*stop;
  827. constunsigned long*crcs;
  828. enum{
  829. NOT_GPL_ONLY,
  830. GPL_ONLY,
  831. WILL_BE_GPL_ONLY,
  832. }licence;
  833. bool unused;
  834. };
  835. */
  836. staticconststruct symsearch arr[]={
  837. {__start___ksymtab,__stop___ksymtab,
  838. __start___kcrctab,NOT_GPL_ONLY,false},
  839. {__start___ksymtab_gpl,__stop___ksymtab_gpl,
  840. __start___kcrctab_gpl,GPL_ONLY,false},
  841. {__start___ksymtab_gpl_future,__stop___ksymtab_gpl_future,
  842. __start___kcrctab_gpl_future,WILL_BE_GPL_ONLY,false},
  843. #ifdef CONFIG_UNUSED_SYMBOLS
  844. {__start___ksymtab_unused,__stop___ksymtab_unused,
  845. __start___kcrctab_unused,NOT_GPL_ONLY,true},
  846. {__start___ksymtab_unused_gpl,__stop___ksymtab_unused_gpl,
  847. __start___kcrctab_unused_gpl,GPL_ONLY,true},
  848. #endif
  849. };

  851. if(each_symbol_in_section(arr,ARRAY_SIZE(arr),NULL,fn,data))
  852. returntrue;

  854. //在内核导出的符号表中没有找到对应的符号，则在系统已加载的模块中查找
  855. list_for_each_entry_rcu(mod,&modules,list){
  856. struct symsearch arr[]={
  857. {mod->syms,mod->syms+mod->num_syms,
  858. mod->crcs,NOT_GPL_ONLY,false},
  859. {mod->gpl_syms,mod->gpl_syms+mod->num_gpl_syms,
  860. mod->gpl_crcs,GPL_ONLY,false},
  861. {mod->gpl_future_syms,mod->gpl_future_syms+mod->num_gpl_future_syms,
  862. mod->gpl_future_crcs,WILL_BE_GPL_ONLY,false},
  863. #ifdef CONFIG_UNUSED_SYMBOLS
  864. {mod->unused_syms,mod->unused_syms+mod->num_unused_syms,
  865. mod->unused_crcs,NOT_GPL_ONLY,true},
  866. {mod->unused_gpl_syms,mod->unused_gpl_syms+mod->num_unused_gpl_syms,
  867. mod->unused_gpl_crcs,GPL_ONLY,true},
  868. #endif
  869. };

  871. //若模块状态为MODULE_STATE_UNFORMED，则此模块的符号不可用
  872. if(mod->state==MODULE_STATE_UNFORMED)
  873. continue;

  875. if(each_symbol_in_section(arr,ARRAY_SIZE(arr),mod,fn,data))
  876. returntrue;
  877. }
  878. returnfalse;
  879. }

  881. static bool each_symbol_in_section(conststruct symsearch*arr,unsignedintarrsize,struct module*owner,bool(*fn)(conststruct symsearch*syms,struct module*owner,void*data),void*data)
  882. {
  883. unsignedintj;

  885. //调用find_symbol_in_section()对每个数组指定的符号地址范围进行查找
  886. for(j=0;j<arrsize;j++){
  887. if(fn(&arr[j],owner,data))//调用find_symbol_in_section()
  888. returntrue;
  889. }
  890. returnfalse;
  891. }

  893. static bool find_symbol_in_section(conststruct symsearch*syms,struct module*owner,void*data)
  894. {
  895. struct find_symbol_arg*fsa=data;
  896. struct kernel_symbol*sym;

  898. //在范围内查找符号名为fsa->name的内核符号
  899. sym=bsearch(fsa->name,syms->start,syms->stop-syms->start,sizeof(struct kernel_symbol),cmp_name);

  901. //若找到内核符号，则对其进行check是否有效
  902. if(sym!=NULL&&check_symbol(syms,owner,sym-syms->start,data))
  903. returntrue;

  905. returnfalse;
  906. }

  908. void*bsearch(constvoid*key,constvoid*base,size_t num,size_t size,int(*cmp)(constvoid*key,constvoid*elt))
  909. {
  910. size_t start=0,end=num;
  911. intresult;

  913. while(start<end){//折半查找
  914. size_tmid=start+(end-start)/2;

  916. //调用cmp_name()函数比较符号名是否一致
  917. result=cmp(key,base+mid*size);
  918. if(result<0)
  919. end=mid;
  920. elseif(result>0)
  921. start=mid+1;
  922. else
  923. return(void*)base+mid*size;
  924. }
  925. returnNULL;
  926. }

  928. staticintcmp_name(constvoid*va,constvoid*vb)
  929. {
  930. constchar*a;
  931. conststruct kernel_symbol*b;
  932. a=va;b=vb;
  933. return strcmp(a,b->name);
  934. }

  936. static bool check_symbol(conststruct symsearch*syms,struct module*owner,unsignedintsymnum,void*data)
  937. {
  938. struct find_symbol_arg*fsa=data;

  940. if(!fsa->gplok){//若未设置gplok，则必须为GPL许可
  941. if(syms->licence==GPL_ONLY)
  942. returnfalse;
  943. if(syms->licence==WILL_BE_GPL_ONLY&&fsa->warn){
  944. printk(KERN_WARNING"Symbol %s is being used "
  945. "by a non-GPL module, which will not "
  946. "be allowed in the future ",fsa->name);
  947. }
  948. }

  950. #ifdef CONFIG_UNUSED_SYMBOLS
  951. if(syms->unused&&fsa->warn){
  952. printk(KERN_WARNING"Symbol %s is marked as UNUSED, "
  953. "however this module is using it. ",fsa->name);
  954. printk(KERN_WARNING"This symbol will go away in the future. ");
  955. printk(KERN_WARNING
  956. "Please evalute if this is the right api to use and if "
  957. "it really is, submit a report the linux kernel "
  958. "mailinglist together with submitting your code for "
  959. "inclusion. ");
  960. }
  961. #endif

  963. fsa->owner=owner;//符号所属模块
  964. //#define symversion(base,idx)((base!=NULL)?((base)+(idx)):NULL)
  965. fsa->crc=symversion(syms->crcs,symnum);//符号的crc值
  966. fsa->sym=&syms->start[symnum];//返回的符号结构
  967. returntrue;
  968. }

  970. staticintcheck_version(Elf_Shdr*sechdrs,unsignedintversindex,constchar*symname,struct module*mod,constunsigned long*crc,conststruct module*crc_owner)
  971. {
  972. unsignedinti,num_versions;
  973. struct modversion_info*versions;

  975. //若系统中的该符号crc值为0，则直接返回1完事
  976. if(!crc)
  977. return 1;

  979. //若该模块的elf格式文件中没有__versions节区，则尝试强制加载模块
  980. //但是try_to_force_load()函数的实现依赖于CONFIG_MODULE_FORCE_LOAD宏是否定义。而该宏默认是没有定义的，所以这里会返回失败，看来内核并不推荐强制加载模块。
  981. if(versindex==0)
  982. return try_to_force_load(mod,symname)==0;

  984. //找到模块“__versions”节区在内存映像中的起始地址。相当于节区的contents内容
  985. versions=(void*)sechdrs[versindex].sh_addr;
  986. num_versions=sechdrs[versindex].sh_size/sizeof(struct modversion_info);
  987. for(i=0;i<num_versions;i++){
  988. if(strcmp(versions[i].name,symname)!=0)//在此节区中找到要比较的符号
  989. continue;

  991. //比较该模块中的符号crc值和现在系统上的内核符号的crc值是否一致
  992. if(versions[i].crc==maybe_relocated(*crc,crc_owner))
  993. return 1;
  994. pr_debug("Found checksum %lX vs module %lX ",maybe_relocated(*crc,crc_owner),versions[i].crc);
  995. goto bad_version;
  996. }

  998. //若在“__versions”节区没有找到要比较的符号，则会给出加载模块时常见错误：“no symbol version for”
  999. printk(KERN_WARNING"%s: no symbol version for %s ",mod->name,symname);
  1000. return 0;
  1001. bad_version:
  1002. //如果比较符号的额crc值不一致，则会给出加载模块时常见错误“disagrees about version of symbol”
  1003. printk("%s: disagrees about version of symbol %s ",mod->name,symname);
  1004. return 0;
  1005. }

  1007. staticinttry_to_force_load(struct module*mod,constchar*reason)
  1008. {
  1009. #ifdef CONFIG_MODULE_FORCE_LOAD
  1010. //若选项CONFIG_MODULE_FORCE_LOAD打开，则检查tainted_mask是否设置了TAINT_FORCED_MODULE标志，若没有给出警告信息
  1011. if(!test_taint(TAINT_FORCED_MODULE))
  1012. printk(KERN_WARNING"%s: %s: kernel tainted. ",mod->name,reason);

  1014. //设置mod->taints和tainted_mask的TAINT_FORCED_MODULE标志，表示强制加载该模块，并返回正确值0
  1015. add_taint_module(mod,TAINT_FORCED_MODULE,LOCKDEP_NOW_UNRELIABLE);
  1016. return 0;
  1017. #else
  1018. //若选项CONFIG_MODULE_FORCE_LOAD未打开，则直接返回错误
  1019. return-ENOEXEC;
  1020. #endif
  1021. }

  1023. staticintcheck_modinfo(struct module*mod,struct load_info*info,intflags)
  1024. {
  1025. //从模块.modinfo节区中获得version magic
  1026. constchar*modmagic=get_modinfo(info,"vermagic");
  1027. interr;
  1028. if(flags&MODULE_INIT_IGNORE_VERMAGIC)
  1029. modmagic=NULL;

  1031. //若version magic为0，则尝试强制加载
  1032. if(!modmagic){
  1033. err=try_to_force_load(mod,"bad vermagic");
  1034. if(err)
  1035. returnerr;
  1036. }
  1037. //与内核的vermagic是否一致，若不一致，给出著名错误：“version magic...should be...”,返回错误码
  1038. elseif(!same_magic(modmagic,vermagic,info->index.vers)){
  1039. printk(KERN_ERR"%s: version magic '%s' should be '%s' ",mod->name,modmagic,vermagic);
  1040. return-ENOEXEC;
  1041. }

  1043. //返回.modinfo节区中intree=“...”的内容,若不存在设置标志TAINT_OOT_MODULE
  1044. if(!get_modinfo(info,"intree"))
  1045. add_taint_module(mod,TAINT_OOT_MODULE,LOCKDEP_STILL_OK);

  1047. //返回.modinfo节区中staging=“...”的内容，存在设置标志TAINT_CRAP
  1048. if(get_modinfo(info,"staging")){
  1049. add_taint_module(mod,TAINT_CRAP,LOCKDEP_STILL_OK);
  1050. printk(KERN_WARNING"%s: module is from the staging directory,"" the quality is unknown, you have been warned. ",mod->name);
  1051. }

  1053. //取出.modinfo节区的license字段指定的license类型，并对此license检查
  1054. set_license(mod,get_modinfo(info,"license"));
  1055. return 0;
  1056. }

  1058. static char*get_modinfo(struct load_info*info,constchar*tag)
  1059. {
  1060. char*p;
  1061. unsignedinttaglen=strlen(tag);
  1062. //找到模块.modinfo节区
  1063. Elf_Shdr*infosec=&info->sechdrs[info->index.info];
  1064. unsigned long size=infosec->sh_size;

  1066. //查找.modinfo节区中的内容，返回"*tag"字符串=后边的内容
  1067. for(p=(char*)infosec->sh_addr;p;p=next_string(p,&size))
  1068. {
  1069. if(strncmp(p,tag,taglen)==0&&p[taglen]=='=')
  1070. return p+taglen+1;
  1071. }
  1072. returnNULL;
  1073. }

  1075. static inlineintsame_magic(constchar*amagic,constchar*bmagic,bool has_crcs)
  1076. {
  1077. //从字符串中依次取出以“ ”结尾的字符串段进行比较
  1078. if(has_crcs){
  1079. amagic+=strcspn(amagic," ");
  1080. bmagic+=strcspn(bmagic," ");
  1081. }
  1082. return strcmp(amagic,bmagic)==0;
  1083. }

  1085. static void set_license(struct module*mod,constchar*license)
  1086. {
  1087. if(!license)
  1088. license="unspecified";

  1090. //比较模块的license类型是否是内核指定的GPL类型，若不是则设置TAINT_PROPRIETARY_MODULE标志
  1091. if(!license_is_gpl_compatible(license)){
  1092. if(!test_taint(TAINT_PROPRIETARY_MODULE))
  1093. printk(KERN_WARNING"%s: module license '%s' taints kernel. ",mod->name,license);
  1094. add_taint_module(mod,TAINT_PROPRIETARY_MODULE,LOCKDEP_NOW_UNRELIABLE);
  1095. }
  1096. }

  1098. static inlineintlicense_is_gpl_compatible(constchar*license)
  1099. {
  1100. return(strcmp(license,"GPL")==0
  1101. ||strcmp(license,"GPL v2")==0
  1102. ||strcmp(license,"GPL and additional rights")==0
  1103. ||strcmp(license,"Dual BSD/GPL")==0
  1104. ||strcmp(license,"Dual MIT/GPL")==0
  1105. ||strcmp(license,"Dual MPL/GPL")==0);
  1106. }

  1108. static void layout_sections(struct module*mod,struct load_info*info)
  1109. {
  1110. //注意：节的复制是按照原来ELF的顺序,将所有标志包含SHF_ALLOC的节都复制到相应的分配空间(module_core/module_init),例外的情况是SHT_NOBITS，也就是BSS段，文件中没有分配空间，因此不需要复制.

  1112. //sections函数首先为标记了SHF_ALLOC的section定义了四种类型:code,read-only data,read-write data和small data.带有SHF_ALLOC的section必定属于四类中的一类。函数遍历section header table中的所有项，将section name不是以".init"开始的section划归为COREsection.以".init"开始的section划归为INIT section.
  1113. static unsigned longconstmasks[][2]={
  1114. {SHF_EXECINSTR|SHF_ALLOC,ARCH_SHF_SMALL},//code
  1115. {SHF_ALLOC,SHF_WRITE|ARCH_SHF_SMALL},//read only data
  1116. {SHF_WRITE|SHF_ALLOC,ARCH_SHF_SMALL},//read-write data
  1117. {ARCH_SHF_SMALL|SHF_ALLOC,0}//small data
  1118. };
  1119. unsignedintm,i;

  1121. //遍历所有节区初始化sh_entsize成员
  1122. //某些节区中包含固定大小的项目，如符号表。对于这类节区，此成员sh_entsize给出每个表项的长度字节数。如果节区中并不包含固定长度表项的表格，此成员取值为 0。
  1123. for(i=0;i<info->hdr->e_shnum;i++)
  1124. info->sechdrs[i].sh_entsize=~0UL;

  1126. //划分为两部分:CORE INIT
  1127. //第1部分CORE:查找标志中含有SHF_ALLOC的section
  1128. for(m=0;m<ARRAY_SIZE(masks);++m){
  1129. for(i=0;i<info->hdr->e_shnum;++i){
  1130. Elf_Shdr*s=&info->sechdrs[i];
  1131. //找到节区名
  1132. constchar*sname=info->secstrings+s->sh_name;
  1133. //含有SHF_ALLOC的section需要加载到最终的内存
  1134. //含有SHF_ALLOC的section并且不以init开头的节区划分到CORE部分
  1135. if((s->sh_flags&masks[m][0])!=masks[m][0]
  1136. ||(s->sh_flags&masks[m][1])
  1137. ||s->sh_entsize!=~0UL||strstarts(sname,".init"))
  1138. continue;

  1140. //把由于对齐产生的偏移保存到节区的sh_entsize字段，后边mod通过sh_entsize就可以找到该节区存储的位置。并把符合要求的节区大小加到mod->core_size
  1141. s->sh_entsize=get_offset(mod,&mod->core_size,s,i);
  1142. }

  1144. //由于我们节的复制是按顺序的，而.text节是第一个节，因此mod->module_core实际上指向的就是.text段。而mod->core_text_size中也包含了.text节的大小.
  1145. switch(m){
  1146. case0://可执行的段,代码段都一样
  1147. mod->core_size=debug_align(mod->core_size);
  1148. mod->core_text_size=mod->core_size;
  1149. break;
  1150. case1://只读段
  1151. mod->core_size=debug_align(mod->core_size);
  1152. mod->core_ro_size=mod->core_size;
  1153. break;
  1154. case3://所有段
  1155. mod->core_size=debug_align(mod->core_size);
  1156. break;
  1157. }
  1158. }

  1160. //第2部分INIT
  1161. for(m=0;m<ARRAY_SIZE(masks);++m){
  1162. for(i=0;i<info->hdr->e_shnum;++i){
  1163. Elf_Shdr*s=&info->sechdrs[i];
  1164. constchar*sname=info->secstrings+s->sh_name;
  1165. //含有SHF_ALLOC的section需要加载到最终的内存
  1166. //含有SHF_ALLOC的section并且以init开头的划分到INIT部分
  1167. if((s->sh_flags&masks[m][0])!=masks[m][0]
  1168. ||(s->sh_flags&masks[m][1])
  1169. ||s->sh_entsize!=~0UL
  1170. ||!strstarts(sname,".init"))
  1171. continue;

  1173. //把由于对齐产生的偏移保存到节区的sh_entsize字段，并把符合要求的节区大小加到mod->init_size
  1174. s->sh_entsize=(get_offset(mod,&mod->init_size,s,i)|INIT_OFFSET_MASK);
  1175. }

  1177. switch(m){
  1178. case0://代码段
  1179. mod->init_size=debug_align(mod->init_size);
  1180. mod->init_text_size=mod->init_size;
  1181. break;
  1182. case1://只读段
  1183. mod->init_size=debug_align(mod->init_size);
  1184. mod->init_ro_size=mod->init_size;
  1185. break;
  1186. case3://所有段
  1187. mod->init_size=debug_align(mod->init_size);
  1188. break;
  1189. }
  1190. }
  1191. }

  1193. static long get_offset(struct module*mod,unsignedint*size,Elf_Shdr*sechdr,unsignedintsection)
  1194. {
  1195. //#define ALIGN(x,a)__ALIGN_KERNEL((x),(a))
  1196. //#define __ALIGN_KERNEL(x,a)__ALIGN_KERNEL_MASK(x,(typeof(x))(a)-1)
  1197. //#define __ALIGN_KERNEL_MASK(x,mask)(((x)+(mask))&~(mask))
  1198. long ret;
  1199. *size+=arch_mod_section_prepend(mod,section);//空函数，返回0
  1200. ret=ALIGN(*size,sechdr->sh_addralign?:1);//返回*size字节对齐后的值
  1201. *size=ret+sechdr->sh_size;//把当前节区的size也加到*size上
  1202. return ret;
  1203. }

  1205. static void layout_symtab(struct module*mod,struct load_info*info)
  1206. {
  1207. Elf_Shdr*symsect=info->sechdrs+info->index.sym;//找到符号表节区头部
  1208. Elf_Shdr*strsect=info->sechdrs+info->index.str;//找到字符串表节区头部
  1209. constElf_Sym*src;
  1210. unsignedinti,nsrc,ndst,strtab_size=0;

  1212. //符号节区设置SHF_ALLOC标志，表示在内存占空间
  1213. symsect->sh_flags|=SHF_ALLOC;

  1215. //设置符号表节区每个表项的长度字节数,并把符号表的size加到mod->init_size
  1216. symsect->sh_entsize=get_offset(mod,&mod->init_size,symsect,info->index.sym)|INIT_OFFSET_MASK;

  1218. pr_debug(" %s ",info->secstrings+symsect->sh_name);
  1219. src=(void*)info->hdr+symsect->sh_offset;//符号表节区内容起始地址
  1220. nsrc=symsect->sh_size/sizeof(*src);//符号表项个数

  1222. //计算该模块包含的所有符号名长度所占的空间
  1223. for(ndst=i=0;i<nsrc;i++){
  1224. //is_core_symbol检查符号是否有效且属于SHF_ALLOC
  1225. if(i==0||is_core_symbol(src+i,info->sechdrs,info->hdr->e_shnum)){
  1226. strtab_size+=strlen(&info->strtab[src[i].st_name])+1;
  1227. ndst++;
  1228. }
  1229. }

  1231. //将mod->core_size按符号节区对齐约束对齐后得到的值返回给info->symoffs
  1232. info->symoffs=ALIGN(mod->core_size,symsect->sh_addralign?:1);
  1233. //将符号表节区内容（即ndst个符号表项）添加到core部分的后边，并重新设置core部分的size。
  1234. info->stroffs=mod->core_size=info->symoffs+ndst*sizeof(Elf_Sym);
  1235. //core部分再把符号名的字符串所占空间加上
  1236. mod->core_size+=strtab_size;
  1237. //注意：这里只是为符号项和符号的名称长度分配了空间，还并没有将内容拷贝过来，在下边的add_kallsyms函数中进行拷贝！！！

  1239. //把字符串节区加到模块的init部分
  1240. strsect->sh_flags|=SHF_ALLOC;//字符串节区也设置上需要内存空间标志
  1241. strsect->sh_entsize=get_offset(mod,&mod->init_size,strsect,info->index.str)|INIT_OFFSET_MASK;
  1242. pr_debug(" %s ",info->secstrings+strsect->sh_name);
  1243. }


  1246. static bool is_core_symbol(constElf_Sym*src,constElf_Shdr*sechdrs,unsignedintshnum)
  1247. {
  1248. constElf_Shdr*sec;
  1249. //未定义的符号，或者符号索引号大于符号总个数，或者符号名为空则直接返回0
  1250. if(src->st_shndx==SHN_UNDEF||src->st_shndx>=shnum||!src->st_name)
  1251. returnfalse;

  1253. //找到符号所在的节区，若该节区不占内存，则也返回0
  1254. sec=sechdrs+src->st_shndx;
  1255. if(!(sec->sh_flags&SHF_ALLOC)
  1256. #ifndef CONFIG_KALLSYMS_ALL
  1257. ||!(sec->sh_flags&SHF_EXECINSTR)
  1258. #endif
  1259. ||(sec->sh_entsize&INIT_OFFSET_MASK))
  1260. returnfalse;
  1261. returntrue;
  1262. }

  1264. staticintmove_module(struct module*mod,struct load_info*info)
  1265. {
  1266. inti;
  1267. void*ptr;

  1269. //在内核空间为模块的core部分分配空间，返回地址
  1270. ptr=module_alloc_update_bounds(mod->core_size);

  1272. //但是要扫描这个指针所分配的内存的内容。分配数据结构那么该结构本身不打印，但是会扫描结构内部的成员变量，是否引用其他指针。
  1273. kmemleak_not_leak(ptr);
  1274. if(!ptr)
  1275. return-ENOMEM;
  1276. memset(ptr,0,mod->core_size);
  1277. mod->module_core=ptr;//地址赋给module_core成员

  1279. //在内核空间为init section分配内存，初始化后存储在module对象的module_init成员中
  1280. if(mod->init_size){
  1281. //为模块的init部分分配空间，返回地址
  1282. ptr=module_alloc_update_bounds(mod->init_size);

  1284. kmemleak_ignore(ptr);
  1285. if(!ptr){
  1286. module_free(mod,mod->module_core);
  1287. return-ENOMEM;
  1288. }
  1289. memset(ptr,0,mod->init_size);
  1290. mod->module_init=ptr;//地址赋给module_init
  1291. }else
  1292. mod->module_init=NULL;
  1293. /*Transfereachsection which specifies SHF_ALLOC*/

  1295. pr_debug("final section addresses: ");
  1296. //遍历所有节区，拷贝需要占用内存（标志为SHF_ALLOC的节区）的段到init section 或core section，并且调整各个节区的运行时地址
  1297. for(i=0;i<info->hdr->e_shnum;i++){
  1298. void*dest;
  1299. Elf_Shdr*shdr=&info->sechdrs[i];
  1300. if(!(shdr->sh_flags&SHF_ALLOC))
  1301. continue;

  1303. //如果节区首部的sh_entsize的最高位设置的话，表示该段属于init section，则从module_init开始的内存中获取当前段应该存储的地址，否则从module_core开始的内存中获取当前段应该存储的地址。
  1304. if(shdr->sh_entsize&INIT_OFFSET_MASK)
  1305. dest=mod->module_init+(shdr->sh_entsize&~INIT_OFFSET_MASK);
  1306. else
  1307. dest=mod->module_core+shdr->sh_entsize;

  1309. //将当前节区的内容从ELF文件头拷贝到指定的段(init section或core section)中
  1310. if(shdr->sh_type!=SHT_NOBITS)
  1311. memcpy(dest,(void*)shdr->sh_addr,shdr->sh_size);

  1313. //更改节区的运行时地址,sh_addr原先存储的地址是相对于ELF文件头的地址，现在是在内核空间分配新的内存空间后，节区新的运行地址(即节区内容的起始地址)。
  1314. shdr->sh_addr=(unsigned long)dest;
  1315. pr_debug(" 0x%lx %s ",(long)shdr->sh_addr,info->secstrings+shdr->sh_name);
  1316. }
  1317. return 0;
  1318. }

  1320. static void*module_alloc_update_bounds(unsigned long size)
  1321. {
  1322. //在内核空间中分配size大小的空间，返回起始地址
  1323. void*ret=module_alloc(size);

  1325. //更新模块边界值
  1326. if(ret){
  1327. mutex_lock(&module_mutex);
  1328. if((unsigned long)ret<module_addr_min)
  1329. module_addr_min=(unsigned long)ret;
  1330. if((unsigned long)ret+size>module_addr_max)
  1331. module_addr_max=(unsigned long)ret+size;
  1332. mutex_unlock(&module_mutex);
  1333. }
  1334. return ret;
  1335. }

  1337. staticintadd_unformed_module(struct module*mod)
  1338. {
  1339. interr;
  1340. struct module*old;
  1341. mod->state=MODULE_STATE_UNFORMED;
  1342. again:
  1343. mutex_lock(&module_mutex);
  1344. //在内核中查找此模块是否已加入链表
  1345. old=find_module_all(mod->name,strlen(mod->name),true);
  1346. if(old!=NULL){
  1347. if(old->state==MODULE_STATE_COMING||old->state==MODULE_STATE_UNFORMED){
  1348. /*Waitincaseit failstoload.*/
  1349. mutex_unlock(&module_mutex);
  1350. err=wait_event_interruptible(module_wq,finished_loading(mod->name));
  1351. if(err)
  1352. goto out_unlocked;
  1353. goto again;
  1354. }
  1355. err=-EEXIST;
  1356. goto out;
  1357. }
  1358. //若还没有，则挂入全局模块链表modules
  1359. list_add_rcu(&mod->list,&modules);
  1360. err=0;
  1361. out:
  1362. mutex_unlock(&module_mutex);
  1363. out_unlocked:
  1364. returnerr;
  1365. }

  1367. staticintmodule_unload_init(struct module*mod)
  1368. {
  1369. //初始化多处理下用于引用计数的refptr成员
  1370. mod->refptr=alloc_percpu(struct module_ref);
  1371. if(!mod->refptr)
  1372. return-ENOMEM;

  1374. //初始化module对象的链表
  1375. INIT_LIST_HEAD(&mod->source_list);
  1376. INIT_LIST_HEAD(&mod->target_list);
  1377. //模块计数加1
  1378. __this_cpu_write(mod->refptr->incs,1);
  1379. /*Backwards compatibility macros put refcount during init.*/
  1380. mod->waiter=current;

  1382. return 0;
  1383. }

  1385. static void find_module_sections(struct module*mod,struct load_info*info)
  1386. {
  1387. mod->kp=section_objs(info,"__param",sizeof(*mod->kp),&mod->num_kp);
  1388. mod->syms=section_objs(info,"__ksymtab",sizeof(*mod->syms),&mod->num_syms);
  1389. mod->crcs=section_addr(info,"__kcrctab");
  1390. mod->gpl_syms=section_objs(info,"__ksymtab_gpl",sizeof(*mod->gpl_syms),&mod->num_gpl_syms);
  1391. mod->gpl_crcs=section_addr(info,"__kcrctab_gpl");
  1392. mod->gpl_future_syms=section_objs(info,"__ksymtab_gpl_future",
  1393. sizeof(*mod->gpl_future_syms),&mod->num_gpl_future_syms);
  1394. mod->gpl_future_crcs=section_addr(info,"__kcrctab_gpl_future");

  1396. #ifdef CONFIG_UNUSED_SYMBOLS
  1397. mod->unused_syms=section_objs(info,"__ksymtab_unused",sizeof(*mod->unused_syms),&mod->num_unused_syms);
  1398. mod->unused_crcs=section_addr(info,"__kcrctab_unused");
  1399. mod->unused_gpl_syms=section_objs(info,"__ksymtab_unused_gpl",sizeof(*mod->unused_gpl_syms),&mod->num_unused_gpl_syms);
  1400. mod->unused_gpl_crcs=section_addr(info,"__kcrctab_unused_gpl");
  1401. #endif
  1402. #ifdef CONFIG_CONSTRUCTORS
  1403. mod->ctors=section_objs(info,".ctors",sizeof(*mod->ctors),&mod->num_ctors);
  1404. #endif

  1406. #ifdef CONFIG_TRACEPOINTS
  1407. mod->tracepoints_ptrs=section_objs(info,"__tracepoints_ptrs",sizeof(*mod->tracepoints_ptrs),&mod->num_tracepoints);
  1408. #endif
  1409. #ifdef HAVE_JUMP_LABEL
  1410. mod->jump_entries=section_objs(info,"__jump_table",sizeof(*mod->jump_entries),&mod->num_jump_entries);
  1411. #endif
  1412. #ifdef CONFIG_EVENT_TRACING
  1413. mod->trace_events=section_objs(info,"_ftrace_events",sizeof(*mod->trace_events),&mod->num_trace_events);
  1414. #endif
  1415. #ifdef CONFIG_TRACING
  1416. mod->trace_bprintk_fmt_start=section_objs(info,"__trace_printk_fmt",sizeof(*mod->trace_bprintk_fmt_start),&mod->num_trace_bprintk_fmt);
  1417. #endif
  1418. #ifdef CONFIG_FTRACE_MCOUNT_RECORD
  1419. /*sechdrs[0].sh_sizeisalways zero*/
  1420. mod->ftrace_callsites=section_objs(info,"__mcount_loc",sizeof(*mod->ftrace_callsites),&mod->num_ftrace_callsites);
  1421. #endif

  1423. mod->extable=section_objs(info,"__ex_table",sizeof(*mod->extable),&mod->num_exentries);

  1425. if(section_addr(info,"__obsparm"))
  1426. printk(KERN_WARNING"%s: Ignoring obsolete parameters ",mod->name);

  1428. info->debug=section_objs(info,"__verbose",sizeof(*info->debug),&info->num_debug);
  1429. }

  1431. static void*section_objs(conststruct load_info*info,constchar*name,size_t object_size,unsignedint*num)
  1432. {
  1433. //根据节区名找到节区索引值
  1434. unsignedintsec=find_sec(info,name);
  1435. //计算节区项目数
  1436. *num=info->sechdrs[sec].sh_size/object_size;
  1437. //返回节区起始地址
  1438. return(void*)info->sechdrs[sec].sh_addr;
  1439. }

  1441. staticintcheck_module_license_and_versions(struct module*mod)
  1442. {
  1443. if(strcmp(mod->name,"ndiswrapper")==0)
  1444. add_taint(TAINT_PROPRIETARY_MODULE,LOCKDEP_NOW_UNRELIABLE);

  1446. /*driverloader was caught wrongly pretendingtobe under GPL*/
  1447. if(strcmp(mod->name,"driverloader")==0)
  1448. add_taint_module(mod,TAINT_PROPRIETARY_MODULE,LOCKDEP_NOW_UNRELIABLE);

  1450. /*lve claimstobe GPL but upstream won't provide source*/
  1451. if(strcmp(mod->name,"lve")==0)
  1452. add_taint_module(mod,TAINT_PROPRIETARY_MODULE,LOCKDEP_NOW_UNRELIABLE);

  1454. #ifdef CONFIG_MODVERSIONS
  1455. if((mod->num_syms&&!mod->crcs)||(mod->num_gpl_syms&&!mod->gpl_crcs)
  1456. ||(mod->num_gpl_future_syms&&!mod->gpl_future_crcs)
  1457. #ifdef CONFIG_UNUSED_SYMBOLS
  1458. ||(mod->num_unused_syms&&!mod->unused_crcs)
  1459. ||(mod->num_unused_gpl_syms&&!mod->unused_gpl_crcs)
  1460. #endif
  1461. ){
  1462. return try_to_force_load(mod,"no versions for exported symbols");
  1463. }
  1464. #endif
  1465. return 0;
  1466. }

  1468. static struct module_attribute*modinfo_attrs[]={
  1469. &module_uevent,
  1470. &modinfo_version,
  1471. &modinfo_srcversion,
  1472. &modinfo_initstate,
  1473. &modinfo_coresize,
  1474. &modinfo_initsize,
  1475. &modinfo_taint,
  1476. #ifdef CONFIG_MODULE_UNLOAD
  1477. &modinfo_refcnt,
  1478. #endif
  1479. NULL,
  1480. };

  1482. static void setup_modinfo(struct module*mod,struct load_info*info)
  1483. {
  1484. struct module_attribute*attr;
  1485. inti;

  1487. for(i=0;(attr=modinfo_attrs[i]);i++){
  1488. if(attr->setup)
  1489. attr->setup(mod,get_modinfo(info,attr->attr.name));
  1490. }
  1491. }

  1493. staticintsimplify_symbols(struct module*mod,conststruct load_info*info)
  1494. {
  1495. Elf_Shdr*symsec=&info->sechdrs[info->index.sym];
  1496. Elf_Sym*sym=(void*)symsec->sh_addr;
  1497. unsigned long secbase;
  1498. unsignedinti;
  1499. intret=0;
  1500. conststruct kernel_symbol*ksym;

  1502. //遍历模块所有符号
  1503. for(i=1;i<symsec->sh_size/sizeof(Elf_Sym);i++){
  1504. constchar*name=info->strtab+sym[i].st_name;

  1506. //不同符号类型必须进行不同的处理。
  1507. switch(sym[i].st_shndx){
  1508. caseSHN_COMMON://标注了一个尚未分配的公共块符号
  1509. DEBUGP("Common symbol: %s ",name);
  1510. printk("%s: please compile with -fno-common ",mod->name);
  1511. ret=-ENOEXEC;
  1512. break;

  1514. caseSHN_ABS://完全定义的符号是最容易的，因为什么也不需要做。
  1515. DEBUGP("Absolute symbol: 0x%08lx ",(long)sym[i].st_value);
  1516. break;

  1518. caseSHN_UNDEF://未定义的符号，会进行crc检查
  1519. //会调用check_version检查crc值是否一致，若一致返回内核中的同名符号
  1520. ksym=resolve_symbol_wait(mod,info,name);

  1522. //如果符号已经解决(crc一致)，则没有问题，将内核中的符号地址赋给模块中的符号地址
  1523. if(ksym&&!IS_ERR(ksym)){
  1524. sym[i].st_value=ksym->value;//使用内核中的符号值
  1525. break;
  1526. }

  1528. //如果符号定义为弱的，也没有问题
  1529. if(!ksym&&ELF_ST_BIND(sym[i].st_info)==STB_WEAK)
  1530. break;

  1532. printk(KERN_WARNING"%s: Unknown symbol %s (err %li) ",mod->name,name,PTR_ERR(ksym));
  1533. ret=PTR_ERR(ksym)?:-ENOENT;
  1534. break;

  1536. //解决其他符号时(符号通过st_shndx成员指向固定的节区)，根据节区新的起始地址
  1537. default:
  1538. if(sym[i].st_shndx==info->index.pcpu)
  1539. secbase=(unsigned long)mod_percpu(mod);
  1540. else
  1541. secbase=info->sechdrs[sym[i].st_shndx].sh_addr;
  1542. //根据符号所在节区的起始地址更改符号地址
  1543. sym[i].st_value+=secbase;
  1544. break;
  1545. }
  1546. }
  1547. return ret;
  1548. }

  1550. staticconststruct kernel_symbol*resolve_symbol_wait(struct module*mod,conststruct load_info*info,constchar*name)
  1551. {
  1552. conststruct kernel_symbol*ksym;
  1553. char owner[MODULE_NAME_LEN];

  1555. //调用resolve_symbol()函数
  1556. if(wait_event_interruptible_timeout(module_wq,!IS_ERR(ksym=resolve_symbol(mod,info,name,owner))||PTR_ERR(ksym)!=-EBUSY,30*HZ)<=0){
  1557. printk(KERN_WARNING"%s: gave up waiting for init of module %s. ",mod->name,owner);
  1558. }
  1559. return ksym;
  1560. }

  1562. staticconststruct kernel_symbol*resolve_symbol(struct module*mod,conststruct load_info*info,constchar*name,char ownername[])
  1563. {
  1564. struct module*owner;
  1565. conststruct kernel_symbol*sym;
  1566. constunsigned long*crc;
  1567. interr;
  1568. mutex_lock(&module_mutex);

  1570. //从内核中查找符号名为name的符号，并返回该符号的crc值
  1571. sym=find_symbol(name,&owner,&crc,!(mod->taints&(1<<TAINT_PROPRIETARY_MODULE)),true);
  1572. if(!sym)
  1573. goto unlock;

  1575. //检查该内核中的符号和模块中此未定义的符号的crc值是否一致
  1576. if(!check_version(info->sechdrs,info->index.vers,name,mod,crc,owner)){
  1577. sym=ERR_PTR(-EINVAL);
  1578. goto getname;
  1579. }

  1581. //更新模块的依赖关系，即修正模块的source_list和target_list链表
  1582. err=ref_module(mod,owner);
  1583. if(err){
  1584. sym=ERR_PTR(err);
  1585. goto getname;
  1586. }

  1588. getname:
  1589. strncpy(ownername,module_name(owner),MODULE_NAME_LEN);

  1591. unlock:
  1592. mutex_unlock(&module_mutex);
  1593. return sym;
  1594. }

  1596. staticintapply_relocations(struct module*mod,conststruct load_info*info)
  1597. {
  1598. unsignedinti;
  1599. interr=0;

  1601. //遍历所有的节区
  1602. for(i=1;i<info->hdr->e_shnum;i++){
  1603. //对于重定位节区来说，其sh_info指向重定位所适用的节区的节区头部索引
  1604. //像.rel.text节区对应.text节区
  1605. unsignedintinfosec=info->sechdrs[i].sh_info;

  1607. //如果当前节区附加的节区的索引大于节区的数目，则info不是一个有效的索引，不做处理。
  1608. if(infosec>=info->hdr->e_shnum)
  1609. continue;

  1611. //如果节区在执行过程中不占内存，则 不需要进行处理。
  1612. if(!(info->sechdrs[infosec].sh_flags&SHF_ALLOC))
  1613. continue;

  1615. //此节区包含重定位表项，其中没有补齐，进行符号重定位，则调用apply_relocate来处理
  1616. if(info->sechdrs[i].sh_type==SHT_REL)
  1617. err=apply_relocate(info->sechdrs,info->strtab,info->index.sym,i,mod);
  1618. //此节区包含重定位表项，其中有补齐，进行符号重定位，则调用apply_relocate_add来处理
  1619. elseif(info->sechdrs[i].sh_type==SHT_RELA)
  1620. err=apply_relocate_add(info->sechdrs,info->strtab,info->index.sym,i,mod);
  1621. if(err<0)
  1622. break;
  1623. }
  1624. returnerr;
  1625. }

  1627. intapply_relocate(Elf32_Shdr*sechdrs,constchar*strtab,unsignedintsymindex,unsignedintrelsec,struct module*me)
  1628. {
  1629. //sechdrs表示节区头部表起始地址，strtab表示字符串节区的内容，symindex表示符号节区在节区头部表的索引值，relsec表示重定位节区的索引值(例如:.rel.text节区)，该节区的内容是重定位结构的表项
  1630. unsignedinti;
  1631. //找到重定位节区中的重定位表项起始地址
  1632. Elf32_Rel*rel=(void*)sechdrs[relsec].sh_addr;
  1633. Elf32_Sym*sym;
  1634. uint32_t*location;

  1636. DEBUGP("Applying relocate section %u to %u ",relsec,sechdrs[relsec].sh_info);

  1638. //遍历重定位节区中的重定位表项
  1639. for(i=0;i<sechdrs[relsec].sh_size/sizeof(*rel);i++){
  1640. //r_offset指定在此节区的区间r_offset处需要重新填写这个符号(.r_info指定)的绝对地址。找到重定位的位置，重定位节区relsec的sh_info表示重定位所适用的节区的节区头部索引值
  1641. //像.rel.text节区对应.text节区
  1642. location=(void*)sechdrs[sechdrs[relsec].sh_info].sh_addr+rel[i].r_offset;
  1643. //找到重定位的符号，ELF32_R_SYM(rel[i].r_info)表示这个符号在在符号表节区的内容中的索引值
  1644. sym=(Elf32_Sym*)sechdrs[symindex].sh_addr+ELF32_R_SYM(rel[i].r_info);

  1646. //sym->st_value是符号的绝对地址
  1647. switch(ELF32_R_TYPE(rel[i].r_info)){//重定位类型
  1648. caseR_386_32://绝对地址修正
  1649. //在要被修正地址处loc，把该地址下的值加上符号的绝对地址，等于这个位置处的取值就是符号地址了，一般来说*location初始值是0，加上符号绝对地址就能在此位置处找到符号地址了
  1650. *location+=sym->st_value;
  1651. break;
  1652. caseR_386_PC32://相对地址修正
  1653. /*Add the value,subtract its position*/
  1654. *location+=sym->st_value-(uint32_t)location;
  1655. break;
  1656. default:
  1657. pr_err("%s: Unknown relocation: %u ",me->name,ELF32_R_TYPE(rel[i].r_info));
  1658. return-ENOEXEC;
  1659. }
  1660. }
  1661. return 0;
  1662. }

  1664. staticintpost_relocation(struct module*mod,conststruct load_info*info)
  1665. {
  1666. //对模块的异常表进行排序
  1667. sort_extable(mod->extable,mod->extable+mod->num_exentries);

  1669. //因为mod对象已经复制到了内核中的最终位置，拷贝模块的percpu数据到mod对象的内存地址处。
  1670. percpu_modcopy(mod,(void*)info->sechdrs[info->index.pcpu].sh_addr,info->sechdrs[info->index.pcpu].sh_size);

  1672. //初始化module对象中中字符串表、符号表相关的成员，初始化core部分中的字符串表和符号表
  1673. add_kallsyms(mod,info);

  1675. /*Arch-specific module finalizing.*/
  1676. return module_finalize(info->hdr,info->sechdrs,mod);//x86是空函数
  1677. }

  1679. static void add_kallsyms(struct module*mod,conststruct load_info*info)
  1680. {
  1681. unsignedinti,ndst;
  1682. constElf_Sym*src;
  1683. Elf_Sym*dst;
  1684. char*s;
  1685. Elf_Shdr*symsec=&info->sechdrs[info->index.sym];//符号表节区

  1687. //符号表节区开始地址
  1688. mod->symtab=(void*)symsec->sh_addr;
  1689. //符号表项个数
  1690. mod->num_symtab=symsec->sh_size/sizeof(Elf_Sym);
  1691. //找到字符串节区
  1692. mod->strtab=(void*)info->sechdrs[info->index.str].sh_addr;

  1694. //遍历符号表节区中的符号表项,获取符号的属性(STB_LOCAL，STB_GLOBAL...)
  1695. for(i=0;i<mod->num_symtab;i++)
  1696. mod->symtab[i].st_info=elf_type(&mod->symtab[i],info);

  1698. //将core部分存储符号项的偏移地址info->symoffs加上core部分的起始地址得到存储符号项的地址。将符号表项的地址付给core_symtab成员，符号名称起始地址付给core_strtab成员
  1699. mod->core_symtab=dst=mod->module_core+info->symoffs;
  1700. mod->core_strtab=s=mod->module_core+info->stroffs;
  1701. src=mod->symtab;//符号表节区开始地址

  1703. //将符号表节区的符号项(若干的Elf_Sym结构)内容拷贝到core部分指定地址处
  1704. //将符号项中符号的名称拷贝到core部分指定地址处，并重新设置符号项中名称在符号字符串中的索引值st_name
  1705. for(ndst=i=0;i<mod->num_symtab;i++){
  1706. if(i==0||is_core_symbol(src+i,info->sechdrs,info->hdr->e_shnum)){
  1707. //符号项拷贝到mod->module_core+info->symoffs
  1708. dst[ndst]=src[i];
  1709. //重新设置符号名在mod->core_strtab中的索引值
  1710. dst[ndst++].st_name=s-mod->core_strtab;
  1711. //符号名称拷贝到mod->module_core+info->stroffs
  1712. s+=strlcpy(s,&mod->strtab[src[i].st_name],KSYM_NAME_LEN)+1;
  1713. }
  1714. }
  1715. mod->core_num_syms=ndst;//符号个数
  1716. }

  1718. staticintcomplete_formation(struct module*mod,struct load_info*info)
  1719. {
  1720. interr;

  1722. mutex_lock(&module_mutex);

  1724. //确认是否有重定义符号
  1725. err=verify_export_symbols(mod);
  1726. if(err<0)
  1727. goto out;

  1729. //模块bug相关操作
  1730. module_bug_finalize(info->hdr,info->sechdrs,mod);

  1732. //设置模块的状态
  1733. mod->state=MODULE_STATE_COMING;
  1734. out:
  1735. mutex_unlock(&module_mutex);
  1736. returnerr;
  1737. }

  1739. staticintverify_export_symbols(struct module*mod)
  1740. {
  1741. unsignedinti;
  1742. struct module*owner;
  1743. conststruct kernel_symbol*s;
  1744. struct{
  1745. conststruct kernel_symbol*sym;
  1746. unsignedintnum;
  1747. }arr[]={
  1748. {mod->syms,mod->num_syms},
  1749. {mod->gpl_syms,mod->num_gpl_syms},
  1750. {mod->gpl_future_syms,mod->num_gpl_future_syms},
  1751. #ifdef CONFIG_UNUSED_SYMBOLS
  1752. {mod->unused_syms,mod->num_unused_syms},
  1753. {mod->unused_gpl_syms,mod->num_unused_gpl_syms},
  1754. #endif
  1755. };

  1757. //遍历模块中的符号，在内核中检查是否已经导出，若已经导出该符号，则给出著名error：“exports duplicate symbol”
  1758. for(i=0;i<ARRAY_SIZE(arr);i++){
  1759. for(s=arr[i].sym;s<arr[i].sym+arr[i].num;s++){
  1760. if(find_symbol(s->name,&owner,NULL,true,false)){
  1761. printk(KERN_ERR"%s: exports duplicate symbol %s"" (owned by %s) ",mod->name,s->name,module_name(owner));
  1762. return-ENOEXEC;
  1763. }
  1764. }
  1765. }
  1766. return 0;
  1767. }

  1769. staticintdo_init_module(struct module*mod)
  1770. {
  1771. intret=0;

  1773. current->flags&=~PF_USED_ASYNC;

  1775. //内核通知
  1776. blocking_notifier_call_chain(&module_notify_list,MODULE_STATE_COMING,mod);

  1778. //SetROandNX regionsforcore
  1779. set_section_ro_nx(mod->module_core,mod->core_text_size,mod->core_ro_size,mod->core_size);

  1781. //SetROandNX regionsforinit
  1782. set_section_ro_nx(mod->module_init,mod->init_text_size,mod->init_ro_size,mod->init_size);

  1784. //调用模块构造函数
  1785. do_mod_ctors(mod);

  1787. //启动模块
  1788. if(mod->init!=NULL)
  1789. ret=do_one_initcall(mod->init);

  1791. if(ret<0){
  1792. /*Init routine failed:abort.Trytoprotect us from buggy refcounters.*/
  1793. mod->state=MODULE_STATE_GOING;
  1794. synchronize_sched();
  1795. module_put(mod);
  1796. blocking_notifier_call_chain(&module_notify_list,MODULE_STATE_GOING,mod);
  1797. free_module(mod);
  1798. wake_up_all(&module_wq);
  1799. return ret;
  1800. }
  1801. if(ret>0){
  1802. printk(KERN_WARNING"%s: '%s'->init suspiciously returned %d, it should follow 0/-E convention ""%s: loading module anyway... ",__func__,mod->name,ret,__func__);
  1803. dump_stack();
  1804. }

  1806. //模块初始化完成，更改状态，通知内核
  1807. mod->state=MODULE_STATE_LIVE;
  1808. blocking_notifier_call_chain(&module_notify_list,MODULE_STATE_LIVE,mod);

  1810. if(current->flags&PF_USED_ASYNC)
  1811. async_synchronize_full();
  1812. mutex_lock(&module_mutex);
  1813. /*Drop initial reference.*/
  1814. module_put(mod);
  1815. rim_init_extable(mod);
  1816. #ifdef CONFIG_KALLSYMS
  1817. mod->num_symtab=mod->core_num_syms;
  1818. mod->symtab=mod->core_symtab;
  1819. mod->strtab=mod->core_strtab;
  1820. #endif
  1821. //释放初始化部分空间，这部分只是在初始化有效，初始化结束回收资源，清空
  1822. unset_module_init_ro_nx(mod);
  1823. module_free(mod,mod->module_init);
  1824. mod->module_init=NULL;
  1825. mod->init_size=0;
  1826. mod->init_ro_size=0;
  1827. mod->init_text_size=0;
  1828. mutex_unlock(&module_mutex);
  1829. wake_up_all(&module_wq);
  1830. return 0;
  1831. }

  1833. int__init_or_module do_one_initcall(initcall_t fn)
  1834. {
  1835. intcount=preempt_count();
  1836. intret;
  1837. char msgbuf[64];

  1839. if(initcall_debug)
  1840. ret=do_one_initcall_debug(fn);
  1841. else
  1842. ret=fn();//执行模块的init_module函数

  1844. msgbuf[0]=0;

  1846. if(preempt_count()!=count){
  1847. sprintf(msgbuf,"preemption imbalance ");
  1848. preempt_count()=count;
  1849. }

  1851. if(irqs_disabled()){
  1852. strlcat(msgbuf,"disabled interrupts ",sizeof(msgbuf));
  1853. local_irq_enable();
  1854. }
  1855. WARN(msgbuf[0],"initcall %pF returned with %s ",fn,msgbuf);

  1857. return ret;
  1858. }

标签：#info#shf#elf | 浏览：833 | 发布日期：

免责声明：文章转载自《insmod过程详解【转】》仅用于学习参考。如对内容有疑问，请及时联系本站处理。

上篇解决：Vue中给input框手动赋值，视图却不更新关于MongoDB 配置安全选项(security)后无法正常启动(Unrecognized option: security)下篇

宿迁高防，2C2G15M，22元/月；香港BGP，2C5G5M，25元/月 雨云优惠码：MjYwNzM=

相关文章

python 脚本检测python 版本

通过sys 模块的sys_info可以返回当前python 的版本信息， 其返回值是一个元组， 比如（2, 6， 6， 'final', 0）; 表示当前版本为2.6.6 , 我们可以利用这个变量的值判断python版本； #!/usr/bin/python import sys if sys.version_info < (2, 7):...

结对项目：一寸时光APP（日程管理）二

建立数据库 package com.example.myapplication3.db; import android.content.ContentValues;import android.content.Context;import android.database.Cursor;import android.database.sqlite.SQLi...

HBase 伪分布式环境搭建及基础命令使用

一.前提条件： (1)文件存储在HDFS文件系统之上。因此必须启动hadoop服务。（namenode,datanode,resourcemanager,nodemanager,historyserver）(2)源文件依赖于zookeeper。因此需要启动zookeeper服务。（./zkServer ./zkCli.sh） 二，HBase的安装（版本:5...

iOS 测试 | iOS 自动化性能采集

​今天小编跟大家分享一篇来自学院内部学员的技术分享，本文主要介绍了作者在进行 iOS 自动化性能采集的一些经验，希望对大家在进行 iOS 自动化测试时有一些启发。 不要为小事遮住视线，我们还有更大的世界 前言 对于iOS总体生态是比较封闭的,相比Android没有像adb这种可以查看内存、cpu的命令.在日常做性能测试,需要借助xcode中instrum...

Tapestry5之onActivate和onPassivate

T5有三种类型的事件，分别是EventLink，ActionLink，Form。并且前两种是通过HTTP GET从服务器获得信息的，最后一种是通过HTTP POST获得信息的。 还有一点儿很重要的就是EventLink和ActionLink从服务器端获得想要的信息的方式是：GET/REDIRECT/GET。FORM的方式是：POST/REDIRECT/GET...

gdb 调试

昨天下班之间请教师父一个panic的解法，见他用gdb调试，真的很厉害，看到堆栈的东西，跟踪堆栈，定位报错的panic出错的具体汇编语句，很惊吓，感叹自己也是用gdb很久的人了，他的很多用法还不知道，特补充下vmlinux和gdb的相关知识在此作为笔记。 （gdb）list *0xc33310a0 (查看0xc33310a0地址所在的源代码段，常用来查看报...

最新文章

随机推荐

思享工具箱导航