内核启动参数详解

今天药忘吃喽~ 2022-08-06 02:07 654阅读 0赞

bootload在启动linux内核时可以传递一些参数，对linux内核进行配置。  
bootload 用的是uboot\_1\_1\_4  
linux内核用的是linux\_2\_6\_24   
  
**一、uboot启动内核**  
当在uboot下敲bootm，或啥都不做等上N秒后，uboot会调用do\_bootm函数  
文件uboot\_1\_1\_4/common/cmd\_bootm.c

1.  int do\_bootm(cmd\_tbl\_t \*cmdtp,  int flag, int argc, char \*argv\[\])  
    
2.  \{   
    
3.  image\_header\_t \*hdr = &header;//这里就是linux镜像的头部了  
    
4.   hdr\->ih\_arch里存放的是cpu架构类型  
    
5.  //可选值有IH\_CPU\_PPC、IH\_CPU\_ARM、IH\_CPU\_I386、IH\_CPU\_MIPS、IH\_CPU\_NIOS等等  
    
6.   hdr\->ih\_os里操作系统类型  
    
7.  //可选值有IH\_OS\_LINUX、IH\_OS\_NETBSD、IH\_OS\_LYNXOS、IH\_OS\_RTEMS等等  
    
8.  //最终，我们调用do\_bootm\_linux()  
    
9.  \}  
    
10.   
    
11. int do\_bootm\_linux(......)  
    
12. \{   
    
13. if ((s = getenv("bootargs")) ==  NULL)  
    
14. s = "";  
    
15. strcpy (cmdline, s);  
    
16. strcat(cmdline," ");  
    
17. strcat(cmdline,config.cmdline);  
    
18. cmd\_start = (ulong)&cmdline\[0\];  
    
19. cmd\_end = cmd\_start  \+ strlen(cmdline);  
    
20. kernel = (void (\*)(bd\_t \*, ulong, ulong, ulong, ulong))hdr\->ih\_ep;  
    
21. /\*  
    
22. \* Linux Kernel Parameters:  
    
23. \* r3: ptr to board info data  
    
24. \* r4: initrd\_start or 0 if no initrd  
    
25. \* r5: initrd\_end \- unused if r4  is 0  
    
26. \* r6: Start of command line string  
    
27. \* r7:  End of command line string  
    
28. \*/  
    
29. (\*kernel) (kbd, initrd\_start, initrd\_end, cmd\_start, cmd\_end);  
    
30. \}

linux内核启动需要5个参数，则使用r3 -- r7 这五个GPR寄存器(为啥？ [看这个帖子][Link 1])  
其中r6，r7里面存的就是cmd\_line的起始地址和长度  
cmd\_line来自环境变量bootargs、全局变量 config.cmdline

1.  typedef struct CE\_CONFIG  \{   
    
2.  char location\[32\]; /\* CE  location \*/  
    
3.  char status\[32\]; /\* CE status  \*/  
    
4.  char hostname\[32\]; /\* host name  \*/  
    
5.  char kernel\[32\]; /\* kernel file name \*/  
    
6.  char image\[32\]; /\* ramdisk file name \*/  
    
7.  char masterip\[8\]; /\* kernel multicast IP \*/  
    
8.  char slaveip\[8\]; /\* ramdisk multicast IP \*/  
    
9.  char type\[32\]; /\* CE type  \*/  
    
10. char pce\[16\];  
    
11. long imagesize;  
    
12. char cmdline\[CMDLINE\_LEN\]; /\* kernel command line \*/  
    
13. \} ce\_config;  
    
14. ce\_config config;

**二、linux内核启动**  
从uboot跳转到内核指令地址后，内核第一件事就是保存bootload传来的参数  
linux\_2\_6\_24/arch/ppc/kernel/head\_fsl\_booke.S

1.  80 .text
2.  81 \_GLOBAL(\_stext)
3.  82 \_GLOBAL(\_start)
4.  83 /\*
5.  84 \* Reserve a word at a fixed location to store the address
6.  85 \* of abatron\_pteptrs
7.  86 \*/
8.  87 nop
9.  88 /\*
10. 89 \* Save parameters we are passed
11. 90 \*/
12. 91 mr r31,r3
13. 92 mr r30,r4
14. 93 mr r29,r5
15. 94 mr r28,r6
16. 95 mr r27,r7
17. 96 li r24,0 /\* CPU number \*/

接着在执行machine\_init的时候，将上面这些参数作为形参导入

