Linux移植之tag参数列表解析过程分析

172        __setup_param(str, fn, fn, 0)

先看__setup_param。它定义了两个参数，一个是char型的字符串__setup_str_##unique_id，另外一个为obs_kernel_param 结构体，它位于includelinuxInit.h。obs_kernel_param 结构体位于

.init.setup段，它的str参数即为__setup_str_##unique_id。__setup宏调用__setup_param传入两个参数str与fn，代表命令行名字与处理函数。

148    struct obs_kernel_param {

149        const char *str;

150        int (*setup_func)(char *);

151        int early;

152    };

2)、root=/dev/mtdblock3参数解析过程

回到initMain.c 中的start_kernel函数继续分析

525    setup_arch(&command_line);//返回的command_line是还未处理的命令行参数存放的首地址

526    setup_command_line(command_line);//static_command_line存放未处理的命令行参数，saved_command_line存放所有的命令行参数

544    printk(KERN_NOTICE 'Kernel command line: %sn', boot_command_line);//打印命令行参数

545        parse_early_param();//一些前期代码的初始化

546        parse_args('Booting kernel', static_command_line, __start___param,

547               __stop___param - __start___param,

548               &unknown_bootoption);//后续的命令处理

其中parse_early_param函数是对一些early属性的命令后做解析，它位于.early_param.init段，包括：cachepolicy=、nocache、nowb、ecc=、initrd=、mem=等等，我们的参数没有涉及到这类命令，所以不去细细的分析这个函数了。

重点关注parse_args函数，先分析函数的参数：

static_command_line                         ：存放未处理的命令行参数首地址

__start___param                                 : 内核参数的存放地址，它处于__param段

__stop___param - __start___param  : 内核参数大小

unknown_bootoption                          : 处理函数

接着看到parse_args函数内部阶段，它位于kernelParams.c 下，可以看到在这里会将所有命令行处理完成。

