自学教程：C++ DEVICE_CLASS函数代码示例

static void scsi_generic_class_initfn(ObjectClass *klass, void *data){    DeviceClass *dc = DEVICE_CLASS(klass);    SCSIDeviceClass *sc = SCSI_DEVICE_CLASS(klass);    sc->realize      = scsi_generic_realize;    sc->unrealize    = scsi_unrealize;    sc->alloc_req    = scsi_new_request;    sc->parse_cdb    = scsi_generic_parse_cdb;    dc->fw_name = "disk";    dc->desc = "pass through generic scsi device (/dev/sg*)";    dc->reset = scsi_generic_reset;    dc->props = scsi_generic_properties;    dc->vmsd  = &vmstate_scsi_device;}

static void apic_common_class_init(ObjectClass *klass, void *data){    ICCDeviceClass *idc = ICC_DEVICE_CLASS(klass);    DeviceClass *dc = DEVICE_CLASS(klass);    dc->vmsd = &vmstate_apic_common;    dc->reset = apic_reset_common;    dc->props = apic_properties_common;    idc->realize = apic_common_realize;    /*     * Reason: APIC and CPU need to be wired up by     * x86_cpu_apic_create()     */    dc->cannot_instantiate_with_device_add_yet = true;}

static void m25p80_class_init(ObjectClass *klass, void *data){    DeviceClass *dc = DEVICE_CLASS(klass);    SSISlaveClass *k = SSI_SLAVE_CLASS(klass);    M25P80Class *mc = M25P80_CLASS(klass);    k->realize = m25p80_realize;    k->transfer = m25p80_transfer8;    k->set_cs = m25p80_cs;    k->cs_polarity = SSI_CS_LOW;    dc->vmsd = &vmstate_m25p80;    dc->props = m25p80_properties;    dc->reset = m25p80_reset;    mc->pi = data;}

static void virtio_blk_class_init(ObjectClass *klass, void *data){    DeviceClass *dc = DEVICE_CLASS(klass);    VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);    dc->props = virtio_blk_properties;    set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);    vdc->realize = virtio_blk_device_realize;    vdc->unrealize = virtio_blk_device_unrealize;    vdc->get_config = virtio_blk_update_config;    vdc->set_config = virtio_blk_set_config;    vdc->get_features = virtio_blk_get_features;    vdc->set_status = virtio_blk_set_status;    vdc->reset = virtio_blk_reset;}

static void usb_braille_class_initfn(ObjectClass *klass, void *data){    DeviceClass *dc = DEVICE_CLASS(klass);    USBDeviceClass *uc = USB_DEVICE_CLASS(klass);    uc->init           = usb_serial_initfn;    uc->product_desc   = "QEMU USB Braille";    uc->usb_desc       = &desc_braille;    uc->handle_reset   = usb_serial_handle_reset;    uc->handle_control = usb_serial_handle_control;    uc->handle_data    = usb_serial_handle_data;    uc->handle_destroy = usb_serial_handle_destroy;    dc->vmsd = &vmstate_usb_serial;    dc->props = braille_properties;}

static void pic_common_class_init(ObjectClass *klass, void *data){    DeviceClass *dc = DEVICE_CLASS(klass);    dc->vmsd = &vmstate_pic_common;    dc->props = pic_properties_common;    dc->realize = pic_common_realize;    /*     * Reason: unlike ordinary ISA devices, the PICs need additional     * wiring: its IRQ input lines are set up by board code, and the     * wiring of the slave to the master is hard-coded in device model     * code.     */    dc->cannot_instantiate_with_device_add_yet = true;}

static void virtio_vga_class_init(ObjectClass *klass, void *data){    DeviceClass *dc = DEVICE_CLASS(klass);    VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);    PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);    set_bit(DEVICE_CATEGORY_DISPLAY, dc->categories);    dc->props = virtio_vga_properties;    dc->reset = virtio_vga_reset;    dc->hotpluggable = false;    k->realize = virtio_vga_realize;    pcidev_k->romfile = "vgabios-virtio.bin";    pcidev_k->class_id = PCI_CLASS_DISPLAY_VGA;}

