Revision abdeed06
b/vl.c | ||
---|---|---|
211 | 211 |
CharDriverState *serial_hds[MAX_SERIAL_PORTS]; |
212 | 212 |
CharDriverState *parallel_hds[MAX_PARALLEL_PORTS]; |
213 | 213 |
CharDriverState *virtcon_hds[MAX_VIRTIO_CONSOLES]; |
214 |
CharDriverState *monitor_hds[MAX_MONITOR_DEVICES]; |
|
214 | 215 |
#ifdef TARGET_I386 |
215 | 216 |
int win2k_install_hack = 0; |
216 | 217 |
int rtc_td_hack = 0; |
... | ... | |
273 | 274 |
|
274 | 275 |
static int default_serial = 1; |
275 | 276 |
static int default_parallel = 1; |
277 |
static int default_monitor = 1; |
|
276 | 278 |
|
277 | 279 |
static struct { |
278 | 280 |
const char *driver; |
... | ... | |
4628 | 4630 |
DEV_BT, /* -bt */ |
4629 | 4631 |
DEV_SERIAL, /* -serial */ |
4630 | 4632 |
DEV_PARALLEL, /* -parallel */ |
4633 |
DEV_MONITOR, /* -monitor */ |
|
4631 | 4634 |
} type; |
4632 | 4635 |
const char *cmdline; |
4633 | 4636 |
QTAILQ_ENTRY(device_config) next; |
... | ... | |
4659 | 4662 |
return 0; |
4660 | 4663 |
} |
4661 | 4664 |
|
4662 |
static void serial_monitor_mux(const char *monitor_devices[])
|
|
4665 |
static void serial_monitor_mux(void)
|
|
4663 | 4666 |
{ |
4664 |
struct device_config *serial; |
|
4667 |
struct device_config *mon0, *serial;
|
|
4665 | 4668 |
const char *devname; |
4666 | 4669 |
|
4667 |
if (strcmp(monitor_devices[0],"stdio") != 0) |
|
4668 |
return; |
|
4670 |
QTAILQ_FOREACH(mon0, &device_configs, next) { |
|
4671 |
if (mon0->type != DEV_MONITOR) |
|
4672 |
continue; |
|
4673 |
if (strcmp(mon0->cmdline,"stdio") != 0) |
|
4674 |
return; |
|
4675 |
break; |
|
4676 |
} |
|
4669 | 4677 |
QTAILQ_FOREACH(serial, &device_configs, next) { |
4670 | 4678 |
if (serial->type != DEV_SERIAL) |
4671 | 4679 |
continue; |
4672 | 4680 |
devname = serial->cmdline; |
4673 | 4681 |
if (devname && !strcmp(devname,"mon:stdio")) { |
4674 |
monitor_devices[0] = NULL;
|
|
4682 |
QTAILQ_REMOVE(&device_configs, mon0, next);
|
|
4675 | 4683 |
break; |
4676 | 4684 |
} else if (devname && !strcmp(devname,"stdio")) { |
4677 |
monitor_devices[0] = NULL;
|
|
4685 |
QTAILQ_REMOVE(&device_configs, mon0, next);
|
|
4678 | 4686 |
serial->cmdline = "mon:stdio"; |
4679 | 4687 |
break; |
4680 | 4688 |
} |
... | ... | |
4725 | 4733 |
return 0; |
4726 | 4734 |
} |
4727 | 4735 |
|
4736 |
static int monitor_parse(const char *devname) |
|
4737 |
{ |
|
4738 |
static int index = 0; |
|
4739 |
char label[32]; |
|
4740 |
|
|
4741 |
if (strcmp(devname, "none") == 0) |
|
4742 |
return 0; |
|
4743 |
if (index == MAX_MONITOR_DEVICES) { |
|
4744 |
fprintf(stderr, "qemu: too many monitor devices\n"); |
|
4745 |
exit(1); |
|
4746 |
} |
|
4747 |
if (index == 0) { |
|
4748 |
snprintf(label, sizeof(label), "monitor"); |
|
4749 |
} else { |
|
4750 |
snprintf(label, sizeof(label), "monitor%d", index); |
|
4751 |
} |
|
4752 |
monitor_hds[index] = qemu_chr_open(label, devname, NULL); |
|
4753 |
if (!monitor_hds[index]) { |
|
4754 |
fprintf(stderr, "qemu: could not open monitor device '%s'\n", |
|
4755 |
devname); |
|
4756 |
return -1; |
|
4757 |
} |
|
4758 |
index++; |
|
4759 |
return 0; |
|
4760 |
} |
|
4761 |
|
|
4728 | 4762 |
int main(int argc, char **argv, char **envp) |
4729 | 4763 |
{ |
4730 | 4764 |
const char *gdbstub_dev = NULL; |
... | ... | |
4740 | 4774 |
QemuOpts *hda_opts = NULL, *opts; |
4741 | 4775 |
int optind; |
4742 | 4776 |
const char *r, *optarg; |
4743 |
CharDriverState *monitor_hds[MAX_MONITOR_DEVICES]; |
|
4744 |
const char *monitor_devices[MAX_MONITOR_DEVICES]; |
|
4745 |
int monitor_device_index; |
|
4746 | 4777 |
const char *virtio_consoles[MAX_VIRTIO_CONSOLES]; |
4747 | 4778 |
int virtio_console_index; |
4748 | 4779 |
const char *loadvm = NULL; |
... | ... | |
4814 | 4845 |
virtio_consoles[i] = NULL; |
4815 | 4846 |
virtio_console_index = 0; |
4816 | 4847 |
|
4817 |
monitor_devices[0] = "vc:80Cx24C"; |
|
4818 |
for (i = 1; i < MAX_MONITOR_DEVICES; i++) { |
|
4819 |
monitor_devices[i] = NULL; |
|
4820 |
} |
|
4821 |
monitor_device_index = 0; |
|
4822 |
|
|
4823 | 4848 |
for (i = 0; i < MAX_NODES; i++) { |
4824 | 4849 |
node_mem[i] = 0; |
4825 | 4850 |
node_cpumask[i] = 0; |
... | ... | |
5237 | 5262 |
break; |
5238 | 5263 |
} |
5239 | 5264 |
case QEMU_OPTION_monitor: |
5240 |
if (monitor_device_index >= MAX_MONITOR_DEVICES) { |
|
5241 |
fprintf(stderr, "qemu: too many monitor devices\n"); |
|
5242 |
exit(1); |
|
5243 |
} |
|
5244 |
monitor_devices[monitor_device_index] = optarg; |
|
5245 |
monitor_device_index++; |
|
5265 |
add_device_config(DEV_MONITOR, optarg); |
|
5266 |
default_monitor = 0; |
|
5246 | 5267 |
break; |
5247 | 5268 |
case QEMU_OPTION_chardev: |
5248 | 5269 |
opts = qemu_opts_parse(&qemu_chardev_opts, optarg, "backend"); |
... | ... | |
5557 | 5578 |
add_device_config(DEV_SERIAL, "stdio"); |
5558 | 5579 |
if (default_parallel) |
5559 | 5580 |
add_device_config(DEV_PARALLEL, "null"); |
5560 |
if (strncmp(monitor_devices[0], "vc", 2) == 0) { |
|
5561 |
monitor_devices[0] = "stdio"; |
|
5562 |
} |
|
5581 |
if (default_monitor) |
|
5582 |
add_device_config(DEV_MONITOR, "stdio"); |
|
5563 | 5583 |
} else { |
5564 | 5584 |
if (default_serial) |
5565 | 5585 |
add_device_config(DEV_SERIAL, "vc:80Cx24C"); |
5566 | 5586 |
if (default_parallel) |
5567 | 5587 |
add_device_config(DEV_PARALLEL, "vc:80Cx24C"); |
5588 |
if (default_monitor) |
|
5589 |
add_device_config(DEV_MONITOR, "vc:80Cx24C"); |
|
5568 | 5590 |
} |
5569 | 5591 |
|
5570 | 5592 |
if (qemu_opts_foreach(&qemu_chardev_opts, chardev_init_func, NULL, 1) != 0) |
... | ... | |
5716 | 5738 |
ram_load, NULL); |
5717 | 5739 |
|
5718 | 5740 |
/* Maintain compatibility with multiple stdio monitors */ |
5719 |
serial_monitor_mux(monitor_devices);
|
|
5741 |
serial_monitor_mux(); |
|
5720 | 5742 |
|
5721 | 5743 |
if (nb_numa_nodes > 0) { |
5722 | 5744 |
int i; |
... | ... | |
5760 | 5782 |
} |
5761 | 5783 |
} |
5762 | 5784 |
|
5763 |
for (i = 0; i < MAX_MONITOR_DEVICES; i++) { |
|
5764 |
const char *devname = monitor_devices[i]; |
|
5765 |
if (devname && strcmp(devname, "none")) { |
|
5766 |
char label[32]; |
|
5767 |
if (i == 0) { |
|
5768 |
snprintf(label, sizeof(label), "monitor"); |
|
5769 |
} else { |
|
5770 |
snprintf(label, sizeof(label), "monitor%d", i); |
|
5771 |
} |
|
5772 |
monitor_hds[i] = qemu_chr_open(label, devname, NULL); |
|
5773 |
if (!monitor_hds[i]) { |
|
5774 |
fprintf(stderr, "qemu: could not open monitor device '%s'\n", |
|
5775 |
devname); |
|
5776 |
exit(1); |
|
5777 |
} |
|
5778 |
} |
|
5779 |
} |
|
5780 |
|
|
5785 |
if (foreach_device_config(DEV_MONITOR, monitor_parse) < 0) |
|
5786 |
exit(1); |
|
5781 | 5787 |
if (foreach_device_config(DEV_SERIAL, serial_parse) < 0) |
5782 | 5788 |
exit(1); |
5783 | 5789 |
if (foreach_device_config(DEV_PARALLEL, parallel_parse) < 0) |
... | ... | |
5903 | 5909 |
text_consoles_set_display(display_state); |
5904 | 5910 |
|
5905 | 5911 |
for (i = 0; i < MAX_MONITOR_DEVICES; i++) { |
5906 |
if (monitor_devices[i] && monitor_hds[i]) {
|
|
5912 |
if (monitor_hds[i]) { |
|
5907 | 5913 |
monitor_init(monitor_hds[i], |
5908 | 5914 |
MONITOR_USE_READLINE | |
5909 | 5915 |
((i == 0) ? MONITOR_IS_DEFAULT : 0)); |
Also available in: Unified diff