144    while (*args) {//循环处理剩余的命令行，直到全部处理完成

145        int ret;

146        int irq_was_disabled;

147

148        args = next_arg(args, ¶m, &val);//找出下一个命令行参数*param为命令名称，*val为参数值

149        irq_was_disabled = irqs_disabled();

150        ret = parse_one(param, val, params, num, unknown);//处理

接着看到处理函数parse_one，它位于kernelParams.c 下。这里面还判断了一个内核的参数，我们传入的参数没有内核参数，内核参数存在于__param段，有：nousb、block2mtd_setup等等，我们传入的命令行参数没有内核参数，所以不关心

49    static int parse_one(char *param,

50                 char *val,

51                 struct kernel_param *params, 

52                 unsigned num_params,

53                 int (*handle_unknown)(char *param, char *val))

54    {

55        unsigned int i;

56

57        /* Find parameter */

58        for (i = 0; i < num_params; i++) {//从__param段找出与命令行参数相同的名字

59            if (parameq(param, params[i].name)) {

60                DEBUGP('They are equal!  Calling %pn',

61                       params[i].set);

62                return params[i].set(val, ¶ms[i]);//如果是内核的参数，那么直接传给内核参数，然后返回。

63            }

64        }

65    

66        if (handle_unknown) {//如果不是内核的参数，并且处理函数存在

67            DEBUGP('Unknown argument: calling %pn', handle_unknown);

68            return handle_unknown(param, val);//调用处理函数处理

69        }

70

71        DEBUGP('Unknown argument `%s'n', param);

72        return

接着看到handle_unknown函数，即unknown_bootoption函数，它位于initMain.c中，截取其中的一段程序

260        /* Change NUL term back to '=', to make 'param' the whole string. */

261        if (val) {//如果val不为空，做一些处理

262            /* param=val or param='val'? */

263            if (val == param+strlen(param)+1)

264                val[-1] = '=';

265            else if (val == param+strlen(param)+2) {

266                val[-2] = '=';

267                memmove(val-1, val, strlen(val)+1);

268                val--;

269            } else

270                BUG();

271        }

272    

273        /* Handle obsolete-style parameters */

274        if (obsolete_checksetup(param))

275            return 0;

接着看到obsolete_checksetup函数，它同样位于initMain.c中，这个函数大致的意思就是在.init.setup中找到符合的命令行参数，如果不是前期已经处理的参数（即early值为0的参数，那么调用处理函数处理它。它由__setup宏定义或者__setup_null_param宏定义（这两个宏定义前面已经介绍过了），搜索一下这两个宏定义，发现了__setup('root=', root_dev_setup);、__setup('init=', init_setup);、__setup('console=', console_setup);都在这里面被处理。

190    static int __init obsolete_checksetup(char *line)

191    {

192        struct obs_kernel_param *p;

193        int had_early_param = 0;

194    

195        p = __setup_start;//.init.setup的首地址

196        do {

197            int n = strlen(p->str);

198            if (!strncmp(line, p->str, n)) {//在.init.setup中寻找相符的命令行参数

199                if (p->early) {//如果early大于0，那么这个参数在前面已经处理过了

200                    /* Already done in parse_early_param?

201                     * (Needs exact match on param part).

202                     * Keep iterating, as we can have early

203                     * params and __setups of same names 8( */

204                    if (line[n] == '' || line[n] == '=')

205                        had_early_param = 1;

206                } else if (!p->setup_func) {//如果处理函数不存在，则报错

207                    printk(KERN_WARNING 'Parameter %s is obsolete,'

208                           ' ignoredn', p->str);

209                    return 1;

210                } else if (p->setup_func(line + n))//调用处理函数处理

211                    return 1;

212            }

213            p++;

214        } while (p < __setup_end);

215

216        return had_early_param;

217    }

接着分析__setup('root=', root_dev_setup)宏，它位于kernelPrintk.c下，可以看到它调用的是root_dev_setup函数来处理root=参数，接着看root_dev_setup函数

211    static int __init root_dev_setup(char *line)

212    {

213        strlcpy(saved_root_name, line, sizeof(saved_root_name));

214        return 1;

215    }

216

217    __setup('root=', root_dev_setup);

可以看到它的处理函数直接将root命令行参数拷贝到saved_root_name里，接着搜索一下在哪里调用的saved_root_name。找到了在initDo_mounts.c 中的prepare_namespace函数用到了它，这个函数的作用是挂接根文件系统的。列出部分代码：如何挂接根文件系统后面说明

430        if (saved_root_name[0]) {

431            root_device_name = saved_root_name;//将saved_root_name赋给root_device_name

432            if (!strncmp(root_device_name, 'mtd', 3)) {

433                mount_block_root(root_device_name, root_mountflags);

434                goto out;

435            }

436            ROOT_DEV = name_to_dev_t(root_device_name);

437            if (strncmp(root_device_name, '/dev/', 5) == 0)

438                root_device_name += 5;

439        }

3)、init=/linuxrc参数解析过程

前面已经分析了命令行参数的提取过程，这里直接看到宏定义__setup('init=', init_setup)。处理init=参数的是init_setup函数，来到Init_setup函数，它位于

initMain.c 中

315    static int __init init_setup(char *str)

316    {

317        unsigned int i;

318

319        execute_command = str;

320        /*

321         * In case LILO is going to boot us with default command line,

322         * it prepends 'auto' before the whole cmdline which makes

323         * the shell think it should execute a script with such name.

324         * So we ignore all arguments entered _before_ init=... [MJ]

325         */

326        for (i = 1; i < MAX_INIT_ARGS; i++)

327            argv_init[i] = NULL;

328        return 1;

329    }

330    __setup('init=', init_setup);

可以看到init_setup函数直接将init=的命令行参数拷贝到execute_command 中，搜索execute_command ,在initMain.c函数下找到了init_post函数，这是start_kernel函数最后调用的一个函数rest_init建立的一个进程函数。取出部分内容，可以看到execute_command是内核运行的根文件系统上的第一个进程