static void lm32_cpu_class_init(ObjectClass *oc, void *data){    LM32CPUClass *lcc = LM32_CPU_CLASS(oc);    CPUClass *cc = CPU_CLASS(oc);    DeviceClass *dc = DEVICE_CLASS(oc);    lcc->parent_realize = dc->realize;    dc->realize = lm32_cpu_realizefn;    lcc->parent_reset = cc->reset;    cc->reset = lm32_cpu_reset;    cc->do_interrupt = lm32_cpu_do_interrupt;    cpu_class_set_vmsd(cc, &vmstate_lm32_cpu);}

static void quiesce_class_init(ObjectClass *klass, void *data){    DeviceClass *dc = DEVICE_CLASS(klass);    SCLPEventClass *k = SCLP_EVENT_CLASS(klass);    dc->reset = quiesce_reset;    dc->vmsd = &vmstate_sclpquiesce;    k->init = quiesce_init;    k->get_send_mask = send_mask;    k->get_receive_mask = receive_mask;    k->can_handle_event = can_handle_event;    k->read_event_data = read_event_data;    k->write_event_data = NULL;}

static void smbus_eeprom_class_initfn(ObjectClass *klass, void *data){    DeviceClass *dc = DEVICE_CLASS(klass);    SMBusDeviceClass *sc = SMBUS_DEVICE_CLASS(klass);    sc->init = smbus_eeprom_initfn;    sc->quick_cmd = eeprom_quick_cmd;    sc->send_byte = eeprom_send_byte;    sc->receive_byte = eeprom_receive_byte;    sc->write_data = eeprom_write_data;    sc->read_data = eeprom_read_data;    dc->props = smbus_eeprom_properties;    /* Reason: pointer property "data" */    dc->user_creatable = false;}

static void usb_braille_class_initfn(ObjectClass *klass, void *data){    DeviceClass *dc = DEVICE_CLASS(klass);    USBDeviceClass *uc = USB_DEVICE_CLASS(klass);    uc->realize        = usb_serial_realize;    uc->product_desc   = "QEMU USB Braille";    uc->usb_desc       = &desc_braille;    uc->handle_reset   = usb_serial_handle_reset;    uc->handle_control = usb_serial_handle_control;    uc->handle_data    = usb_serial_handle_data;    dc->vmsd = &vmstate_usb_serial;    dc->props = braille_properties;    set_bit(DEVICE_CATEGORY_INPUT, dc->categories);}

static void i6300esb_class_init(ObjectClass *klass, void *data){    DeviceClass *dc = DEVICE_CLASS(klass);    PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);    k->config_read = i6300esb_config_read;    k->config_write = i6300esb_config_write;    k->init = i6300esb_init;    k->vendor_id = PCI_VENDOR_ID_INTEL;    k->device_id = PCI_DEVICE_ID_INTEL_ESB_9;    k->class_id = PCI_CLASS_SYSTEM_OTHER;    dc->reset = i6300esb_reset;    dc->vmsd = &vmstate_i6300esb;    set_bit(DEVICE_CATEGORY_MISC, dc->categories);}

static void virtio_balloon_class_init(ObjectClass *klass, void *data){    DeviceClass *dc = DEVICE_CLASS(klass);    VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);    dc->props = virtio_balloon_properties;    set_bit(DEVICE_CATEGORY_MISC, dc->categories);    vdc->realize = virtio_balloon_device_realize;    vdc->unrealize = virtio_balloon_device_unrealize;    vdc->get_config = virtio_balloon_get_config;    vdc->set_config = virtio_balloon_set_config;    vdc->get_features = virtio_balloon_get_features;    vdc->save = virtio_balloon_save_device;    vdc->load = virtio_balloon_load_device;}

static void dec_21154_pci_bridge_class_init(ObjectClass *klass, void *data){    DeviceClass *dc = DEVICE_CLASS(klass);    PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);    k->init = pci_bridge_initfn;    k->exit = pci_bridge_exitfn;    k->vendor_id = PCI_VENDOR_ID_DEC;    k->device_id = PCI_DEVICE_ID_DEC_21154;    k->config_write = pci_bridge_write_config;    k->is_bridge = 1;    dc->desc = "DEC 21154 PCI-PCI bridge";    dc->reset = pci_bridge_reset;    dc->vmsd = &vmstate_pci_device;}