1.  446 \* Decide what sort of machine this is and initialize the MMU.
2.  447 \*/
3.  448 mr r3,r31
4.  449 mr r4,r30
5.  450 mr r5,r29
6.  451 mr r6,r28
7.  452 mr r7,r27
8.  453 /\*
9.  454 \* Find out what kind of machine we're on and save any data we need
10. 455 \* from the early boot process (devtree is copied on pmac by prom\_init()).
11. 456 \* This is called very early on the boot process, after a minimal
12. 457 \* MMU environment has been set up but before MMU\_init is called.
13. 458 \*/
14. 459
15. 460 bl machine\_init
16.   
    
17. mahine\_init（r3，r4, r5, r6, r7）
18. \--> platform\_init(r3, r4, r5, r6, r7);

linux\_2\_6\_24/arch/ppc/platforms/85xx/mpc85xx\_cds\_common.c

1.  platform\_init(unsigned long r3, unsigned long r4, unsigned long r5,  
    
2.  unsigned long r6, unsigned long r7)  
    
3.  \{   
    
4.  /\*  
    
5.  \* If we were passed in a board information, copy it into the  
    
6.  \* residual data area.  
    
7.  \*/  
    
8.  if (r3)  
    
9.  memcpy((void \*) \_\_res, (void \*) (r3 \+ KERNELBASE), sizeof (bd\_t));  
    
10.   
    
11. \#if defined(CONFIG\_BLK\_DEV\_INITRD)  
    
12. /\*  
    
13. \* If the init RAM disk has been configured in,  and there's a valid  
    
14. \* starting address  for it, set it up.  
    
15. \*/  
    
16. if (r4) \{   
    
17. initrd\_start = r4  \+ KERNELBASE;  
    
18. initrd\_end = r5  \+ KERNELBASE;  
    
19. \}  
    
20. \#endif /\* CONFIG\_BLK\_DEV\_INITRD \*/  
    
21.   
    
22. /\* Copy the kernel command line arguments to a safe place. \*/  
    
23. if (r6) \{   
    
24. \*(char \*)  (r7 \+ KERNELBASE) = 0;  
    
25. strcpy(cmd\_line, (char \*) (r6 \+ KERNELBASE));  
    
26. \}  
    
27.   
    
28. //......省略  
    
29. return;  
    
30. \}

好，现在bootload传来的启动参数全保存在全局变量cmd\_line里面,接下来就要处理cmd\_line了  
  
 **三、处理内核启动参数**  
  
下面的函数对无关代码进行了省略

1.  void \_\_init start\_kernel(void)  
    
2.  \{   
    
3.  char \* command\_line;  
    
4.  setup\_arch(&command\_line);  
    
5.  strlcpy(boot\_command\_line, cmd\_line, COMMAND\_LINE\_SIZE);  
    
6.  command\_line = cmd\_line; //这个cmd\_line就是从bootload里传来的  
    
7.  parse\_early\_param();  
    
8.  //  \-\-> parse\_args("early options", tmp\_cmdline, NULL, 0, do\_early\_param);  
    
9.    
    
10. setup\_command\_line(command\_line);  
    
11. saved\_command\_line = alloc\_bootmem(strlen (boot\_command\_line)\+1);  
    
12. static\_command\_line = alloc\_bootmem(strlen (command\_line)\+1);  
    
13. strcpy (saved\_command\_line, boot\_command\_line);  
    
14. strcpy (static\_command\_line, command\_line);  
    
15.   
    
16. parse\_args("Booting kernel", static\_command\_line, \_\_start\_\_\_param,  
    
17. \_\_stop\_\_\_param \- \_\_start\_\_\_param, &unknown\_bootoption);  
    
18. \}

最重要的就是看parse\_args()这个函数了

1.  int parse\_args(const char \*name,  // description 字符串，可无视  
    
2.  char \*args, // 待解析的字符串args  
    
3.  struct kernel\_param \*params, // 内核的数据结构数组  
    
4.  unsigned num,  // 数组中元素个数  
    
5.  int (\*unknown)(char \*param, char  \*val))  // 函数指针  
    
6.  \{   
    
7.  while(args中还有p=v对)\{   
    
8.  从args中取出p=v对  
    
9.  遍历params数组，若有p对应的数组元素的话，调用数组元素的set函数  
    
10. 执行unknow(p,v)  
    
11. \}  
    
12. \}

start\_kernel里有如下调用parse\_early\_param();  
最终调用 parse\_args("early options", tmp\_cmdline, NULL, 0, do\_early\_param);  
实际上就是从命令字符串中解析出一个个的p=v对后，对其调用do\_early\_param

