QEMU源码全解析5 —— QEMU参数解析（5）

于 2023-07-13 09:47:34 发布
阅读量365 收藏
点赞数
分类专栏： KVM QEMU/KVM 文章标签： QEMU/KVM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接： https://blog.csdn.net/phmatthaus/article/details/131692003
版权
QEMU/KVM 同时被 2 个专栏收录
123 篇文章 36 订阅 ¥49.90 ¥99.00
已订阅 8折续费
KVM
88 篇文章 19 订阅
订阅专栏
您已是超级会员，正在免费阅读会员专享内容
查看更多超级会员权益
本文详细探讨了QEMU参数解析过程，特别是以-device参数为例，分析了在softmmu/vl.c的main函数中的qemu_init函数如何处理参数。通过查找lookup_opt函数和qemu_opts_parse_noisily以及qemu_find_opts的源码，揭示了QEMU如何解析和应用设备选项。后续将深入解析opt_parse函数的工作原理。
摘要由CSDN通过智能技术生成

接前一篇文章： QEMU源码全解析4 —— QEMU参数解析（4）

本文内容参考：

《趣谈 Linux 操作系统》 —— 刘超， 极客时间

《 QEMU /KVM》源码解析与应用 —— 李强，机械工业出版社

特此致谢！

本篇文章以-device参数项为例简单分析QEMU参数的处理过程。

softmmu/vl.c的main函数（qemu_init函数）中有一个很长的循环来解析参数，代码片段如下所示： 

  1.     /* second pass of option parsing */
  2.     optind = 1;
  3.     for(;;) {
  4.         if (optind >= argc)
  5.             break;
  6.         if (argv[optind][0] != '-') {
  7.             loc_set_cmdline(argv, optind, 1);
  8.             drive_add(IF_DEFAULT, 0, argv[optind++], HD_OPTS);
  9.         } else {
  10.             const QEMUOption *popt;
  11.  
  12.             popt = lookup_opt(argc, argv, &optarg, &optind);
  13.             if (!(popt->arch_mask & arch_type)) {
  14.                 error_report("Option not supported for this target");
  15.                 exit(1);
  16.             }
  17.             switch(popt->index) {
  18.             case QEMU_OPTION_cpu:
  19.                 /* hw initialization will check this */
  20.                 cpu_option = optarg;
  21.                 break;
  22.             case QEMU_OPTION_hda:
  23.             case QEMU_OPTION_hdb:
  24.             case QEMU_OPTION_hdc:
  25.             case QEMU_OPTION_hdd:
  26.                 drive_add(IF_DEFAULT, popt->index - QEMU_OPTION_hda, optarg,
  27.                           HD_OPTS);
  28.                 break;
  29.             case QEMU_OPTION_blockdev:
  30.                 {
  31.                     Visitor *v;
  32.                     BlockdevOptionsQueueEntry *bdo;
  33.  
  34.                     v = qobject_input_visitor_new_str(optarg, "driver",
  35.                                                       &error_fatal);
  36.  
  37.                     bdo = g_new(BlockdevOptionsQueueEntry, 1);
  38.                     visit_type_BlockdevOptions(v, NULL, &bdo->bdo,
  39.                                                &error_fatal);
  40.                     visit_free(v);
  41.                     loc_save(&bdo->loc);
  42.                     QSIMPLEQ_INSERT_TAIL(&bdo_queue, bdo, entry);
  43.                     break;
  44.                 }
  45.             case QEMU_OPTION_drive:
  46.                 opts = qemu_opts_parse_noisily(qemu_find_opts("drive"),
  47.                                                optarg, false);
  48.                 if (opts == NULL) {
  49.                     exit(1);
  50.                 }
  51.                 break;
  52.  
  53.             ……
  54.  
  55.             case QEMU_OPTION_msg:
  56.                 opts = qemu_opts_parse_noisily(qemu_find_opts("msg"), optarg,
  57.                                                false);
  58.                 if (!opts) {
  59.                     exit(1);
  60.                 }
  61.                 configure_msg(opts);
  62.                 break;
  63.             case QEMU_OPTION_dump_vmstate:
  64.                 if (vmstate_dump_file) {
  65.                     error_report("only one '-dump-vmstate' "
  66.                                  "option may be given");
  67.                     exit(1);
  68.                 }
  69.                 vmstate_dump_file = fopen(optarg, "w");
  70.                 if (vmstate_dump_file == NULL) {
  71.                     error_report("open %s: %s", optarg, strerror(errno));
  72.                     exit(1);
  73.                 }
  74.                 break;
  75.             case QEMU_OPTION_enable_sync_profile:
  76.                 qsp_enable();
  77.                 break;
  78.             case QEMU_OPTION_nouserconfig:
  79.                 /* Nothing to be parsed here. Especially, do not error out below. */
  80.                 break;
  81.             default:
  82.                 if (os_parse_cmd_args(popt->index, optarg)) {
  83.                     error_report("Option not supported in this build");
  84.                     exit(1);
  85.                 }
  86.             }
  87.         }
  88.     }

从注释中可以看到，是第2次选项解析，那么第1次解析是什么？其实就是本系列第2篇文章中讲到的lookup_opt函数，其在主函数中的代码片段如下： 

  1.      /* first pass of option parsing */
  2.     optind = 1;
  3.     while (optind < argc) {
  4.         if (argv[optind][0] != '-') {
  5.             /* disk image */
  6.             optind++;
  7.         } else {
  8.             const QEMUOption *popt;
  9.  
  10.             popt = lookup_opt(argc, argv, &optarg, &optind);
  11.             switch (popt->index) {
  12.             case QEMU_OPTION_nouserconfig:
  13.                 userconfig = false;
  14.                 break;
  15.             }
  16.         }
  17.     }
  18.  
  19.     machine_opts_dict = qdict_new();
  20.     if (userconfig) {
  21.         qemu_read_default_config_file(&error_fatal);
  22.     }