static void vhost_scsi_class_init(ObjectClass *klass, void *data){    DeviceClass *dc = DEVICE_CLASS(klass);    VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);    FWPathProviderClass *fwc = FW_PATH_PROVIDER_CLASS(klass);    dc->props = vhost_scsi_properties;    set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);    vdc->realize = vhost_scsi_realize;    vdc->unrealize = vhost_scsi_unrealize;    vdc->get_features = vhost_scsi_get_features;    vdc->set_config = vhost_scsi_set_config;    vdc->set_status = vhost_scsi_set_status;    fwc->get_dev_path = vhost_scsi_get_fw_dev_path;}

static void ich_ahci_class_init(ObjectClass *klass, void *data){    DeviceClass *dc = DEVICE_CLASS(klass);    PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);    k->realize = pci_ich9_ahci_realize;    k->exit = pci_ich9_uninit;    k->vendor_id = PCI_VENDOR_ID_INTEL;    k->device_id = PCI_DEVICE_ID_INTEL_82801IR;    k->revision = 0x02;    k->class_id = PCI_CLASS_STORAGE_SATA;    dc->vmsd = &vmstate_ich9_ahci;    dc->reset = pci_ich9_reset;    set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);}

static void spapr_vlan_class_init(ObjectClass *klass, void *data){    DeviceClass *dc = DEVICE_CLASS(klass);    VIOsPAPRDeviceClass *k = VIO_SPAPR_DEVICE_CLASS(klass);    k->init = spapr_vlan_init;    k->reset = spapr_vlan_reset;    k->devnode = spapr_vlan_devnode;    k->dt_name = "l-lan";    k->dt_type = "network";    k->dt_compatible = "IBM,l-lan";    k->signal_mask = 0x1;    dc->props = spapr_vlan_properties;    k->rtce_window_size = 0x10000000;}

static void virtual_css_bridge_class_init(ObjectClass *klass, void *data){    HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(klass);    DeviceClass *dc = DEVICE_CLASS(klass);    hc->unplug = ccw_device_unplug;    set_bit(DEVICE_CATEGORY_BRIDGE, dc->categories);    dc->props = virtual_css_bridge_properties;    object_class_property_add_bool(klass, "cssid-unrestricted",                                   prop_get_true, NULL, NULL);    object_class_property_set_description(klass, "cssid-unrestricted",            "A css device can use any cssid, regardless whether virtual"            " or not (read only, always true)",            NULL);}

static void generic_loader_class_init(ObjectClass *klass, void *data){    DeviceClass *dc = DEVICE_CLASS(klass);    /* The reset function is not registered here and is instead registered in     * the realize function to allow this device to be added via the device_add     * command in the QEMU monitor.     * TODO: Improve the device_add functionality to allow resets to be     * connected     */    dc->realize = generic_loader_realize;    dc->unrealize = generic_loader_unrealize;    dc->props = generic_loader_props;    dc->desc = "Generic Loader";}

static void virtio_cuda_class_init(ObjectClass *klass, void *data){	DeviceClass *dc = DEVICE_CLASS(klass);	VirtioDeviceClass *k = VIRTIO_DEVICE_CLASS(klass);	dc->props = virtio_cuda_properties;	set_bit(DEVICE_CATEGORY_INPUT, dc->categories);	k->realize = virtio_cuda_realize;	k->unrealize = virtio_cuda_unrealize;	k->get_features = get_features;	k->get_config = get_config;	k->set_config = set_config;	k->set_status = set_status;	k->reset = vser_reset;}