1.  static int \_\_init do\_early\_param(char \*param, char  \*val)  
    
2.  \{   
    
3.  struct obs\_kernel\_param \*p;  
    
4.    
    
5.  for (p  = \_\_setup\_start; p  < \_\_setup\_end; p\+\+) \{   
    
6.  if ((p\->early && strcmp(param, p\->str) == 0) //注意此处的p\->early  
    
7.  || (strcmp(param, "console")  == 0 && strcmp(p\->str, "earlycon")  == 0)) \{   
    
8.  if (p\->setup\_func(val) != 0) //执行挂在上面的钩子函数  
    
9.  printk(KERN\_WARNING  "Malformed early option '%s'\\n", param);  
    
10. \}  
    
11. \}  
    
12. return 0;  
    
13. \}

\_\_setup\_start和\_\_setup\_end是什么东西呢

1.  \#define early\_param(str, fn) \\  
    
2.  \_\_setup\_param(str, fn, fn, 1)  
    
3.    
    
4.  \#define \_\_setup(str, fn) \\  
    
5.  \_\_setup\_param(str, fn, fn, 0)  
    
6.    
    
7.  \#define \_\_setup\_param(str, unique\_id, fn, early) \\  
    
8.  static char \_\_setup\_str\_\#\#unique\_id\[\] \_\_initdata \_\_aligned(1) = str;  \\  
    
9.  static struct obs\_kernel\_param \_\_setup\_\#\#unique\_id  \\  
    
10. \_\_attribute\_used\_\_ \\  
    
11. \_\_attribute\_\_((\_\_section\_\_(".init.setup"))) \\  
    
12. \_\_attribute\_\_((aligned((sizeof(long))))) \\  
    