为例便于理解，再贴一下lookup_opt函数代码，在softmmu/vl.c中： 

  1. static const QEMUOption *lookup_opt(int argc, char **argv,
  2.                                     const char **poptarg, int *poptind)
  3. {
  4.     const QEMUOption *popt;
  5.     int optind = *poptind;
  6.     char *r = argv[optind];
  7.     const char *optarg;
  8.  
  9.     loc_set_cmdline(argv, optind, 1);
  10.     optind++;
  11.     /* Treat --foo the same as -foo.  */
  12.     if (r[1] == '-')
  13.         r++;
  14.     popt = qemu_options;
  15.     for(;;) {
  16.         if (!popt->name) {
  17.             error_report("invalid option");
  18.             exit(1);
  19.         }
  20.         if (!strcmp(popt->name, r + 1))
  21.             break;
  22.         popt++;
  23.     }
  24.     if (popt->flags & HAS_ARG) {
  25.         if (optind >= argc) {
  26.             error_report("requires an argument");
  27.             exit(1);
  28.         }
  29.         optarg = argv[optind++];
  30.         loc_set_cmdline(argv, optind - 2, 2);
  31.     } else {
  32.         optarg = NULL;
  33.     }
  34.  
  35.     *poptarg = optarg;
  36.     *poptind = optind;
  37.  
  38.     return popt;
  39. }

还是回到第2次选项解析中来。这个循环用很长都不够表达了，那是“相当的长”，有1000行左右。这个循环中包含了一个一个的选项，其中就包括-device。当解析到“-device”时，对应的分支处理代码如下： 

  1.         case QEMU_OPTION_device:
  2.                 if (optarg[0] == '{') {
  3.                     QObject *obj = qobject_from_json(optarg, &error_fatal);
  4.                     DeviceOption *opt = g_new0(DeviceOption, 1);
  5.                     opt->opts = qobject_to(QDict, obj);
  6.                     loc_save(&opt->loc);
  7.                     assert(opt->opts != NULL);
  8.                     QTAILQ_INSERT_TAIL(&device_opts, opt, next);
  9.                 } else {
  10.                     if (!qemu_opts_parse_noisily(qemu_find_opts("device"),
  11.                                                  optarg, true)) {
  12.                         exit(1);
  13.                     }
  14.                 }
  15.                 break;

核心的代码为：!qemu_opts_parse_noisily(qemu_find_opts("device"), optarg, true))。其中包括2个函数，qemu_opts_parse_noisily和qemu_find_opts。

先来看后者。qemu_find_opts函数在util/qemu-config.c中，代码如下： 

  1. QemuOptsList *qemu_find_opts(const char *group)
  2. {
  3.     QemuOptsList *ret;
  4.     Error *local_err = NULL;
  5.  
  6.     ret = find_list(vm_config_groups, group, &local_err);
  7.     if (local_err) {
  8.         error_report_err(local_err);
  9.     }
  10.  
  11.     return ret;
  12. }

find_list函数就在qemu_find_opts函数上边，代码如下： 

  1. static QemuOptsList *find_list(QemuOptsList **lists, const char *group,
  2.                                Error **errp)
  3. {
  4.     int i;
  5.  
  6.     qemu_load_module_for_opts(group);
  7.     for (i = 0; lists[i] != NULL; i++) {
  8.         if (strcmp(lists[i]->name, group) == 0)
  9.             break;
  10.     }
  11.     if (lists[i] == NULL) {
  12.         error_setg(errp, "There is no option group '%s'", group);
  13.     }
  14.     return lists[i];
  15. }

简单来讲，qemu_find_opts函数从全局变量vm_config_groups中找到刚才插入的device QemuOptsList并返回。

再来看前者，即qemu_opts_parse_noisily函数。其在util/qemu-option.c中实现，代码如下： 

  1. /**
  2.  * Create a QemuOpts in @list and with options parsed from @params.
  3.  * If @permit_abbrev, the first key=value in @params may omit key=,
  4.  * and is treated as if key was @list->implied_opt_name.
  5.  * Report errors with error_report_err().  This is inappropriate in
  6.  * QMP context.  Do not use this function there!
  7.  * Return the new QemuOpts on success, null pointer on error.
  8.  */
  9. QemuOpts *qemu_opts_parse_noisily(QemuOptsList *list, const char *params,
  10.                                   bool permit_abbrev)
  11. {
  12.     Error *err = NULL;
  13.     QemuOpts *opts;
  14.     bool help_wanted = false;
  15.  
  16.     opts = opts_parse(list, params, permit_abbrev, true,
  17.                       opts_accepts_any(list) ? NULL : &help_wanted,
  18.                       &err);
  19.     if (!opts) {
  20.         assert(!!err + !!help_wanted == 1);
  21.         if (help_wanted) {
  22.             qemu_opts_print_help(list, true);
  23.         } else {
  24.             error_report_err(err);
  25.         }
  26.     }
  27.     return opts;
  28. }

qemu_opts_parse_noisily函数只是简单调用了opt_parse函数，后者解析出一个QemuOpts。预知opt_parse函数的详情，且看下回分解。

举报

选择你想要举报的内容（必选）
  • 内容涉黄
  • 政治相关
  • 内容抄袭
  • 涉嫌广告
  • 内容侵权
  • 侮辱谩骂
  • 样式问题
  • 其他

取消

确定