/ - Diff - qemu - Greek Research and Technology Network's projects

b/blockdev.c
47	47	#include "sysemu/arch_init.h"
48	48
49	49	static QTAILQ_HEAD(drivelist, DriveInfo) drives = QTAILQ_HEAD_INITIALIZER(drives);
50		extern QemuOptsList qemu_common_drive_opts;
51	50
52	51	static const char *const if_name[IF_COUNT] = {
53	52	[IF_NONE] = "none",

b/include/qemu/config-file.h
8	8	QemuOptsList qemu_find_opts(const char group);
9	9	QemuOptsList qemu_find_opts_err(const char group, Error **errp);
10	10	void qemu_add_opts(QemuOptsList *list);
	11	void qemu_add_drive_opts(QemuOptsList *list);
11	12	int qemu_set_option(const char *str);
12	13	int qemu_global_option(const char *str);
13	14	void qemu_add_globals(void);

     bool usb_enabled(bool default_usb);
     extern QemuOptsList qemu_legacy_drive_opts;
     extern QemuOptsList qemu_common_drive_opts;
     extern QemuOptsList qemu_drive_opts;
     extern QemuOptsList qemu_chardev_opts;
     extern QemuOptsList qemu_device_opts;

     #include "qmp-commands.h"
     static QemuOptsList *vm_config_groups[32];
     static QemuOptsList *drive_config_groups[4];
     static QemuOptsList *find_list(QemuOptsList **lists, const char *group,
                                    Error **errp)
-...
         return param_list;
+    }
     /* remove repeated entry from the info list */
     static void cleanup_infolist(CommandLineParameterInfoList *head)
+    {
         CommandLineParameterInfoList *pre_entry, *cur, *del_entry;
         cur = head;
         while (cur->next) {
             pre_entry = head;
             while (pre_entry != cur->next) {
                 if (!strcmp(pre_entry->value->name, cur->next->value->name)) {
                     del_entry = cur->next;
                     cur->next = cur->next->next;
                     g_free(del_entry);
                     break;
+                }
                 pre_entry = pre_entry->next;
+            }
             cur = cur->next;
+        }
+    }
     /* merge the description items of two parameter infolists */
     static void connect_infolist(CommandLineParameterInfoList *head,
                                  CommandLineParameterInfoList *new)
+    {
         CommandLineParameterInfoList *cur;
         cur = head;
         while (cur->next) {
             cur = cur->next;
+        }
         cur->next = new;
+    }
     /* access all the local QemuOptsLists for drive option */
     static CommandLineParameterInfoList *get_drive_infolist(void)
+    {
         CommandLineParameterInfoList *head = NULL, *cur;
         int i;
         for (i = 0; drive_config_groups[i] != NULL; i++) {
             if (!head) {
                 head = query_option_descs(drive_config_groups[i]->desc);
             } else {
                 cur = query_option_descs(drive_config_groups[i]->desc);
                 connect_infolist(head, cur);
+            }
+        }
         cleanup_infolist(head);
         return head;
+    }
     CommandLineOptionInfoList *qmp_query_command_line_options(bool has_option,
                                                               const char *option,
                                                               Error **errp)
-...
             if (!has_option || !strcmp(option, vm_config_groups[i]->name)) {
                 info = g_malloc0(sizeof(*info));
                 info->option = g_strdup(vm_config_groups[i]->name);
                 info->parameters = query_option_descs(vm_config_groups[i]->desc);
                 if (!strcmp("drive", vm_config_groups[i]->name)) {
                     info->parameters = get_drive_infolist();
                 } else {
                     info->parameters =
                         query_option_descs(vm_config_groups[i]->desc);
+                }
                 entry = g_malloc0(sizeof(*entry));
                 entry->value = info;
                 entry->next = conf_list;
-...
         return find_list(vm_config_groups, group, errp);
+    }
     void qemu_add_drive_opts(QemuOptsList *list)
+    {
         int entries, i;
         entries = ARRAY_SIZE(drive_config_groups);
         entries--; /* keep list NULL terminated */
         for (i = 0; i < entries; i++) {
             if (drive_config_groups[i] == NULL) {
                 drive_config_groups[i] = list;
                 return;
+            }
+        }
         fprintf(stderr, "ran out of space in drive_config_groups");
         abort();
+    }
     void qemu_add_opts(QemuOptsList *list)
+    {
         int entries, i;

         module_call_init(MODULE_INIT_QOM);
         qemu_add_opts(&qemu_drive_opts);
         qemu_add_drive_opts(&qemu_legacy_drive_opts);
         qemu_add_drive_opts(&qemu_common_drive_opts);
         qemu_add_drive_opts(&qemu_drive_opts);
         qemu_add_opts(&qemu_chardev_opts);
         qemu_add_opts(&qemu_device_opts);
         qemu_add_opts(&qemu_netdev_opts);

Archipelago » qemu

Revision 968854c8