static void vhost_vsock_class_init(ObjectClass *klass, void *data){    DeviceClass *dc = DEVICE_CLASS(klass);    VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);    dc->props = vhost_vsock_properties;    dc->vmsd = &vmstate_virtio_vhost_vsock;    set_bit(DEVICE_CATEGORY_MISC, dc->categories);    vdc->realize = vhost_vsock_device_realize;    vdc->unrealize = vhost_vsock_device_unrealize;    vdc->get_features = vhost_vsock_get_features;    vdc->get_config = vhost_vsock_get_config;    vdc->set_status = vhost_vsock_set_status;    vdc->guest_notifier_mask = vhost_vsock_guest_notifier_mask;    vdc->guest_notifier_pending = vhost_vsock_guest_notifier_pending;}

static void mips_cpu_class_init(ObjectClass *c, void *data){    MIPSCPUClass *mcc = MIPS_CPU_CLASS(c);    CPUClass *cc = CPU_CLASS(c);    DeviceClass *dc = DEVICE_CLASS(c);    mcc->parent_realize = dc->realize;    dc->realize = mips_cpu_realizefn;    mcc->parent_reset = cc->reset;    cc->reset = mips_cpu_reset;    cc->do_interrupt = mips_cpu_do_interrupt;    cc->dump_state = mips_cpu_dump_state;    cpu_class_set_do_unassigned_access(cc, mips_cpu_unassigned_access);}

static void mch_class_init(ObjectClass *klass, void *data){    PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);    DeviceClass *dc = DEVICE_CLASS(klass);    k->init = mch_init;    k->config_write = mch_write_config;    dc->reset = mch_reset;    set_bit(DEVICE_CATEGORY_BRIDGE, dc->categories);    dc->desc = "Host bridge";    dc->vmsd = &vmstate_mch;    k->vendor_id = PCI_VENDOR_ID_INTEL;    k->device_id = PCI_DEVICE_ID_INTEL_Q35_MCH;    k->revision = MCH_HOST_BRIDGE_REVISION_DEFUALT;    k->class_id = PCI_CLASS_BRIDGE_HOST;}

static void pci_bridge_dev_class_init(ObjectClass *klass, void *data){    DeviceClass *dc = DEVICE_CLASS(klass);    PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);    k->init = pci_bridge_dev_initfn;    k->exit = pci_bridge_dev_exitfn;    k->config_write = pci_bridge_dev_write_config;    k->vendor_id = PCI_BRIDGE_DEV_VENDOR_ID;    k->device_id = PCI_BRIDGE_DEV_DEVICE_ID;    k->class_id = PCI_CLASS_BRIDGE_PCI;    k->is_bridge = 1,    dc->desc = "Standard PCI Bridge";    dc->reset = qdev_pci_bridge_dev_reset;    dc->props = pci_bridge_dev_properties;    dc->vmsd = &pci_bridge_dev_vmstate;}

static void gen_rp_dev_class_init(ObjectClass *klass, void *data){    DeviceClass *dc = DEVICE_CLASS(klass);    PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);    PCIERootPortClass *rpc = PCIE_ROOT_PORT_CLASS(klass);    k->vendor_id = PCI_VENDOR_ID_REDHAT;    k->device_id = PCI_DEVICE_ID_REDHAT_PCIE_RP;    dc->desc = "PCI Express Root Port";    dc->vmsd = &vmstate_rp_dev;    dc->props = gen_rp_props;    rpc->aer_vector = gen_rp_aer_vector;    rpc->interrupts_init = gen_rp_interrupts_init;    rpc->interrupts_uninit = gen_rp_interrupts_uninit;    rpc->aer_offset = GEN_PCIE_ROOT_PORT_AER_OFFSET;}

static void xen_platform_class_init(ObjectClass *klass, void *data){    DeviceClass *dc = DEVICE_CLASS(klass);    PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);    k->init = xen_platform_initfn;    k->vendor_id = PCI_VENDOR_ID_XEN;    k->device_id = PCI_DEVICE_ID_XEN_PLATFORM;    k->class_id = PCI_CLASS_OTHERS << 8 | 0x80;    k->subsystem_vendor_id = PCI_VENDOR_ID_XEN;    k->subsystem_id = PCI_DEVICE_ID_XEN_PLATFORM;    k->revision = 1;    dc->desc = "XEN platform pci device";    dc->reset = platform_reset;    dc->vmsd = &vmstate_xen_platform;}