13. = \{  \_\_setup\_str\_\#\#unique\_id, fn, early \}

linux\_2\_6\_24/arch/powerpc/kernel/vmlinux.lds.S

1.   122 .  = ALIGN(16);  
    
2.  123 \_\_setup\_start  = .;  
    
3.  124 .init.setup : \{   \*(.init.setup) \}  
    
4.  125 \_\_setup\_end  = .;  
    
5.  126 \_\_initcall\_start =  .;  
    
6.  127 .initcall.init : \{   
    
7.  128 INITCALLS  
    
8.  129 \}

宏early\_param和 \_\_setup\_param初始化了一个struct obs\_kernel\_param结构并放到节.init.setup中  
两个宏的区别就是 early\_param把 obs\_kernel\_param.early初始化为1，\_\_setup\_param初始化为0  
  
do\_early\_param() 遍历节.init.setup（此节可以看成一个数组）只处理被early\_param()链接进去的元素  
如果有和p匹配的数据结构元素，调用其setup\_func(v)指针函数  
比如参数"mem=xx"由 early\_parse\_mem() 来处理  
参数"numa=xx"有 early\_numa() 来处理  
还有有哪些呢，搜搜看，我擦，还真多

1.  arch/powerpc/mm/numa.c:707:early\_param("numa", early\_numa);  
    
2.  arch/powerpc/xmon/xmon.c:2656:early\_param("xmon", early\_parse\_xmon);  
    
3.  arch/powerpc/kernel/prom.c:431:early\_param("mem", early\_parse\_mem);  
    
4.  arch/powerpc/kernel/setup\_64.c:138:early\_param("smt-enabled", early\_smt\_enabled);  
    
5.  arch/powerpc/kernel/setup\_32.c:150:early\_param("wdt", early\_parse\_wdt);  
    
6.  arch/powerpc/kernel/setup\_32.c:159:early\_param("wdt\_period", early\_parse\_wdt\_period);  
    
7.  arch/ppc/kernel/setup.c:611:early\_param("wdt", early\_parse\_wdt);  
    
8.  arch/ppc/kernel/setup.c:620:early\_param("wdt\_period", early\_parse\_wdt\_period);  
    
9.  arch/ppc/kernel/setup.c:783:early\_param("earlycon", setup\_early\_serial8250\_console);  
    
10. arch/ppc/kernel/setup.c:784:early\_param("mem", early\_parse\_mem);  
    
11. drivers/serial/8250\_early.c:313:early\_param("earlycon", setup\_early\_serial8250\_console);  
    
12. drivers/pci/pci.c:1617:early\_param("pci", pci\_setup);  
    
13. init/main.c:155:early\_param("nosmp", nosmp);  
    
14. init/main.c:166:early\_param("maxcpus", maxcpus);  
    
15. init/main.c:1694:early\_param("earlycon", setup\_early\_serial8250\_console);  
    
16. init/main.c:1695:early\_param("mem", early\_parse\_mem);  
    
17. mm/page\_alloc.c:2180:early\_param("numa\_zonelist\_order", setup\_numa\_zonelist\_order);  
    
18. mm/page\_alloc.c:4239:early\_param("kernelcore", cmdline\_parse\_kernelcore);  
    
19. mm/page\_alloc.c:4240:early\_param("movablecore", cmdline\_parse\_movablecore);

start\_kernel()里又调用  
parse\_args("Booting kernel", static\_command\_line, \_\_start\_\_\_param,  
\_\_stop\_\_\_param - \_\_start\_\_\_param, &unknown\_bootoption);  
实际上就是从命令字符串中解析出一个个的p=v对后，对其调用unknown\_bootoption  
遍历节.init.setup（此节可以看成一个数组）只处理由\_\_setup(str, fn) 链接进去的数组元素  
有匹配p的话，调用数组元素的setup\_func(v)钩子函数

1.  arch/powerpc/kernel/iommu.c:81:\_\_setup("protect4gb=", setup\_protect4gb);  
    
2.  arch/powerpc/kernel/iommu.c:82:\_\_setup("iommu=", setup\_iommu);  
    
3.  arch/powerpc/kernel/irq.c:1155:\_\_setup("noirqdistrib", setup\_noirqdistrib);  
    
4.  arch/powerpc/kernel/setup\_32.c:173:\_\_setup("l2cr=", ppc\_setup\_l2cr);  
    
5.  arch/powerpc/kernel/crash\_dump.c:73:\_\_setup("elfcorehdr=", parse\_elfcorehdr);  
    
6.  arch/powerpc/kernel/crash\_dump.c:83:\_\_setup("savemaxmem=", parse\_savemaxmem);  
    
7.  arch/powerpc/kernel/idle.c:51:\_\_setup("powersave=off", powersave\_off);  
    
8.  //此处略去N多行

**三、常用的内核启动参数**  
  
Linux的内核参数是以空格分开的一个字符串列表，通常具有如下形式：  
name\[=value\_1\]\[,value\_2\]...\[,value\_10\]  
  
比如你在启动时设置参数name＝a,b,c,d，内核搜索bootsetups数组，如果发现“name”已注册，则调用“name”的设置函数如name\_setup()，并把a,b,c,d传递给name\_setup()执行。  
所有型如“name＝value”参数，如果没有被上面所述的设置函数接收，将被解释为系统启动后的环境变量，比如“TERM=vt100”就会被作为一个启动时参数。  
所有没有被内核设置函数接收也没又被设置成环境变量的参数都将留给init进程处理，比如“single”。  
  
**1、init＝...**  
设置内核执行的初始化进程名，如果该项没有设置，内核会按顺序尝试/etc/init，  
/bin/init，/sbin/init， /bin/sh，如果所有的都没找到，内核会抛出 kernel panic：的错误。  
  
**2、nfsaddrs=...**  
设置从网络启动时NFS的启动地址，已字符串的形式给出。  
  
**3、nfsroot=...**  
设置网络启动时的NFS根名字，如果该字符串不是以 "/"、","、"."开始，默认指向“/tftp-boot”。  
以上2、3在无盘站中很有用处。  
  
**4、no-hlt**  
该选项仅当定义了CONFIG\_BUGi386时才能用，一些早期的i486DX-100芯片在处理“hlt”指令时会有问题，执行该指令后不能可靠的返回操作系统，使用该选项，可以让linux系统在CPU空闲的时候不要挂起CPU。  
  
**5、root=...**  
该参数告诉内核启动时使用哪个设备作为根文件系统。比如可以指定根文件为hda8：root=/dev/hda8。  
  
**6、ro和rw**  
ro参数告诉内核以只读方式加载根文件系统，以便进行文件系统完整性检查，比如运行fsck；rw参数告诉内核以读写方式加载根文件系统，这是默认值。  
  
**7、reserve=...**  
保留端口号。格式：reserve=iobase,extent\[,iobase,extent\]...，用来保护一定区域的I/O端口不被设备驱动程序自动探测。在某些机器上，自动探测会失败，或者设备探测错误或者不想让内核初始化设备时会用到该参数；比如： reserve=0x300,32 device=0x300，除device=0x300外所有设备驱动不探测 0x300-0x31f范围的I/O端口。  
  
**8、mem=...**  
限制内核使用的内存数量。早期BIOS设计为只能识别64M以下的内存，如果你的内存数量大于64M，你可以指明，如果你指明的数量超过了实际安装的内存数量，系统崩溃是迟早的事情。如：mem=0x1000000意味着有16M内存，如果是 mem=0x6000000，就是96M内存了。  
  
**9、panic=N**  
默认情况，内核崩溃－－kernel panic 后会宕机而不会重启，你可以设置宕机多少秒之后重启机器；也可以在/proc/sys/kernel/panic文件里设置。  
  
**10、reboot=\[warm|cold\]\[,\[bios|hard\]\]**  
该选项仅当定义了CONFIG\_BUGi386时才能用。2.0.22的内核重启默认为cool reboot，warm reboot 更快，使用"reboot=bios"可以继承bios的设置。  
  
**11、debug**  
linux的日志级别比较多(详细信息可以参看linux/kernel.h)，一般地，日志的守护进程klogd只把比DEBUG级别高的日志写进磁盘；如果使用该选项，klogd也把内核的DEBUG信息写进日志。  
  
**12、profile=N**  
在做内核开发的时候，如果想清楚的知道内核在什么地方耗用了多少CPU的时钟周期，可以使用核心的分析函数设置变量prof\_shift为非0值，有两种方式可以实现：一种是在编译时指定，另一种就是通过“profile=”来指定； 他给出了一个相当于最小单位－－即时钟周期；系统在执行内核代码的时候， profile\[address >;>; prof\_shift\]的值就会累加，你也可以从 /proc/profile得到关于它的一些信息。  
  
**13、swap=N1,N2,N3,N4,N5,N6,N7,N8**  
设置内核交换算法的八个参数：max\_page\_age, page\_advance, page\_decline,page\_initial\_age, age\_cluster\_fract, age\_cluster\_min, pageout\_weight,bufferout\_weight。  
  
**14、buff=N1,N2,N3,N4,N5,N6**  
设置内核缓冲内存管理的六个参数：max\_buff\_age, buff\_advance, buff\_decline,buff\_initial\_age, bufferout\_weight, buffermem\_grace。  
  
**使用 RAMDISK的参数**  
  
(仅当内核配置并编译了 CONFIG\_BLK\_DEV\_RAM)。一般的来说，使用ramdisk并不是一件好事，系统自己会更加有效的使用可用的内存；但是，在启动或者制作启动盘时，使用ramdisk可以很方便的装载软盘等设备上的映象(尤其是安装程序、启动过程中)，因为在正真使用物理磁盘之前，必须要加载一些必要的模块，比如文件系统模块，scsi驱动等(可以参见我的initrd-x.x.x.img文件分析－制作安装程序不支持的根文件系统)。  
  
早期的ramdisk(比如1.3.48的核心)是静态分配的，必须以ramdisk=N来指定ramdisk的大小；现在ramdisk可以动态增加。一共有四个参数，两个布尔型，两个整形。  
  
**1、load\_ramdisk=N**  
如果N＝1，就加载ramdisk；如果N＝0，就不加载ramdisk；默认值为0。  
  
**2、prompt\_ramdisk=N**  
N＝1，提示插入软盘；N＝0，不提示插入软盘；默认为1。  
  
**3、ramdisk\_size=N或者ramdisk=N**  
设定ramdisk的最大值为N KB,默认为4096KB。  
  
**4、ramdisk\_start=N**  
设置ramdisk的开始块号为N，当ramdisk有内核的映象文件是需要这个参数。  
  
**5、noinitrd**  
(仅当内核配置了选项 CONFIG\_BLK\_DEV\_RAM和CONFIG\_BLK\_DEV\_INITRD)现在的内核都可以支持initrd了，引导进程首先装载内核和一个初始化的ramdisk，然后内核将initrd转换成普通的ramdisk，也就是读写模式的根文件系统设备。然后linuxrc执行，然后装载真正的根文件系统，之后ramdisk被卸载，最后执行启动序列，比如/sbin/init。  
  
选项noinitrd告诉内核不执行上面的步骤，即使内核编译了initrd，而是把initrd的数据写到 /dev/initrd，只是这是一个一次性的设备。  
  
\------------------------------ 请叫我华丽的分割线 --------------------------------  
  
系统起来以后，可以敲 cat /proc/cmdline 来查看内核启动参数

[Link 1]: http://blog.chinaunix.net/space.php?uid=24148050&do=blog&id=339351