Add a valid_cpu_types property
Subsystems (3)
v4 cover Add a valid_cpu_types property
There are numorous QEMU machines that only have a single or a handful of valid CPU options. To simplyfy the management of specificying which CPU is/isn't valid let's create a property that can be set in the machine init. We can then check to see if the user supplied CPU is in that list or not.
I have added the valid_cpu_types for some ARM machines only at the moment.
Here is what specifying the CPUs looks like now:
$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m3" -S QEMU 2.10.50 monitor - type 'help' for more information (qemu) info cpus * CPU #0: thread_id=24175 (qemu) q
$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m4" -S QEMU 2.10.50 monitor - type 'help' for more information (qemu) q
$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m5" -S qemu-system-aarch64: unable to find CPU model 'cortex-m5'
$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-a9" -S qemu-system-aarch64: Invalid CPU type: cortex-a9-arm-cpu The valid types are: cortex-m3-arm-cpu, cortex-m4-arm-cpu
V4:
- Rebase
- Remove spaces
V3:
- Make the varialbes static
V2:
- Rebase
- Reorder patches
- Add a Raspberry Pi 2 CPU fix
V1:
- Small fixes to prepare a series instead of RFC
- Add commit messages for the commits
- Expand the machine support to ARM machines
RFC v2:
- Rebase on Igor's work
- Use more QEMUisms inside the code
- List the supported machines in a NULL terminated array
Alistair Francis (5):
netduino2: Specify the valid CPUs
bcm2836: Use the Cortex-A7 instead of Cortex-A15
raspi: Specify the valid CPUs
xlnx-zcu102: Specify the valid CPUs
xilinx_zynq: Specify the valid CPUs
hw/arm/bcm2836.c | 2 +- hw/arm/netduino2.c | 10 +++++++++- hw/arm/raspi.c | 7 +++++++ hw/arm/xilinx_zynq.c | 6 ++++++ hw/arm/xlnx-zcu102.c | 17 +++++++++++++++++ 5 files changed, 40 insertions(+), 2 deletions(-)
Signature · 1 line
2.14.1
PATCH v4 1/5 netduino2: Specify the valid CPUs
List all possible valid CPU options.
Although the board only ever has a Cortex-M3 we mark the Cortex-M4 as supported because the Netduino2 Plus supports the Cortex-M4 and the Netduino2 Plus is similar to the Netduino2.
---
V3:
- Add static property
V2:
- Fixup allignment
RFC v2:
- Use a NULL terminated list
- Add the Cortex-M4 for testing
hw/arm/netduino2.c | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-)
hw/arm/netduino2.c +9 -1
@@ -34,18 +34,26 @@ static void netduino2_init(MachineState *machine)DeviceState *dev; dev =qdev_create (NULL ,TYPE_STM32F205_SOC ); -qdev_prop_set_string (dev,"cpu-type" ,ARM_CPU_TYPE_NAME ("cortex-m3" )); +qdev_prop_set_string (dev,"cpu-type" , machine->cpu_type);object_property_set_bool (OBJECT (dev), true,"realized" , &error_fatal);armv7m_load_kernel (ARM_CPU (first_cpu), machine->kernel_filename,FLASH_SIZE ); } +static const char *netduino_valid_cpus[] = { +ARM_CPU_TYPE_NAME ("cortex-m3" ), +ARM_CPU_TYPE_NAME ("cortex-m4" ), +NULL + }; +static void netduino2_machine_init (MachineClass *mc) { mc->desc ="Netduino 2 Machine" ; mc->init = netduino2_init; mc->ignore_memory_transaction_failures = true; + mc->default_cpu_type =ARM_CPU_TYPE_NAME ("cortex-m3" ); + mc->valid_cpu_types = netduino_valid_cpus; }DEFINE_MACHINE ("netduino2" , netduino2_machine_init)
Signature · 1 line
2.14.1
PATCH v4 2/5 bcm2836: Use the Cortex-A7 instead of Cortex-A15
In reply to Alistair FrancisThe BCM2836 uses a Cortex-A7 not a Cortex-A15. Update the device to use the correct CPU.
https://www.raspberrypi.org/documentation/hardware/raspberrypi/bcm2836/QA7_rev3.4.pdf
---
V3:
- Use ARM_CPU_TYPE_NAME() macro
V2:
- Fix the BCM2836 CPU
hw/arm/bcm2836.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
hw/arm/bcm2836.c +1 -1
@@ -30,7 +30,7 @@ static void bcm2836_init(Object *obj)for (n =0 ; n <BCM2836_NCPUS ; n++) {object_initialize (&s->cpus[n],sizeof (s->cpus[n]), -"cortex-a15-" TYPE_ARM_CPU ); +ARM_CPU_TYPE_NAME ("cortex-a7" ));object_property_add_child (obj,"cpu[*]" ,OBJECT (&s->cpus[n]), &error_abort); }
Signature · 1 line
2.14.1
PATCH v4 3/5 raspi: Specify the valid CPUs
In reply to Alistair FrancisList all possible valid CPU options.
---
V4:
- Remove spaces
V3:
- Add static property
V2:
- Fix the indentation
hw/arm/raspi.c | 7 +++++++ 1 file changed, 7 insertions(+)
hw/arm/raspi.c +7 -0
@@ -158,6 +158,11 @@ static void raspi2_init(MachineState *machine)setup_boot (machine,2 , machine->ram_size - vcram_size); } +static const char *raspi2_valid_cpus[] = { +ARM_CPU_TYPE_NAME ("cortex-a7" ), +NULL +}; +static void raspi2_machine_init (MachineClass *mc) { mc->desc ="Raspberry Pi 2" ;
@@ -171,5 +176,7 @@ static void raspi2_machine_init(MachineClass *mc) mc->default_cpus =BCM2836_NCPUS ; mc->default_ram_size =1024 *1024 *1024 ; mc->ignore_memory_transaction_failures = true; + mc->default_cpu_type =ARM_CPU_TYPE_NAME ("cortex-a7" ); + mc->valid_cpu_types = raspi2_valid_cpus; };DEFINE_MACHINE ("raspi2" , raspi2_machine_init)
Signature · 1 line
2.14.1
PATCH v4 4/5 xlnx-zcu102: Specify the valid CPUs
In reply to Alistair FrancisList all possible valid CPU options.
---
An implementation for single CPU machines is still being discussed. A solution proposed by Eduardo is this:
1) Change the default on TYPE_MACHINE to:
mc->valid_cpu_types = { TYPE_CPU, NULL };This will keep the existing behavior for all boards.
2) mc->valid_cpu_types=NULL be interpreted as "no CPU model except the default is accepted" or "-cpu is not accepted" in machine_run_board_init() (I prefer the former, but both options would be correct)
3) Boards like xlnx_zynqmp could then just do this:
static void xxx_class_init(...) {
mc->default_cpu_type = MY_CPU_TYPE;
/* Reason: XXX_init() is hardcoded to MY_CPU_TYPE */
mc->valid_cpu_types = NULL; }
V4:
- Remove spaces
V3:
- Make variable static
V2:
- Don't use the users -cpu
- Fixup allignment
hw/arm/xlnx-zcu102.c | 17 +++++++++++++++++ 1 file changed, 17 insertions(+)
hw/arm/xlnx-zcu102.c +17 -0
@@ -184,6 +184,11 @@ static void xlnx_zynqmp_init(XlnxZCU102 *s, MachineState *machine)arm_load_kernel (s->soc.boot_cpu_ptr, &xlnx_zcu102_binfo); } +static const char *xlnx_zynqmp_valid_cpus[] = { +ARM_CPU_TYPE_NAME ("cortex-a53" ), +NULL +}; +static void xlnx_ep108_init (MachineState *machine) {XlnxZCU102 *s =EP108_MACHINE (machine);
@@ -216,6 +221,12 @@ static void xlnx_ep108_machine_class_init(ObjectClass *oc, void *data) mc->ignore_memory_transaction_failures = true; mc->max_cpus =XLNX_ZYNQMP_NUM_APU_CPUS +XLNX_ZYNQMP_NUM_RPU_CPUS ; mc->default_cpus =XLNX_ZYNQMP_NUM_APU_CPUS ; + mc->default_cpu_type =ARM_CPU_TYPE_NAME ("cortex-a53" ); +/* The ZynqMP SoC is always a Cortex-A53. We add this here to give +* users a sane error if they specify a different CPU, but we never +* use their CPU choice. +*/ + mc->valid_cpu_types = xlnx_zynqmp_valid_cpus; }static const TypeInfo xlnx_ep108_machine_init_typeinfo = {
@@ -274,6 +285,12 @@ static void xlnx_zcu102_machine_class_init(ObjectClass *oc, void *data) mc->ignore_memory_transaction_failures = true; mc->max_cpus =XLNX_ZYNQMP_NUM_APU_CPUS +XLNX_ZYNQMP_NUM_RPU_CPUS ; mc->default_cpus =XLNX_ZYNQMP_NUM_APU_CPUS ; + mc->default_cpu_type =ARM_CPU_TYPE_NAME ("cortex-a53" ); +/* The ZynqMP SoC is always a Cortex-A53. We add this here to give +* users a sane error if they specify a different CPU, but we never +* use their CPU choice. +*/ + mc->valid_cpu_types = xlnx_zynqmp_valid_cpus; }static const TypeInfo xlnx_zcu102_machine_init_typeinfo = {
Signature · 1 line
2.14.1
PATCH v4 5/5 xilinx_zynq: Specify the valid CPUs
In reply to Alistair FrancisList all possible valid CPU options.
---
V4:
- Remove spaces
V3:
- Make variable static
V2:
- Fixup alignment
hw/arm/xilinx_zynq.c | 6 ++++++ 1 file changed, 6 insertions(+)
hw/arm/xilinx_zynq.c +6 -0
@@ -313,6 +313,11 @@ static void zynq_init(MachineState *machine)arm_load_kernel (ARM_CPU (first_cpu), &zynq_binfo); } +static const char *xlnx_zynq_7000_valid_cpus[] = { +ARM_CPU_TYPE_NAME ("cortex-a9" ), +NULL +}; +static void zynq_machine_init (MachineClass *mc) { mc->desc ="Xilinx Zynq Platform Baseboard for Cortex-A9" ;
@@ -321,6 +326,7 @@ static void zynq_machine_init(MachineClass *mc) mc->no_sdcard =1 ; mc->ignore_memory_transaction_failures = true; mc->default_cpu_type =ARM_CPU_TYPE_NAME ("cortex-a9" ); + mc->valid_cpu_types = xlnx_zynq_7000_valid_cpus; }DEFINE_MACHINE ("xilinx-zynq-a9" , zynq_machine_init)
Signature · 1 line
2.14.1
Quoted 21 lines · Alistair Francis
There are numorous QEMU machines that only have a single or a handful of valid CPU options. To simplyfy the management of specificying which CPU is/isn't valid let's create a property that can be set in the machine init. We can then check to see if the user supplied CPU is in that list or not.
I have added the
valid_cpu_typesfor some ARM machines only at the moment.Here is what specifying the CPUs looks like now:
$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m3" -S QEMU 2.10.50 monitor - type 'help' for more information (qemu) info cpus * CPU #0: thread_id=24175 (qemu) q$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m4" -S QEMU 2.10.50 monitor - type 'help' for more information (qemu) q
Quoted 6 lines
$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m5" -S qemu-system-aarch64: unable to find CPU model 'cortex-m5'$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-a9" -S qemu-system-aarch64: Invalid CPU type: cortex-a9-arm-cpu The valid types are: cortex-m3-arm-cpu, cortex-m4-arm-cpu
Thanks for this; we really should be more strict about forbidding "won't work" combinations than we have been in the past.
In the last of these cases, I think that when we list the invalid CPU type and the valid types we should use the same names we want the user to use on the command line, without the "-arm-cpu" suffixes.
thanks
-- PMM
Quoted 34 lines · Peter Maydell
Quoted 21 lines · Alistair Francis
There are numorous QEMU machines that only have a single or a handful of valid CPU options. To simplyfy the management of specificying which CPU is/isn't valid let's create a property that can be set in the machine init. We can then check to see if the user supplied CPU is in that list or not.
I have added the
valid_cpu_typesfor some ARM machines only at the moment.Here is what specifying the CPUs looks like now:
$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m3" -S QEMU 2.10.50 monitor - type 'help' for more information (qemu) info cpus * CPU #0: thread_id=24175 (qemu) q$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m4" -S QEMU 2.10.50 monitor - type 'help' for more information (qemu) qQuoted 6 lines
$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m5" -S qemu-system-aarch64: unable to find CPU model 'cortex-m5'$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-a9" -S qemu-system-aarch64: Invalid CPU type: cortex-a9-arm-cpu The valid types are: cortex-m3-arm-cpu, cortex-m4-arm-cpuThanks for this; we really should be more strict about forbidding "won't work" combinations than we have been in the past.
Quoted 5 lines
In the last of these cases, I think that when we list the invalid CPU type and the valid types we should use the same names we want the user to use on the command line, without the "-arm-cpu" suffixes.
Hmm... That is a good point, it is confusing that they don't line up.
The problem is that we are just doing a simple object_class_dynamic_cast() in hw/core/machine.c which I think (untested) requires us to have the full name in the valid cpu array.
Alistair
Quoted 3 lines
thanks
-- PMM
Quoted 41 lines · Alistair Francis
Quoted 34 lines · Peter Maydell
Quoted 21 lines · Alistair Francis
There are numorous QEMU machines that only have a single or a handful of valid CPU options. To simplyfy the management of specificying which CPU is/isn't valid let's create a property that can be set in the machine init. We can then check to see if the user supplied CPU is in that list or not.
I have added the
valid_cpu_typesfor some ARM machines only at the moment.Here is what specifying the CPUs looks like now:
$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m3" -S QEMU 2.10.50 monitor - type 'help' for more information (qemu) info cpus * CPU #0: thread_id=24175 (qemu) q$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m4" -S QEMU 2.10.50 monitor - type 'help' for more information (qemu) qQuoted 6 lines
$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m5" -S qemu-system-aarch64: unable to find CPU model 'cortex-m5'$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-a9" -S qemu-system-aarch64: Invalid CPU type: cortex-a9-arm-cpu The valid types are: cortex-m3-arm-cpu, cortex-m4-arm-cpuThanks for this; we really should be more strict about forbidding "won't work" combinations than we have been in the past.
Quoted 5 lines
In the last of these cases, I think that when we list the invalid CPU type and the valid types we should use the same names we want the user to use on the command line, without the "-arm-cpu" suffixes.
Quoted 5 lines
Hmm... That is a good point, it is confusing that they don't line up.
The problem is that we are just doing a simple
object_class_dynamic_cast()inhw/core/machine.cwhich I think (untested) requires us to have the full name in the valid cpu array.
Yeah, so I tested this diff on top of this series:
hw/arm/netduino2.c +2 -2
@@ -42,8 +42,8 @@ static void netduino2_init(MachineState *machine) }static const char *netduino_valid_cpus[] = { -ARM_CPU_TYPE_NAME ("cortex-m3" ), -ARM_CPU_TYPE_NAME ("cortex-m4" ), +"cortex-m3" , +"cortex-m4" ,NULL };
hw/core/machine.c +3 -3
@@ -761,8 +761,8 @@ void machine_run_board_init(MachineState *machine)/* If the machine supports the valid_cpu_types check and the user * specified a CPU with -cpu check here that the user CPU is supported. */ -if (machine_class->valid_cpu_types && machine->cpu_type) { -ObjectClass *class =object_class_by_name (machine->cpu_type); +if (machine_class->valid_cpu_types && machine->cpu_model) { +ObjectClass *class =object_class_by_name (machine->cpu_model);int i;for (i =0 ; machine_class->valid_cpu_types[i]; i++) {
@@ -777,7 +777,7 @@ void machine_run_board_init(MachineState *machine)if (!machine_class->valid_cpu_types[i]) {/* The user specified CPU is not valid */ -error_report ("Invalid CPU type: %s" , machine->cpu_type); +error_report ("Invalid CPU type: %s" , machine->cpu_model);error_printf ("The valid types are: %s" , machine_class->valid_cpu_types[0 ]);for (i =1 ; machine_class->valid_cpu_types[i]; i++) {
and I get this:
$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m4" -S qemu-system-aarch64: Invalid CPU type: cortex-m4 The valid types are: cortex-m3, cortex-m4
So we loose the object_class_dynamic_cast() ability.
I think an earlier version of my previous series adding the support to machine.c did string comparison, but it was decided to utilise objects instead. One option is to make the array 2 wide and have the second string be user friendly?
Alistair
Quoted 6 lines
Alistair
Quoted 3 lines
thanks
-- PMM
Quoted 37 lines · Alistair Francis
Quoted 35 lines · Alistair Francis
Quoted 34 lines · Peter Maydell
Quoted 21 lines · Alistair Francis
There are numorous QEMU machines that only have a single or a handful of valid CPU options. To simplyfy the management of specificying which CPU is/isn't valid let's create a property that can be set in the machine init. We can then check to see if the user supplied CPU is in that list or not.
I have added the
valid_cpu_typesfor some ARM machines only at the moment.Here is what specifying the CPUs looks like now:
$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m3" -S QEMU 2.10.50 monitor - type 'help' for more information (qemu) info cpus * CPU #0: thread_id=24175 (qemu) q$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m4" -S QEMU 2.10.50 monitor - type 'help' for more information (qemu) qQuoted 6 lines
$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m5" -S qemu-system-aarch64: unable to find CPU model 'cortex-m5'$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-a9" -S qemu-system-aarch64: Invalid CPU type: cortex-a9-arm-cpu The valid types are: cortex-m3-arm-cpu, cortex-m4-arm-cpuThanks for this; we really should be more strict about forbidding "won't work" combinations than we have been in the past.
Quoted 7 lines
Quoted 7 lines
Quoted 5 lines
In the last of these cases, I think that when we list the invalid CPU type and the valid types we should use the same names we want the user to use on the command line, without the "-arm-cpu" suffixes.
Hmm... That is a good point, it is confusing that they don't line up.
Agreed.
Quoted 4 lines
Quoted 4 lines
The problem is that we are just doing a simple
object_class_dynamic_cast()inhw/core/machine.cwhich I think (untested) requires us to have the full name in the valid cpu array.
[...]
Quoted 5 lines
I think an earlier version of my previous series adding the support to
machine.cdid string comparison, but it was decided to utilise objects instead. One option is to make the array 2 wide and have the second string be user friendly?
Making the array 2-column will duplicate information that we can already find out using other methods, and it won't solve the problem if an entry has a parent class with multiple subclasses (the original reason I suggested object_class_dynamic_cast()).
The main obstacle to fix this easily is that we do have a common
ObjectClass *cpu_class_by_name(const char *cpu_model)
function, but not a common method to get the model name from a CPUClass. Implementing this is possible, but probably better to do it after moving the existing arch-specific CPU model enumeration hooks to common code (currently we duplicate lots of CPU enumeration/lookup boilerplate code that we shouldn't have to).
Listing only the human-friendly names in the array like in the original patch could be a reasonable temporary solution. It won't allow us to use a single entry for all subclasses of a given type by now (e.g. listing only TYPE_X86_CPU on PC), but at least we can address this issue without waiting for a refactor of the CPU model enumeration code.
Signature · 1 line
Eduardo
Quoted 73 lines · Eduardo Habkost
Quoted 37 lines · Alistair Francis
Quoted 35 lines · Alistair Francis
Quoted 34 lines · Peter Maydell
Quoted 21 lines · Alistair Francis
There are numorous QEMU machines that only have a single or a handful of valid CPU options. To simplyfy the management of specificying which CPU is/isn't valid let's create a property that can be set in the machine init. We can then check to see if the user supplied CPU is in that list or not.
I have added the
valid_cpu_typesfor some ARM machines only at the moment.Here is what specifying the CPUs looks like now:
$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m3" -S QEMU 2.10.50 monitor - type 'help' for more information (qemu) info cpus * CPU #0: thread_id=24175 (qemu) q$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m4" -S QEMU 2.10.50 monitor - type 'help' for more information (qemu) qQuoted 6 lines
$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m5" -S qemu-system-aarch64: unable to find CPU model 'cortex-m5'$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-a9" -S qemu-system-aarch64: Invalid CPU type: cortex-a9-arm-cpu The valid types are: cortex-m3-arm-cpu, cortex-m4-arm-cpuThanks for this; we really should be more strict about forbidding "won't work" combinations than we have been in the past.
Quoted 7 lines
Quoted 7 lines
Quoted 5 lines
In the last of these cases, I think that when we list the invalid CPU type and the valid types we should use the same names we want the user to use on the command line, without the "-arm-cpu" suffixes.
Hmm... That is a good point, it is confusing that they don't line up.
Agreed.
Quoted 4 lines
Quoted 4 lines
The problem is that we are just doing a simple
object_class_dynamic_cast()inhw/core/machine.cwhich I think (untested) requires us to have the full name in the valid cpu array.[...]
Quoted 5 lines
I think an earlier version of my previous series adding the support to
machine.cdid string comparison, but it was decided to utilise objects instead. One option is to make the array 2 wide and have the second string be user friendly?Making the array 2-column will duplicate information that we can already find out using other methods, and it won't solve the problem if an entry has a parent class with multiple subclasses (the original reason I suggested
object_class_dynamic_cast()).The main obstacle to fix this easily is that we do have a common
ObjectClass *cpu_class_by_name(const char*cpu_model)
function, but not a common method to get the model name from a CPUClass. Implementing this is possible, but probably better to do it after moving the existing arch-specific CPU model enumeration hooks to common code (currently we duplicate lots of CPU enumeration/lookup boilerplate code that we shouldn't have to).
Quoted 6 lines
Listing only the human-friendly names in the array like in the original patch could be a reasonable temporary solution. It won't allow us to use a single entry for all subclasses of a given type by now (e.g. listing only
TYPE_X86_CPUon PC), but at least we can address this issue without waiting for a refactor of the CPU model enumeration code.
Ok, so it sounds like I'll respin this series with an extra column in the array for human readable names. Then in the future we can work on removing that.
Alistair
Quoted 4 lines
--
Eduardo
Quoted 74 lines · Alistair Francis
Quoted 73 lines · Eduardo Habkost
Quoted 37 lines · Alistair Francis
Quoted 35 lines · Alistair Francis
Quoted 34 lines · Peter Maydell
Quoted 21 lines · Alistair Francis
There are numorous QEMU machines that only have a single or a handful of valid CPU options. To simplyfy the management of specificying which CPU is/isn't valid let's create a property that can be set in the machine init. We can then check to see if the user supplied CPU is in that list or not.
I have added the
valid_cpu_typesfor some ARM machines only at the moment.Here is what specifying the CPUs looks like now:
$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m3" -S QEMU 2.10.50 monitor - type 'help' for more information (qemu) info cpus * CPU #0: thread_id=24175 (qemu) q$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m4" -S QEMU 2.10.50 monitor - type 'help' for more information (qemu) qQuoted 6 lines
$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m5" -S qemu-system-aarch64: unable to find CPU model 'cortex-m5'$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-a9" -S qemu-system-aarch64: Invalid CPU type: cortex-a9-arm-cpu The valid types are: cortex-m3-arm-cpu, cortex-m4-arm-cpuThanks for this; we really should be more strict about forbidding "won't work" combinations than we have been in the past.
Quoted 7 lines
Quoted 7 lines
Quoted 5 lines
In the last of these cases, I think that when we list the invalid CPU type and the valid types we should use the same names we want the user to use on the command line, without the "-arm-cpu" suffixes.
Hmm... That is a good point, it is confusing that they don't line up.
Agreed.
Quoted 4 lines
Quoted 4 lines
The problem is that we are just doing a simple
object_class_dynamic_cast()inhw/core/machine.cwhich I think (untested) requires us to have the full name in the valid cpu array.[...]
Quoted 5 lines
I think an earlier version of my previous series adding the support to
machine.cdid string comparison, but it was decided to utilise objects instead. One option is to make the array 2 wide and have the second string be user friendly?Making the array 2-column will duplicate information that we can already find out using other methods, and it won't solve the problem if an entry has a parent class with multiple subclasses (the original reason I suggested
object_class_dynamic_cast()).The main obstacle to fix this easily is that we do have a common
ObjectClass *cpu_class_by_name(const char*cpu_model)
function, but not a common method to get the model name from a CPUClass. Implementing this is possible, but probably better to do it after moving the existing arch-specific CPU model enumeration hooks to common code (currently we duplicate lots of CPU enumeration/lookup boilerplate code that we shouldn't have to).
Quoted 6 lines
Quoted 6 lines
Listing only the human-friendly names in the array like in the original patch could be a reasonable temporary solution. It won't allow us to use a single entry for all subclasses of a given type by now (e.g. listing only
TYPE_X86_CPUon PC), but at least we can address this issue without waiting for a refactor of the CPU model enumeration code.
Ah, I just re-read this. Do you mean go back to the original RFC and just use strcmp() to compare the human readable cpu_model?
Alistair
Quoted 11 lines
Ok, so it sounds like I'll respin this series with an extra column in the array for human readable names. Then in the future we can work on removing that.
Alistair
Quoted 4 lines
--
Eduardo
Quoted 83 lines · Alistair Francis
Quoted 74 lines · Alistair Francis
Quoted 73 lines · Eduardo Habkost
Quoted 37 lines · Alistair Francis
Quoted 35 lines · Alistair Francis
Quoted 34 lines · Peter Maydell
Quoted 21 lines · Alistair Francis
There are numorous QEMU machines that only have a single or a handful of valid CPU options. To simplyfy the management of specificying which CPU is/isn't valid let's create a property that can be set in the machine init. We can then check to see if the user supplied CPU is in that list or not.
I have added the
valid_cpu_typesfor some ARM machines only at the moment.Here is what specifying the CPUs looks like now:
$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m3" -S QEMU 2.10.50 monitor - type 'help' for more information (qemu) info cpus * CPU #0: thread_id=24175 (qemu) q$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m4" -S QEMU 2.10.50 monitor - type 'help' for more information (qemu) qQuoted 6 lines
$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m5" -S qemu-system-aarch64: unable to find CPU model 'cortex-m5'$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-a9" -S qemu-system-aarch64: Invalid CPU type: cortex-a9-arm-cpu The valid types are: cortex-m3-arm-cpu, cortex-m4-arm-cpuThanks for this; we really should be more strict about forbidding "won't work" combinations than we have been in the past.
Quoted 7 lines
Quoted 7 lines
Quoted 5 lines
In the last of these cases, I think that when we list the invalid CPU type and the valid types we should use the same names we want the user to use on the command line, without the "-arm-cpu" suffixes.
Hmm... That is a good point, it is confusing that they don't line up.
Agreed.
Quoted 4 lines
Quoted 4 lines
The problem is that we are just doing a simple
object_class_dynamic_cast()inhw/core/machine.cwhich I think (untested) requires us to have the full name in the valid cpu array.[...]
Quoted 5 lines
I think an earlier version of my previous series adding the support to
machine.cdid string comparison, but it was decided to utilise objects instead. One option is to make the array 2 wide and have the second string be user friendly?Making the array 2-column will duplicate information that we can already find out using other methods, and it won't solve the problem if an entry has a parent class with multiple subclasses (the original reason I suggested
object_class_dynamic_cast()).The main obstacle to fix this easily is that we do have a common
ObjectClass *cpu_class_by_name(const char*cpu_model)
function, but not a common method to get the model name from a CPUClass. Implementing this is possible, but probably better to do it after moving the existing arch-specific CPU model enumeration hooks to common code (currently we duplicate lots of CPU enumeration/lookup boilerplate code that we shouldn't have to).Quoted 6 lines
Quoted 6 lines
Listing only the human-friendly names in the array like in the original patch could be a reasonable temporary solution. It won't allow us to use a single entry for all subclasses of a given type by now (e.g. listing only
TYPE_X86_CPUon PC), but at least we can address this issue without waiting for a refactor of the CPU model enumeration code.
Quoted 2 lines
Ah, I just re-read this. Do you mean go back to the original RFC and just use
strcmp()to compare the human readablecpu_model?
Yes, I think this would be simpler, considering that the current users don't need the object_class_dynamic_cast() stuff.
Then whoever decide to make PC simply list TYPE_X86_CPU later (possibly me) will need to clean up the CPU model enumeration/lookup code and implement a cpu_model_from_type_name() helper.
Signature · 1 line
Eduardo
Quoted 83 lines · On Fri, 22 Dec 2017 11:47:00 -0800 Alistair Francis…
Quoted 74 lines · Alistair Francis
Quoted 73 lines · Eduardo Habkost
Quoted 37 lines · Alistair Francis
Quoted 35 lines · Alistair Francis
Quoted 34 lines · Peter Maydell
Quoted 21 lines · Alistair Francis
There are numorous QEMU machines that only have a single or a handful of valid CPU options. To simplyfy the management of specificying which CPU is/isn't valid let's create a property that can be set in the machine init. We can then check to see if the user supplied CPU is in that list or not.
I have added the
valid_cpu_typesfor some ARM machines only at the moment.Here is what specifying the CPUs looks like now:
$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m3" -S QEMU 2.10.50 monitor - type 'help' for more information (qemu) info cpus * CPU #0: thread_id=24175 (qemu) q$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m4" -S QEMU 2.10.50 monitor - type 'help' for more information (qemu) qQuoted 6 lines
$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m5" -S qemu-system-aarch64: unable to find CPU model 'cortex-m5'$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-a9" -S qemu-system-aarch64: Invalid CPU type: cortex-a9-arm-cpu The valid types are: cortex-m3-arm-cpu, cortex-m4-arm-cpuThanks for this; we really should be more strict about forbidding "won't work" combinations than we have been in the past.
Quoted 7 lines
Quoted 7 lines
Quoted 5 lines
In the last of these cases, I think that when we list the invalid CPU type and the valid types we should use the same names we want the user to use on the command line, without the "-arm-cpu" suffixes.
Hmm... That is a good point, it is confusing that they don't line up.
Agreed.
Quoted 4 lines
Quoted 4 lines
The problem is that we are just doing a simple
object_class_dynamic_cast()inhw/core/machine.cwhich I think (untested) requires us to have the full name in the valid cpu array.[...]
Quoted 5 lines
I think an earlier version of my previous series adding the support to
machine.cdid string comparison, but it was decided to utilise objects instead. One option is to make the array 2 wide and have the second string be user friendly?Making the array 2-column will duplicate information that we can already find out using other methods, and it won't solve the problem if an entry has a parent class with multiple subclasses (the original reason I suggested
object_class_dynamic_cast()).The main obstacle to fix this easily is that we do have a common
ObjectClass *cpu_class_by_name(const char*cpu_model)
function, but not a common method to get the model name from a CPUClass. Implementing this is possible, but probably better to do it after moving the existing arch-specific CPU model enumeration hooks to common code (currently we duplicate lots of CPU enumeration/lookup boilerplate code that we shouldn't have to).Quoted 6 lines
Quoted 6 lines
Listing only the human-friendly names in the array like in the original patch could be a reasonable temporary solution. It won't allow us to use a single entry for all subclasses of a given type by now (e.g. listing only
TYPE_X86_CPUon PC), but at least we can address this issue without waiting for a refactor of the CPU model enumeration code.
Quoted 2 lines
Ah, I just re-read this. Do you mean go back to the original RFC and just use
strcmp()to compare the human readablecpu_model?
It's sort of going backwards but I won't object to this as far as you won't use machine->cpu_model (which is in process of being removed)
BTW:
how hard is it, to add cpu_type2cpu_name function?
Quoted 13 lines
Alistair
Quoted 11 lines
Ok, so it sounds like I'll respin this series with an extra column in the array for human readable names. Then in the future we can work on removing that.
Alistair
Quoted 4 lines
--
Eduardo
Quoted 86 lines · Igor Mammedov
Quoted 83 lines · On Fri, 22 Dec 2017 11:47:00 -0800 Alistair Francis…
Quoted 80 lines · Alistair Francis
Quoted 79 lines · Eduardo Habkost
Quoted 37 lines · Alistair Francis
Quoted 35 lines · Alistair Francis
Quoted 34 lines · Peter Maydell
Quoted 21 lines · Alistair Francis
There are numorous QEMU machines that only have a single or a handful of valid CPU options. To simplyfy the management of specificying which CPU is/isn't valid let's create a property that can be set in the machine init. We can then check to see if the user supplied CPU is in that list or not.
I have added the
valid_cpu_typesfor some ARM machines only at the moment.Here is what specifying the CPUs looks like now:
$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m3" -S QEMU 2.10.50 monitor - type 'help' for more information (qemu) info cpus * CPU #0: thread_id=24175 (qemu) q$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m4" -S QEMU 2.10.50 monitor - type 'help' for more information (qemu) qQuoted 6 lines
$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m5" -S qemu-system-aarch64: unable to find CPU model 'cortex-m5'$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-a9" -S qemu-system-aarch64: Invalid CPU type: cortex-a9-arm-cpu The valid types are: cortex-m3-arm-cpu, cortex-m4-arm-cpuThanks for this; we really should be more strict about forbidding "won't work" combinations than we have been in the past.
Quoted 7 lines
Quoted 7 lines
Quoted 5 lines
In the last of these cases, I think that when we list the invalid CPU type and the valid types we should use the same names we want the user to use on the command line, without the "-arm-cpu" suffixes.
Hmm... That is a good point, it is confusing that they don't line up.
Agreed.
Quoted 4 lines
Quoted 4 lines
The problem is that we are just doing a simple
object_class_dynamic_cast()inhw/core/machine.cwhich I think (untested) requires us to have the full name in the valid cpu array.[...]
Quoted 5 lines
I think an earlier version of my previous series adding the support to
machine.cdid string comparison, but it was decided to utilise objects instead. One option is to make the array 2 wide and have the second string be user friendly?Making the array 2-column will duplicate information that we can already find out using other methods, and it won't solve the problem if an entry has a parent class with multiple subclasses (the original reason I suggested
object_class_dynamic_cast()).The main obstacle to fix this easily is that we do have a common
ObjectClass *cpu_class_by_name(const char*cpu_model)
function, but not a common method to get the model name from a CPUClass. Implementing this is possible, but probably better to do it after moving the existing arch-specific CPU model enumeration hooks to common code (currently we duplicate lots of CPU enumeration/lookup boilerplate code that we shouldn't have to).Listing only the human-friendly names in the array like in the original patch could be a reasonable temporary solution. It won't allow us to use a single entry for all subclasses of a given type by now (e.g. listing only
TYPE_X86_CPUon PC), but at least we can address this issue without waiting for a refactor of the CPU model enumeration code.
Quoted 8 lines
Quoted 2 lines
Ah, I just re-read this. Do you mean go back to the original RFC and just use
strcmp()to compare the human readablecpu_model?It's sort of going backwards but I won't object to this as far as you won't use
machine->cpu_model(which is in process of being removed)BTW:
how hard is it, to addcpu_type2cpu_namefunction?
It shouldn't be hard, but I would like to avoid adding yet another arch-specific hook just for that. Probably we would need to clean up the existing CPU model enumeration/lookup code if we want to avoid increase duplication of code on arch-specific hooks.
Signature · 1 line
Eduardo
Quoted 87 lines · Eduardo Habkost
Quoted 86 lines · Igor Mammedov
Quoted 83 lines · On Fri, 22 Dec 2017 11:47:00 -0800 Alistair Francis…
Quoted 80 lines · Alistair Francis
Quoted 79 lines · Eduardo Habkost
Quoted 37 lines · Alistair Francis
Quoted 35 lines · Alistair Francis
Quoted 34 lines · Peter Maydell
Quoted 21 lines · Alistair Francis
There are numorous QEMU machines that only have a single or a handful of valid CPU options. To simplyfy the management of specificying which CPU is/isn't valid let's create a property that can be set in the machine init. We can then check to see if the user supplied CPU is in that list or not.
I have added the
valid_cpu_typesfor some ARM machines only at the moment.Here is what specifying the CPUs looks like now:
$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m3" -S QEMU 2.10.50 monitor - type 'help' for more information (qemu) info cpus * CPU #0: thread_id=24175 (qemu) q$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m4" -S QEMU 2.10.50 monitor - type 'help' for more information (qemu) qQuoted 6 lines
$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m5" -S qemu-system-aarch64: unable to find CPU model 'cortex-m5'$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-a9" -S qemu-system-aarch64: Invalid CPU type: cortex-a9-arm-cpu The valid types are: cortex-m3-arm-cpu, cortex-m4-arm-cpuThanks for this; we really should be more strict about forbidding "won't work" combinations than we have been in the past.
Quoted 7 lines
Quoted 7 lines
Quoted 5 lines
In the last of these cases, I think that when we list the invalid CPU type and the valid types we should use the same names we want the user to use on the command line, without the "-arm-cpu" suffixes.
Hmm... That is a good point, it is confusing that they don't line up.
Agreed.
Quoted 4 lines
Quoted 4 lines
The problem is that we are just doing a simple
object_class_dynamic_cast()inhw/core/machine.cwhich I think (untested) requires us to have the full name in the valid cpu array.[...]
Quoted 5 lines
I think an earlier version of my previous series adding the support to
machine.cdid string comparison, but it was decided to utilise objects instead. One option is to make the array 2 wide and have the second string be user friendly?Making the array 2-column will duplicate information that we can already find out using other methods, and it won't solve the problem if an entry has a parent class with multiple subclasses (the original reason I suggested
object_class_dynamic_cast()).The main obstacle to fix this easily is that we do have a common
ObjectClass *cpu_class_by_name(const char*cpu_model)
function, but not a common method to get the model name from a CPUClass. Implementing this is possible, but probably better to do it after moving the existing arch-specific CPU model enumeration hooks to common code (currently we duplicate lots of CPU enumeration/lookup boilerplate code that we shouldn't have to).Listing only the human-friendly names in the array like in the original patch could be a reasonable temporary solution. It won't allow us to use a single entry for all subclasses of a given type by now (e.g. listing only
TYPE_X86_CPUon PC), but at least we can address this issue without waiting for a refactor of the CPU model enumeration code.
Quoted 4 lines
Quoted 4 lines
Quoted 2 lines
Ah, I just re-read this. Do you mean go back to the original RFC and just use
strcmp()to compare the human readablecpu_model?It's sort of going backwards but I won't object to this as far as you won't use
machine->cpu_model(which is in process of being removed)
Wait, machine->cpu_model is the human readable name. Without using that we can't use just human readable strings for the valid cpu types.
Alistair
Quoted 14 lines
Quoted 4 lines
BTW:
how hard is it, to addcpu_type2cpu_namefunction?It shouldn't be hard, but I would like to avoid adding yet another arch-specific hook just for that. Probably we would need to clean up the existing CPU model enumeration/lookup code if we want to avoid increase duplication of code on arch-specific hooks.
--
Eduardo
Quoted 88 lines · Alistair Francis
Quoted 87 lines · Eduardo Habkost
Quoted 86 lines · Igor Mammedov
Quoted 83 lines · On Fri, 22 Dec 2017 11:47:00 -0800 Alistair Francis…
Quoted 80 lines · Alistair Francis
Quoted 79 lines · Eduardo Habkost
Quoted 37 lines · Alistair Francis
Quoted 35 lines · Alistair Francis
Quoted 34 lines · Peter Maydell
Quoted 21 lines · Alistair Francis
There are numorous QEMU machines that only have a single or a handful of valid CPU options. To simplyfy the management of specificying which CPU is/isn't valid let's create a property that can be set in the machine init. We can then check to see if the user supplied CPU is in that list or not.
I have added the
valid_cpu_typesfor some ARM machines only at the moment.Here is what specifying the CPUs looks like now:
$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m3" -S QEMU 2.10.50 monitor - type 'help' for more information (qemu) info cpus * CPU #0: thread_id=24175 (qemu) q$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m4" -S QEMU 2.10.50 monitor - type 'help' for more information (qemu) qQuoted 6 lines
$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m5" -S qemu-system-aarch64: unable to find CPU model 'cortex-m5'$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-a9" -S qemu-system-aarch64: Invalid CPU type: cortex-a9-arm-cpu The valid types are: cortex-m3-arm-cpu, cortex-m4-arm-cpuThanks for this; we really should be more strict about forbidding "won't work" combinations than we have been in the past.
Quoted 7 lines
Quoted 7 lines
Quoted 5 lines
In the last of these cases, I think that when we list the invalid CPU type and the valid types we should use the same names we want the user to use on the command line, without the "-arm-cpu" suffixes.
Hmm... That is a good point, it is confusing that they don't line up.
Agreed.
Quoted 4 lines
Quoted 4 lines
The problem is that we are just doing a simple
object_class_dynamic_cast()inhw/core/machine.cwhich I think (untested) requires us to have the full name in the valid cpu array.[...]
Quoted 5 lines
I think an earlier version of my previous series adding the support to
machine.cdid string comparison, but it was decided to utilise objects instead. One option is to make the array 2 wide and have the second string be user friendly?Making the array 2-column will duplicate information that we can already find out using other methods, and it won't solve the problem if an entry has a parent class with multiple subclasses (the original reason I suggested
object_class_dynamic_cast()).The main obstacle to fix this easily is that we do have a common
ObjectClass *cpu_class_by_name(const char*cpu_model)
function, but not a common method to get the model name from a CPUClass. Implementing this is possible, but probably better to do it after moving the existing arch-specific CPU model enumeration hooks to common code (currently we duplicate lots of CPU enumeration/lookup boilerplate code that we shouldn't have to).Listing only the human-friendly names in the array like in the original patch could be a reasonable temporary solution. It won't allow us to use a single entry for all subclasses of a given type by now (e.g. listing only
TYPE_X86_CPUon PC), but at least we can address this issue without waiting for a refactor of the CPU model enumeration code.
Quoted 7 lines
Quoted 4 lines
Quoted 4 lines
Quoted 2 lines
Ah, I just re-read this. Do you mean go back to the original RFC and just use
strcmp()to compare the human readablecpu_model?It's sort of going backwards but I won't object to this as far as you won't use
machine->cpu_model(which is in process of being removed)Wait,
machine->cpu_modelis the human readable name. Without using that we can't use just human readable strings for the valid cpu types.
Well, if we want to deprecate machine->cpu_model we need to offer an alternative first, otherwise we can't prevent people from using it.
Igor, do you see an (existing) alternative to machine->cpu_model that would allow us to avoid using it in machine_run_board_init()?
Signature · 1 line
Eduardo
Quoted 97 lines · On Wed, 10 Jan 2018 19:48:00 -0200 Eduardo Habkost <[email protected]> wrote:
Quoted 88 lines · Alistair Francis
Quoted 87 lines · Eduardo Habkost
Quoted 86 lines · Igor Mammedov
Quoted 83 lines · On Fri, 22 Dec 2017 11:47:00 -0800 Alistair Francis…
Quoted 80 lines · Alistair Francis
Quoted 79 lines · Eduardo Habkost
Quoted 37 lines · Alistair Francis
Quoted 35 lines · Alistair Francis
Quoted 34 lines · Peter Maydell
Quoted 21 lines · Alistair Francis
There are numorous QEMU machines that only have a single or a handful of valid CPU options. To simplyfy the management of specificying which CPU is/isn't valid let's create a property that can be set in the machine init. We can then check to see if the user supplied CPU is in that list or not.
I have added the
valid_cpu_typesfor some ARM machines only at the moment.Here is what specifying the CPUs looks like now:
$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m3" -S QEMU 2.10.50 monitor - type 'help' for more information (qemu) info cpus * CPU #0: thread_id=24175 (qemu) q$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m4" -S QEMU 2.10.50 monitor - type 'help' for more information (qemu) qQuoted 6 lines
$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m5" -S qemu-system-aarch64: unable to find CPU model 'cortex-m5'$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-a9" -S qemu-system-aarch64: Invalid CPU type: cortex-a9-arm-cpu The valid types are: cortex-m3-arm-cpu, cortex-m4-arm-cpuThanks for this; we really should be more strict about forbidding "won't work" combinations than we have been in the past.
Quoted 7 lines
Quoted 7 lines
Quoted 5 lines
In the last of these cases, I think that when we list the invalid CPU type and the valid types we should use the same names we want the user to use on the command line, without the "-arm-cpu" suffixes.
Hmm... That is a good point, it is confusing that they don't line up.
Agreed.
Quoted 4 lines
Quoted 4 lines
The problem is that we are just doing a simple
object_class_dynamic_cast()inhw/core/machine.cwhich I think (untested) requires us to have the full name in the valid cpu array.[...]
Quoted 5 lines
I think an earlier version of my previous series adding the support to
machine.cdid string comparison, but it was decided to utilise objects instead. One option is to make the array 2 wide and have the second string be user friendly?Making the array 2-column will duplicate information that we can already find out using other methods, and it won't solve the problem if an entry has a parent class with multiple subclasses (the original reason I suggested
object_class_dynamic_cast()).The main obstacle to fix this easily is that we do have a common
ObjectClass *cpu_class_by_name(const char*cpu_model)
function, but not a common method to get the model name from a CPUClass. Implementing this is possible, but probably better to do it after moving the existing arch-specific CPU model enumeration hooks to common code (currently we duplicate lots of CPU enumeration/lookup boilerplate code that we shouldn't have to).Listing only the human-friendly names in the array like in the original patch could be a reasonable temporary solution. It won't allow us to use a single entry for all subclasses of a given type by now (e.g. listing only
TYPE_X86_CPUon PC), but at least we can address this issue without waiting for a refactor of the CPU model enumeration code.Quoted 7 lines
Quoted 4 lines
Quoted 4 lines
Quoted 2 lines
Ah, I just re-read this. Do you mean go back to the original RFC and just use
strcmp()to compare the human readablecpu_model?It's sort of going backwards but I won't object to this as far as you won't use
machine->cpu_model(which is in process of being removed)Wait,
machine->cpu_modelis the human readable name. Without using that we can't use just human readable strings for the valid cpu types.
Quoted 7 lines
Well, if we want to deprecate
machine->cpu_modelwe need to offer an alternative first, otherwise we can't prevent people from using it.Igor, do you see an (existing) alternative to
machine->cpu_modelthat would allow us to avoid using it inmachine_run_board_init()?
In recently merged refactoring machine->cpu_model is being replaced by machine->cpu_type. So currently we don't need machine->cpu_model anywhere except machine('none'), and once I refactor that it could be dropped completely and after some work on *-user targets we can practically get rid of cpu_model notion completely (excluding of -cpu option parser).
My dislike of idea is that it's adding back cpumodel strings in boards code again (which I've just got rid of).
I hate to say that but it looks like we need more refactoring for this series to print cpumodels back to user.
We already have FOO_cpu_list()/FOO_query_cpu_definitions() which already do cpu type => cpumodel conversion (and even have some code duplication within a target), I'd suggest generalizing that across targets and then using generic helper for printing back to user converted cpu types from mc->valid_cpu_types which this series introduces.
Quoted 120 lines · Igor Mammedov
Quoted 97 lines · On Wed, 10 Jan 2018 19:48:00 -0200 Eduardo Habkost <[email protected]> wrote:
Quoted 88 lines · Alistair Francis
Quoted 87 lines · Eduardo Habkost
Quoted 86 lines · Igor Mammedov
Quoted 83 lines · On Fri, 22 Dec 2017 11:47:00 -0800 Alistair Francis…
Quoted 80 lines · Alistair Francis
Quoted 79 lines · Eduardo Habkost
Quoted 37 lines · Alistair Francis
Quoted 35 lines · Alistair Francis
Quoted 34 lines · Peter Maydell
Quoted 21 lines · Alistair Francis
There are numorous QEMU machines that only have a single or a handful of valid CPU options. To simplyfy the management of specificying which CPU is/isn't valid let's create a property that can be set in the machine init. We can then check to see if the user supplied CPU is in that list or not.
I have added the
valid_cpu_typesfor some ARM machines only at the moment.Here is what specifying the CPUs looks like now:
$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m3" -S QEMU 2.10.50 monitor - type 'help' for more information (qemu) info cpus * CPU #0: thread_id=24175 (qemu) q$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m4" -S QEMU 2.10.50 monitor - type 'help' for more information (qemu) qQuoted 6 lines
$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m5" -S qemu-system-aarch64: unable to find CPU model 'cortex-m5'$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-a9" -S qemu-system-aarch64: Invalid CPU type: cortex-a9-arm-cpu The valid types are: cortex-m3-arm-cpu, cortex-m4-arm-cpuThanks for this; we really should be more strict about forbidding "won't work" combinations than we have been in the past.
Quoted 7 lines
Quoted 7 lines
Quoted 5 lines
In the last of these cases, I think that when we list the invalid CPU type and the valid types we should use the same names we want the user to use on the command line, without the "-arm-cpu" suffixes.
Hmm... That is a good point, it is confusing that they don't line up.
Agreed.
Quoted 4 lines
Quoted 4 lines
The problem is that we are just doing a simple
object_class_dynamic_cast()inhw/core/machine.cwhich I think (untested) requires us to have the full name in the valid cpu array.[...]
Quoted 5 lines
I think an earlier version of my previous series adding the support to
machine.cdid string comparison, but it was decided to utilise objects instead. One option is to make the array 2 wide and have the second string be user friendly?Making the array 2-column will duplicate information that we can already find out using other methods, and it won't solve the problem if an entry has a parent class with multiple subclasses (the original reason I suggested
object_class_dynamic_cast()).The main obstacle to fix this easily is that we do have a common
ObjectClass *cpu_class_by_name(const char*cpu_model)
function, but not a common method to get the model name from a CPUClass. Implementing this is possible, but probably better to do it after moving the existing arch-specific CPU model enumeration hooks to common code (currently we duplicate lots of CPU enumeration/lookup boilerplate code that we shouldn't have to).Listing only the human-friendly names in the array like in the original patch could be a reasonable temporary solution. It won't allow us to use a single entry for all subclasses of a given type by now (e.g. listing only
TYPE_X86_CPUon PC), but at least we can address this issue without waiting for a refactor of the CPU model enumeration code.Quoted 7 lines
Quoted 4 lines
Quoted 4 lines
Quoted 2 lines
Ah, I just re-read this. Do you mean go back to the original RFC and just use
strcmp()to compare the human readablecpu_model?It's sort of going backwards but I won't object to this as far as you won't use
machine->cpu_model(which is in process of being removed)Wait,
machine->cpu_modelis the human readable name. Without using that we can't use just human readable strings for the valid cpu types.Quoted 7 lines
Well, if we want to deprecate
machine->cpu_modelwe need to offer an alternative first, otherwise we can't prevent people from using it.Igor, do you see an (existing) alternative to
machine->cpu_modelthat would allow us to avoid using it inmachine_run_board_init()?In recently merged refactoring
machine->cpu_modelis being replaced bymachine->cpu_type. So currently we don't needmachine->cpu_modelanywhere except machine('none'), and once I refactor that it could be dropped completely and after some work on *-user targets we can practically get rid ofcpu_modelnotion completely (excluding of -cpu option parser).My dislike of idea is that it's adding back cpumodel strings in boards code again (which I've just got rid of).
I hate to say that but it looks like we need more refactoring for this series to print cpumodels back to user.
Quoted 6 lines
We already have FOO_cpu_list()/FOO_query_cpu_definitions() which already do cpu type => cpumodel conversion (and even have some code duplication within a target), I'd suggest generalizing that across targets and then using generic helper for printing back to user converted cpu types from
mc->valid_cpu_typeswhich this series introduces.
I agree with the long term goal of making cpu type => cpu model conversion generic. But until we refactor the arch-specific code and implement that, we have 2 options:
1) Keep printing a confusing error message until we implement cpu type => cpu model conversion;
2) Keep the MachineState::cpu_model field until we implement cpu type => cpu model conversion.
I don't see any reason to pick (1) instead of (2).
Signature · 1 line
Eduardo
Quoted 132 lines · Eduardo Habkost
Quoted 120 lines · Igor Mammedov
Quoted 97 lines · On Wed, 10 Jan 2018 19:48:00 -0200 Eduardo Habkost <[email protected]> wrote:
Quoted 88 lines · Alistair Francis
Quoted 87 lines · Eduardo Habkost
Quoted 86 lines · Igor Mammedov
Quoted 83 lines · On Fri, 22 Dec 2017 11:47:00 -0800 Alistair Francis…
Quoted 80 lines · Alistair Francis
Quoted 79 lines · Eduardo Habkost
Quoted 37 lines · Alistair Francis
Quoted 35 lines · Alistair Francis
Quoted 34 lines · Peter Maydell
Quoted 27 lines · Alistair Francis
There are numorous QEMU machines that only have a single or a handful of
valid CPU options. To simplyfy the management of specificying which CPU
is/isn't valid let's create a property that can be set in the machine
init. We can then check to see if the user supplied CPU is in that list
or not.I have added the valid_cpu_types for some ARM machines only at the
moment.Here is what specifying the CPUs looks like now:
$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m3" -S
QEMU 2.10.50 monitor - type 'help' for more information
(qemu) info cpus
* CPU #0: thread_id=24175
(qemu) q$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m4" -S
QEMU 2.10.50 monitor - type 'help' for more information
(qemu) q$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-m5" -S
qemu-system-aarch64: unable to find CPU model 'cortex-m5'$ aarch64-softmmu/qemu-system-aarch64 -M netduino2 -kernel ./u-boot.elf -nographic -cpu "cortex-a9" -S
qemu-system-aarch64: Invalid CPU type: cortex-a9-arm-cpu
The valid types are: cortex-m3-arm-cpu, cortex-m4-arm-cpuThanks for this; we really should be more strict about forbidding "won't work" combinations than we have been in the past.
Quoted 7 lines
Quoted 7 lines
Quoted 5 lines
In the last of these cases, I think that when we list the invalid CPU type and the valid types we should use the same names we want the user to use on the command line, without the "-arm-cpu" suffixes.
Hmm... That is a good point, it is confusing that they don't line up.
Agreed.
Quoted 4 lines
Quoted 4 lines
The problem is that we are just doing a simple
object_class_dynamic_cast()inhw/core/machine.cwhich I think (untested) requires us to have the full name in the valid cpu array.[...]
Quoted 5 lines
I think an earlier version of my previous series adding the support to
machine.cdid string comparison, but it was decided to utilise objects instead. One option is to make the array 2 wide and have the second string be user friendly?Making the array 2-column will duplicate information that we can already find out using other methods, and it won't solve the problem if an entry has a parent class with multiple subclasses (the original reason I suggested
object_class_dynamic_cast()).The main obstacle to fix this easily is that we do have a common
ObjectClass *cpu_class_by_name(const char*cpu_model)
function, but not a common method to get the model name from a CPUClass. Implementing this is possible, but probably better to do it after moving the existing arch-specific CPU model enumeration hooks to common code (currently we duplicate lots of CPU enumeration/lookup boilerplate code that we shouldn't have to).Listing only the human-friendly names in the array like in the original patch could be a reasonable temporary solution. It won't allow us to use a single entry for all subclasses of a given type by now (e.g. listing only
TYPE_X86_CPUon PC), but at least we can address this issue without waiting for a refactor of the CPU model enumeration code.Quoted 7 lines
Quoted 4 lines
Quoted 4 lines
Quoted 2 lines
Ah, I just re-read this. Do you mean go back to the original RFC and just use
strcmp()to compare the human readablecpu_model?It's sort of going backwards but I won't object to this as far as you won't use
machine->cpu_model(which is in process of being removed)Wait,
machine->cpu_modelis the human readable name. Without using that we can't use just human readable strings for the valid cpu types.Quoted 7 lines
Well, if we want to deprecate
machine->cpu_modelwe need to offer an alternative first, otherwise we can't prevent people from using it.Igor, do you see an (existing) alternative to
machine->cpu_modelthat would allow us to avoid using it inmachine_run_board_init()?In recently merged refactoring
machine->cpu_modelis being replaced bymachine->cpu_type. So currently we don't needmachine->cpu_modelanywhere except machine('none'), and once I refactor that it could be dropped completely and after some work on *-user targets we can practically get rid ofcpu_modelnotion completely (excluding of -cpu option parser).My dislike of idea is that it's adding back cpumodel strings in boards code again (which I've just got rid of).
I hate to say that but it looks like we need more refactoring for this series to print cpumodels back to user.
Quoted 6 lines
We already have FOO_cpu_list()/FOO_query_cpu_definitions() which already do cpu type => cpumodel conversion (and even have some code duplication within a target), I'd suggest generalizing that across targets and then using generic helper for printing back to user converted cpu types from
mc->valid_cpu_typeswhich this series introduces.I agree with the long term goal of making cpu type => cpu model conversion generic. But until we refactor the arch-specific code and implement that, we have 2 options:
Quoted 6 lines
1) Keep printing a confusing error message until we implement cpu type => cpu model conversion;
2) Keep theMachineState::cpu_modelfield until we implement cpu type => cpu model conversion.I don't see any reason to pick (1) instead of (2).
Ok, I'm going over this again (sorry for the delay).
I'm going to respin using machine->cpu_model. It shouldn't be hard to refactor in the future to machine->cpu_type, once that is or can be translated to a user friendly string.
Alistair
Quoted 4 lines
--
Eduardo