include/hw/boards.h

   1 /* Declarations for use by board files for creating devices.  */
   2
   3 #ifndef HW_BOARDS_H
   4 #define HW_BOARDS_H
   5
   6 #include "exec/memory.h"
   7 #include "sysemu/hostmem.h"
   8 #include "sysemu/blockdev.h"
   9 #include "qapi/qapi-types-machine.h"
  10 #include "qemu/module.h"
  11 #include "qom/object.h"
  12 #include "hw/core/cpu.h"
  13
  14 #define TYPE_MACHINE_SUFFIX "-machine"
  15
  16 /* Machine class name that needs to be used for class-name-based machine
  17  * type lookup to work.
  18  */
  19 #define MACHINE_TYPE_NAME(machinename) (machinename TYPE_MACHINE_SUFFIX)
  20
  21 #define TYPE_MACHINE "machine"
  22 #undef MACHINE  /* BSD defines it and QEMU does not use it */
  23 OBJECT_DECLARE_TYPE(MachineState, MachineClass, MACHINE)
  24
  25 extern MachineState *current_machine;
  26
  27 /**
  28  * machine_class_default_cpu_type: Return the machine default CPU type.
  29  * @mc: Machine class
  30  */
  31 const char *machine_class_default_cpu_type(MachineClass *mc);
  32
  33 void machine_add_audiodev_property(MachineClass *mc);
  34 void machine_run_board_init(MachineState *machine, const char *mem_path, Error **errp);
  35 bool machine_usb(MachineState *machine);
  36 int machine_phandle_start(MachineState *machine);
  37 bool machine_dump_guest_core(MachineState *machine);
  38 bool machine_mem_merge(MachineState *machine);
  39 HotpluggableCPUList *machine_query_hotpluggable_cpus(MachineState *machine);
  40 void machine_set_cpu_numa_node(MachineState *machine,
  41                                const CpuInstanceProperties *props,
  42                                Error **errp);
  43 void machine_parse_smp_config(MachineState *ms,
  44                               const SMPConfiguration *config, Error **errp);
  45 unsigned int machine_topo_get_cores_per_socket(const MachineState *ms);
  46 unsigned int machine_topo_get_threads_per_socket(const MachineState *ms);
  47 void machine_memory_devices_init(MachineState *ms, hwaddr base, uint64_t size);
  48
  49 /**
  50  * machine_class_allow_dynamic_sysbus_dev: Add type to list of valid devices
  51  * @mc: Machine class
  52  * @type: type to allow (should be a subtype of TYPE_SYS_BUS_DEVICE)
  53  *
  54  * Add the QOM type @type to the list of devices of which are subtypes
  55  * of TYPE_SYS_BUS_DEVICE but which are still permitted to be dynamically
  56  * created (eg by the user on the command line with -device).
  57  * By default if the user tries to create any devices on the command line
  58  * that are subtypes of TYPE_SYS_BUS_DEVICE they will get an error message;
  59  * for the special cases which are permitted for this machine model, the
  60  * machine model class init code must call this function to add them
  61  * to the list of specifically permitted devices.
  62  */
  63 void machine_class_allow_dynamic_sysbus_dev(MachineClass *mc, const char *type);
  64
  65 /**
  66  * device_type_is_dynamic_sysbus: Check if type is an allowed sysbus device
  67  * type for the machine class.
  68  * @mc: Machine class
  69  * @type: type to check (should be a subtype of TYPE_SYS_BUS_DEVICE)
  70  *
  71  * Returns: true if @type is a type in the machine's list of
  72  * dynamically pluggable sysbus devices; otherwise false.
  73  *
  74  * Check if the QOM type @type is in the list of allowed sysbus device
  75  * types (see machine_class_allowed_dynamic_sysbus_dev()).
  76  * Note that if @type has a parent type in the list, it is allowed too.
  77  */
  78 bool device_type_is_dynamic_sysbus(MachineClass *mc, const char *type);
  79
  80 /**
  81  * device_is_dynamic_sysbus: test whether device is a dynamic sysbus device
  82  * @mc: Machine class
  83  * @dev: device to check
  84  *
  85  * Returns: true if @dev is a sysbus device on the machine's list
  86  * of dynamically pluggable sysbus devices; otherwise false.
  87  *
  88  * This function checks whether @dev is a valid dynamic sysbus device,
  89  * by first confirming that it is a sysbus device and then checking it
  90  * against the list of permitted dynamic sysbus devices which has been
  91  * set up by the machine using machine_class_allow_dynamic_sysbus_dev().
  92  *
  93  * It is valid to call this with something that is not a subclass of
  94  * TYPE_SYS_BUS_DEVICE; the function will return false in this case.
  95  * This allows hotplug callback functions to be written as:
  96  *     if (device_is_dynamic_sysbus(mc, dev)) {
  97  *         handle dynamic sysbus case;
  98  *     } else if (some other kind of hotplug) {
  99  *         handle that;
 100  *     }
 101  */
 102 bool device_is_dynamic_sysbus(MachineClass *mc, DeviceState *dev);
 103
 104 /*
 105  * Checks that backend isn't used, preps it for exclusive usage and
 106  * returns migratable MemoryRegion provided by backend.
 107  */
 108 MemoryRegion *machine_consume_memdev(MachineState *machine,
 109                                      HostMemoryBackend *backend);
 110
 111 /**
 112  * CPUArchId:
 113  * @arch_id - architecture-dependent CPU ID of present or possible CPU
 114  * @cpu - pointer to corresponding CPU object if it's present on NULL otherwise
 115  * @type - QOM class name of possible @cpu object
 116  * @props - CPU object properties, initialized by board
 117  * #vcpus_count - number of threads provided by @cpu object
 118  */
 119 typedef struct CPUArchId {
 120     uint64_t arch_id;
 121     int64_t vcpus_count;
 122     CpuInstanceProperties props;
 123     Object *cpu;
 124     const char *type;
 125 } CPUArchId;
 126
 127 /**
 128  * CPUArchIdList:
 129  * @len - number of @CPUArchId items in @cpus array
 130  * @cpus - array of present or possible CPUs for current machine configuration
 131  */
 132 typedef struct {
 133     int len;
 134     CPUArchId cpus[];
 135 } CPUArchIdList;
 136
 137 /**
 138  * SMPCompatProps:
 139  * @prefer_sockets - whether sockets are preferred over cores in smp parsing
 140  * @dies_supported - whether dies are supported by the machine
 141  * @clusters_supported - whether clusters are supported by the machine
 142  * @has_clusters - whether clusters are explicitly specified in the user
 143  *                 provided SMP configuration
 144  * @books_supported - whether books are supported by the machine
 145  * @drawers_supported - whether drawers are supported by the machine
 146  */
 147 typedef struct {
 148     bool prefer_sockets;
 149     bool dies_supported;
 150     bool clusters_supported;
 151     bool has_clusters;
 152     bool books_supported;
 153     bool drawers_supported;
 154 } SMPCompatProps;
 155
 156 /**
 157  * MachineClass:
 158  * @deprecation_reason: If set, the machine is marked as deprecated. The
 159  *    string should provide some clear information about what to use instead.
 160  * @max_cpus: maximum number of CPUs supported. Default: 1
 161  * @min_cpus: minimum number of CPUs supported. Default: 1
 162  * @default_cpus: number of CPUs instantiated if none are specified. Default: 1
 163  * @is_default:
 164  *    If true QEMU will use this machine by default if no '-M' option is given.
 165  * @get_hotplug_handler: this function is called during bus-less
 166  *    device hotplug. If defined it returns pointer to an instance
 167  *    of HotplugHandler object, which handles hotplug operation
 168  *    for a given @dev. It may return NULL if @dev doesn't require
 169  *    any actions to be performed by hotplug handler.
 170  * @cpu_index_to_instance_props:
 171  *    used to provide @cpu_index to socket/core/thread number mapping, allowing
 172  *    legacy code to perform mapping from cpu_index to topology properties
 173  *    Returns: tuple of socket/core/thread ids given cpu_index belongs to.
 174  *    used to provide @cpu_index to socket number mapping, allowing
 175  *    a machine to group CPU threads belonging to the same socket/package
 176  *    Returns: socket number given cpu_index belongs to.
 177  * @hw_version:
 178  *    Value of QEMU_VERSION when the machine was added to QEMU.
 179  *    Set only by old machines because they need to keep
 180  *    compatibility on code that exposed QEMU_VERSION to guests in
 181  *    the past (and now use qemu_hw_version()).
 182  * @possible_cpu_arch_ids:
 183  *    Returns an array of @CPUArchId architecture-dependent CPU IDs
 184  *    which includes CPU IDs for present and possible to hotplug CPUs.
 185  *    Caller is responsible for freeing returned list.
 186  * @get_default_cpu_node_id:
 187  *    returns default board specific node_id value for CPU slot specified by
 188  *    index @idx in @ms->possible_cpus[]
 189  * @has_hotpluggable_cpus:
 190  *    If true, board supports CPUs creation with -device/device_add.
 191  * @default_cpu_type:
 192  *    specifies default CPU_TYPE, which will be used for parsing target
 193  *    specific features and for creating CPUs if CPU name wasn't provided
 194  *    explicitly at CLI
 195  * @minimum_page_bits:
 196  *    If non-zero, the board promises never to create a CPU with a page size
 197  *    smaller than this, so QEMU can use a more efficient larger page
 198  *    size than the target architecture's minimum. (Attempting to create
 199  *    such a CPU will fail.) Note that changing this is a migration
 200  *    compatibility break for the machine.
 201  * @ignore_memory_transaction_failures:
 202  *    If this is flag is true then the CPU will ignore memory transaction
 203  *    failures which should cause the CPU to take an exception due to an
 204  *    access to an unassigned physical address; the transaction will instead
 205  *    return zero (for a read) or be ignored (for a write). This should be
 206  *    set only by legacy board models which rely on the old RAZ/WI behaviour
 207  *    for handling devices that QEMU does not yet model. New board models
 208  *    should instead use "unimplemented-device" for all memory ranges where
 209  *    the guest will attempt to probe for a device that QEMU doesn't
 210  *    implement and a stub device is required.
 211  * @kvm_type:
 212  *    Return the type of KVM corresponding to the kvm-type string option or
 213  *    computed based on other criteria such as the host kernel capabilities.
 214  *    kvm-type may be NULL if it is not needed.
 215  * @numa_mem_supported:
 216  *    true if '--numa node.mem' option is supported and false otherwise
 217  * @hotplug_allowed:
 218  *    If the hook is provided, then it'll be called for each device
 219  *    hotplug to check whether the device hotplug is allowed.  Return
 220  *    true to grant allowance or false to reject the hotplug.  When
 221  *    false is returned, an error must be set to show the reason of
 222  *    the rejection.  If the hook is not provided, all hotplug will be
 223  *    allowed.
 224  * @default_ram_id:
 225  *    Specifies initial RAM MemoryRegion name to be used for default backend
 226  *    creation if user explicitly hasn't specified backend with "memory-backend"
 227  *    property.
 228  *    It also will be used as a way to option into "-m" option support.
 229  *    If it's not set by board, '-m' will be ignored and generic code will
 230  *    not create default RAM MemoryRegion.
 231  * @fixup_ram_size:
 232  *    Amends user provided ram size (with -m option) using machine
 233  *    specific algorithm. To be used by old machine types for compat
 234  *    purposes only.
 235  *    Applies only to default memory backend, i.e., explicit memory backend
 236  *    wasn't used.
 237  */
 238 struct MachineClass {
 239     /*< private >*/
 240     ObjectClass parent_class;
 241     /*< public >*/
 242
 243     const char *family; /* NULL iff @name identifies a standalone machtype */
 244     char *name;
 245     const char *alias;
 246     const char *desc;
 247     const char *deprecation_reason;
 248
 249     void (*init)(MachineState *state);
 250     void (*reset)(MachineState *state, ShutdownCause reason);
 251     void (*wakeup)(MachineState *state);
 252     int (*kvm_type)(MachineState *machine, const char *arg);
 253
 254     BlockInterfaceType block_default_type;
 255     int units_per_default_bus;
 256     int max_cpus;
 257     int min_cpus;
 258     int default_cpus;
 259     unsigned int no_serial:1,
 260         no_parallel:1,
 261         no_floppy:1,
 262         no_cdrom:1,
 263         no_sdcard:1,
 264         pci_allow_0_address:1,
 265         legacy_fw_cfg_order:1;
 266     bool is_default;
 267     const char *default_machine_opts;
 268     const char *default_boot_order;
 269     const char *default_display;
 270     const char *default_nic;
 271     GPtrArray *compat_props;
 272     const char *hw_version;
 273     ram_addr_t default_ram_size;
 274     const char *default_cpu_type;
 275     bool default_kernel_irqchip_split;
 276     bool option_rom_has_mr;
 277     bool rom_file_has_mr;
 278     int minimum_page_bits;
 279     bool has_hotpluggable_cpus;
 280     bool ignore_memory_transaction_failures;
 281     int numa_mem_align_shift;
 282     const char * const *valid_cpu_types;
 283     strList *allowed_dynamic_sysbus_devices;
 284     bool auto_enable_numa_with_memhp;
 285     bool auto_enable_numa_with_memdev;
 286     bool ignore_boot_device_suffixes;
 287     bool smbus_no_migration_support;
 288     bool nvdimm_supported;
 289     bool numa_mem_supported;
 290     bool auto_enable_numa;
 291     bool cpu_cluster_has_numa_boundary;
 292     SMPCompatProps smp_props;
 293     const char *default_ram_id;
 294
 295     HotplugHandler *(*get_hotplug_handler)(MachineState *machine,
 296                                            DeviceState *dev);
 297     bool (*hotplug_allowed)(MachineState *state, DeviceState *dev,
 298                             Error **errp);
 299     CpuInstanceProperties (*cpu_index_to_instance_props)(MachineState *machine,
 300                                                          unsigned cpu_index);
 301     const CPUArchIdList *(*possible_cpu_arch_ids)(MachineState *machine);
 302     int64_t (*get_default_cpu_node_id)(const MachineState *ms, int idx);
 303     ram_addr_t (*fixup_ram_size)(ram_addr_t size);
 304 };
 305
 306 /**
 307  * DeviceMemoryState:
 308  * @base: address in guest physical address space where the memory
 309  * address space for memory devices starts
 310  * @mr: memory region container for memory devices
 311  * @as: address space for memory devices
 312  * @listener: memory listener used to track used memslots in the address space
 313  * @dimm_size: the sum of plugged DIMMs' sizes
 314  * @used_region_size: the part of @mr already used by memory devices
 315  * @required_memslots: the number of memslots required by memory devices
 316  * @used_memslots: the number of memslots currently used by memory devices
 317  * @memslot_auto_decision_active: whether any plugged memory device
 318  *                                automatically decided to use more than
 319  *                                one memslot
 320  */
 321 typedef struct DeviceMemoryState {
 322     hwaddr base;
 323     MemoryRegion mr;
 324     AddressSpace as;
 325     MemoryListener listener;
 326     uint64_t dimm_size;
 327     uint64_t used_region_size;
 328     unsigned int required_memslots;
 329     unsigned int used_memslots;
 330     unsigned int memslot_auto_decision_active;
 331 } DeviceMemoryState;
 332
 333 /**
 334  * CpuTopology:
 335  * @cpus: the number of present logical processors on the machine
 336  * @drawers: the number of drawers on the machine
 337  * @books: the number of books in one drawer
 338  * @sockets: the number of sockets in one book
 339  * @dies: the number of dies in one socket
 340  * @clusters: the number of clusters in one die
 341  * @cores: the number of cores in one cluster
 342  * @threads: the number of threads in one core
 343  * @max_cpus: the maximum number of logical processors on the machine
 344  */
 345 typedef struct CpuTopology {
 346     unsigned int cpus;
 347     unsigned int drawers;
 348     unsigned int books;
 349     unsigned int sockets;
 350     unsigned int dies;
 351     unsigned int clusters;
 352     unsigned int cores;
 353     unsigned int threads;
 354     unsigned int max_cpus;
 355 } CpuTopology;
 356
 357 /**
 358  * MachineState:
 359  */
 360 struct MachineState {
 361     /*< private >*/
 362     Object parent_obj;
 363
 364     /*< public >*/
 365
 366     void *fdt;
 367     char *dtb;
 368     char *dumpdtb;
 369     int phandle_start;
 370     char *dt_compatible;
 371     bool dump_guest_core;
 372     bool mem_merge;
 373     bool usb;
 374     bool usb_disabled;
 375     char *firmware;
 376     bool iommu;
 377     bool suppress_vmdesc;
 378     bool enable_graphics;
 379     ConfidentialGuestSupport *cgs;
 380     HostMemoryBackend *memdev;
 381     /*
 382      * convenience alias to ram_memdev_id backend memory region
 383      * or to numa container memory region
 384      */
 385     MemoryRegion *ram;
 386     DeviceMemoryState *device_memory;
 387
 388     /*
 389      * Included in MachineState for simplicity, but not supported
 390      * unless machine_add_audiodev_property is called.  Boards
 391      * that have embedded audio devices can call it from the
 392      * machine init function and forward the property to the device.
 393      */
 394     char *audiodev;
 395
 396     ram_addr_t ram_size;
 397     ram_addr_t maxram_size;
 398     uint64_t   ram_slots;
 399     BootConfiguration boot_config;
 400     char *kernel_filename;
 401     char *kernel_cmdline;
 402     char *initrd_filename;
 403     const char *cpu_type;
 404     AccelState *accelerator;
 405     CPUArchIdList *possible_cpus;
 406     CpuTopology smp;
 407     struct NVDIMMState *nvdimms_state;
 408     struct NumaState *numa_state;
 409 };
 410
 411 #define DEFINE_MACHINE(namestr, machine_initfn) \
 412     static void machine_initfn##_class_init(ObjectClass *oc, void *data) \
 413     { \
 414         MachineClass *mc = MACHINE_CLASS(oc); \
 415         machine_initfn(mc); \
 416     } \
 417     static const TypeInfo machine_initfn##_typeinfo = { \
 418         .name       = MACHINE_TYPE_NAME(namestr), \
 419         .parent     = TYPE_MACHINE, \
 420         .class_init = machine_initfn##_class_init, \
 421     }; \
 422     static void machine_initfn##_register_types(void) \
 423     { \
 424         type_register_static(&machine_initfn##_typeinfo); \
 425     } \
 426     type_init(machine_initfn##_register_types)
 427
 428 extern GlobalProperty hw_compat_8_2[];
 429 extern const size_t hw_compat_8_2_len;
 430
 431 extern GlobalProperty hw_compat_8_1[];
 432 extern const size_t hw_compat_8_1_len;
 433
 434 extern GlobalProperty hw_compat_8_0[];
 435 extern const size_t hw_compat_8_0_len;
 436
 437 extern GlobalProperty hw_compat_7_2[];
 438 extern const size_t hw_compat_7_2_len;
 439
 440 extern GlobalProperty hw_compat_7_1[];
 441 extern const size_t hw_compat_7_1_len;
 442
 443 extern GlobalProperty hw_compat_7_0[];
 444 extern const size_t hw_compat_7_0_len;
 445
 446 extern GlobalProperty hw_compat_6_2[];
 447 extern const size_t hw_compat_6_2_len;
 448
 449 extern GlobalProperty hw_compat_6_1[];
 450 extern const size_t hw_compat_6_1_len;
 451
 452 extern GlobalProperty hw_compat_6_0[];
 453 extern const size_t hw_compat_6_0_len;
 454
 455 extern GlobalProperty hw_compat_5_2[];
 456 extern const size_t hw_compat_5_2_len;
 457
 458 extern GlobalProperty hw_compat_5_1[];
 459 extern const size_t hw_compat_5_1_len;
 460
 461 extern GlobalProperty hw_compat_5_0[];
 462 extern const size_t hw_compat_5_0_len;
 463
 464 extern GlobalProperty hw_compat_4_2[];
 465 extern const size_t hw_compat_4_2_len;
 466
 467 extern GlobalProperty hw_compat_4_1[];
 468 extern const size_t hw_compat_4_1_len;
 469
 470 extern GlobalProperty hw_compat_4_0[];
 471 extern const size_t hw_compat_4_0_len;
 472
 473 extern GlobalProperty hw_compat_3_1[];
 474 extern const size_t hw_compat_3_1_len;
 475
 476 extern GlobalProperty hw_compat_3_0[];
 477 extern const size_t hw_compat_3_0_len;
 478
 479 extern GlobalProperty hw_compat_2_12[];
 480 extern const size_t hw_compat_2_12_len;
 481
 482 extern GlobalProperty hw_compat_2_11[];
 483 extern const size_t hw_compat_2_11_len;
 484
 485 extern GlobalProperty hw_compat_2_10[];
 486 extern const size_t hw_compat_2_10_len;
 487
 488 extern GlobalProperty hw_compat_2_9[];
 489 extern const size_t hw_compat_2_9_len;
 490
 491 extern GlobalProperty hw_compat_2_8[];
 492 extern const size_t hw_compat_2_8_len;
 493
 494 extern GlobalProperty hw_compat_2_7[];
 495 extern const size_t hw_compat_2_7_len;
 496
 497 extern GlobalProperty hw_compat_2_6[];
 498 extern const size_t hw_compat_2_6_len;
 499
 500 extern GlobalProperty hw_compat_2_5[];
 501 extern const size_t hw_compat_2_5_len;
 502
 503 extern GlobalProperty hw_compat_2_4[];
 504 extern const size_t hw_compat_2_4_len;
 505
 506 extern GlobalProperty hw_compat_2_3[];
 507 extern const size_t hw_compat_2_3_len;
 508
 509 extern GlobalProperty hw_compat_2_2[];
 510 extern const size_t hw_compat_2_2_len;
 511
 512 extern GlobalProperty hw_compat_2_1[];
 513 extern const size_t hw_compat_2_1_len;
 514
 515 #endif