static void ivshmem_common_class_init(ObjectClass *klass, void *data){    DeviceClass *dc = DEVICE_CLASS(klass);    PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);    k->realize = ivshmem_common_realize;    k->exit = ivshmem_exit;    k->config_write = ivshmem_write_config;    k->vendor_id = PCI_VENDOR_ID_IVSHMEM;    k->device_id = PCI_DEVICE_ID_IVSHMEM;    k->class_id = PCI_CLASS_MEMORY_RAM;    k->revision = 1;    dc->reset = ivshmem_reset;    set_bit(DEVICE_CATEGORY_MISC, dc->categories);    dc->desc = "Inter-VM shared memory";}

static void console_class_init(ObjectClass *klass, void *data){    DeviceClass *dc = DEVICE_CLASS(klass);    SCLPEventClass *ec = SCLP_EVENT_CLASS(klass);    dc->props = console_properties;    dc->reset = console_reset;    dc->vmsd = &vmstate_sclplmconsole;    ec->init = console_init;    ec->get_send_mask = send_mask;    ec->get_receive_mask = receive_mask;    ec->can_handle_event = can_handle_event;    ec->read_event_data = read_event_data;    ec->write_event_data = write_event_data;    set_bit(DEVICE_CATEGORY_INPUT, dc->categories);}

static void xtensa_cpu_class_init(ObjectClass *oc, void *data){    DeviceClass *dc = DEVICE_CLASS(oc);    CPUClass *cc = CPU_CLASS(oc);    XtensaCPUClass *xcc = XTENSA_CPU_CLASS(cc);    xcc->parent_realize = dc->realize;    dc->realize = xtensa_cpu_realizefn;    xcc->parent_reset = cc->reset;    cc->reset = xtensa_cpu_reset;    cc->do_interrupt = xtensa_cpu_do_interrupt;    cc->dump_state = xtensa_cpu_dump_state;    dc->vmsd = &vmstate_xtensa_cpu;}

static void s390_cpu_class_init(ObjectClass *oc, void *data){    S390CPUClass *scc = S390_CPU_CLASS(oc);    CPUClass *cc = CPU_CLASS(scc);    DeviceClass *dc = DEVICE_CLASS(oc);    scc->next_cpu_id = 0;    scc->parent_realize = dc->realize;    dc->realize = s390_cpu_realizefn;    scc->parent_reset = cc->reset;#if !defined(CONFIG_USER_ONLY)    scc->load_normal = s390_cpu_load_normal;#endif    scc->cpu_reset = s390_cpu_reset;    scc->initial_cpu_reset = s390_cpu_initial_reset;    cc->reset = s390_cpu_full_reset;    cc->class_by_name = s390_cpu_class_by_name,    cc->has_work = s390_cpu_has_work;    cc->do_interrupt = s390_cpu_do_interrupt;    cc->dump_state = s390_cpu_dump_state;    cc->set_pc = s390_cpu_set_pc;    cc->gdb_read_register = s390_cpu_gdb_read_register;    cc->gdb_write_register = s390_cpu_gdb_write_register;#ifdef CONFIG_USER_ONLY    cc->handle_mmu_fault = s390_cpu_handle_mmu_fault;#else    cc->get_phys_page_debug = s390_cpu_get_phys_page_debug;    cc->vmsd = &vmstate_s390_cpu;    cc->write_elf64_note = s390_cpu_write_elf64_note;    cc->cpu_exec_interrupt = s390_cpu_exec_interrupt;    cc->debug_excp_handler = s390x_cpu_debug_excp_handler;#endif    cc->disas_set_info = s390_cpu_disas_set_info;    cc->gdb_num_core_regs = S390_NUM_CORE_REGS;    cc->gdb_core_xml_file = "s390x-core64.xml";    cc->gdb_arch_name = s390_gdb_arch_name;    /*     * Reason: s390_cpu_realizefn() calls cpu_exec_init(), which saves     * the object in cpus -> dangling pointer after final     * object_unref().     */    dc->cannot_destroy_with_object_finalize_yet = true;    s390_cpu_model_class_register_props(oc);}