static struct xbd_attach_args *
get_xbda(xen_disk_t *xd)
{
switch (XEN_MAJOR(xd->device)) {
#if NSD > 0
case XEN_SCSI_DISK0_MAJOR:
case XEN_SCSI_DISK1_MAJOR ... XEN_SCSI_DISK7_MAJOR:
case XEN_SCSI_DISK8_MAJOR ... XEN_SCSI_DISK15_MAJOR:
if (xd->capacity == 0)
return NULL;
return &sd_ata;
case XEN_SCSI_CDROM_MAJOR:
return &cd_ata;
#endif
#if NWD > 0
case XEN_IDE0_MAJOR:
case XEN_IDE1_MAJOR:
case XEN_IDE2_MAJOR:
case XEN_IDE3_MAJOR:
case XEN_IDE4_MAJOR:
case XEN_IDE5_MAJOR:
case XEN_IDE6_MAJOR:
case XEN_IDE7_MAJOR:
case XEN_IDE8_MAJOR:
case XEN_IDE9_MAJOR:
switch (XD_TYPE(xd->info)) {
case XD_TYPE_CDROM:
return &cd_ata;
case XD_TYPE_DISK:
if (xd->capacity == 0)
return NULL;
return &wd_ata;
default:
return NULL;
}
break;
#endif
default:
if (xd->capacity == 0)
return NULL;
return &xbd_ata;
}
return NULL;
}
/*
* Attach the hypervisor.
*/
void
hypervisor_attach(device_t parent, device_t self, void *aux)
{
#if NPCI >0
#ifdef PCI_BUS_FIXUP
int pci_maxbus = 0;
#endif
#endif /* NPCI */
union hypervisor_attach_cookie hac;
char xen_extra_version[XEN_EXTRAVERSION_LEN];
static char xen_version_string[20];
int rc;
const struct sysctlnode *node = NULL;
xenkernfs_init();
xen_version = HYPERVISOR_xen_version(XENVER_version, NULL);
memset(xen_extra_version, 0, sizeof(xen_extra_version));
HYPERVISOR_xen_version(XENVER_extraversion, xen_extra_version);
rc = snprintf(xen_version_string, 20, "%d.%d%s", XEN_MAJOR(xen_version),
XEN_MINOR(xen_version), xen_extra_version);
aprint_normal(": Xen version %s\n", xen_version_string);
if (rc >= 20)
aprint_debug(": xen_version_string truncated\n");
sysctl_createv(NULL, 0, NULL, &node, 0,
CTLTYPE_NODE, "xen",
SYSCTL_DESCR("Xen top level node"),
NULL, 0, NULL, 0, CTL_MACHDEP, CTL_CREATE, CTL_EOL);
if (node != NULL) {
sysctl_createv(NULL, 0, &node, NULL, CTLFLAG_READONLY,
CTLTYPE_STRING, "version",
SYSCTL_DESCR("Xen hypervisor version"),
NULL, 0, xen_version_string, 0, CTL_CREATE, CTL_EOL);
}
aprint_verbose_dev(self, "features: ");
#define XEN_TST_F(n) \
if (xen_feature(XENFEAT_##n)) \
aprint_verbose(" %s", #n);
XEN_TST_F(writable_page_tables);
XEN_TST_F(writable_descriptor_tables);
XEN_TST_F(auto_translated_physmap);
XEN_TST_F(supervisor_mode_kernel);
XEN_TST_F(pae_pgdir_above_4gb);
XEN_TST_F(mmu_pt_update_preserve_ad);
XEN_TST_F(highmem_assist);
XEN_TST_F(gnttab_map_avail_bits);
XEN_TST_F(hvm_callback_vector);
XEN_TST_F(hvm_safe_pvclock);
XEN_TST_F(hvm_pirqs);
#undef XEN_TST_F
aprint_verbose("\n");
xengnt_init();
events_init();
memset(&hac, 0, sizeof(hac));
hac.hac_vcaa.vcaa_name = "vcpu";
hac.hac_vcaa.vcaa_caa.cpu_number = 0;
hac.hac_vcaa.vcaa_caa.cpu_role = CPU_ROLE_BP;
hac.hac_vcaa.vcaa_caa.cpu_func = NULL; /* See xen/x86/cpu.c:vcpu_attach() */
config_found_ia(self, "xendevbus", &hac.hac_vcaa, hypervisor_print);
#ifdef MULTIPROCESSOR
/*
* The xenstore contains the configured number of vcpus.
* The xenstore however, is not accessible until much later in
* the boot sequence. We therefore bruteforce check for
* allocated vcpus (See: cpu.c:vcpu_match()) by iterating
* through the maximum supported by NetBSD MP.
*/
cpuid_t vcpuid;
for (vcpuid = 1; vcpuid < maxcpus; vcpuid++) {
memset(&hac, 0, sizeof(hac));
hac.hac_vcaa.vcaa_name = "vcpu";
hac.hac_vcaa.vcaa_caa.cpu_number = vcpuid;
hac.hac_vcaa.vcaa_caa.cpu_role = CPU_ROLE_AP;
hac.hac_vcaa.vcaa_caa.cpu_func = NULL; /* See xen/x86/cpu.c:vcpu_attach() */
if (NULL == config_found_ia(self, "xendevbus", &hac.hac_vcaa,
hypervisor_vcpu_print)) {
break;
}
}
#endif /* MULTIPROCESSOR */
#if NXENBUS > 0
memset(&hac, 0, sizeof(hac));
hac.hac_xenbus.xa_device = "xenbus";
config_found_ia(self, "xendevbus", &hac.hac_xenbus, hypervisor_print);
#endif
#if NXENCONS > 0
memset(&hac, 0, sizeof(hac));
hac.hac_xencons.xa_device = "xencons";
config_found_ia(self, "xendevbus", &hac.hac_xencons, hypervisor_print);
#endif
#ifdef DOM0OPS
#if NPCI > 0
#if NACPICA > 0
if (acpi_present) {
memset(&hac, 0, sizeof(hac));
hac.hac_acpi.aa_iot = x86_bus_space_io;
hac.hac_acpi.aa_memt = x86_bus_space_mem;
hac.hac_acpi.aa_pc = NULL;
hac.hac_acpi.aa_pciflags =
PCI_FLAGS_IO_OKAY | PCI_FLAGS_MEM_OKAY |
PCI_FLAGS_MRL_OKAY | PCI_FLAGS_MRM_OKAY |
PCI_FLAGS_MWI_OKAY;
hac.hac_acpi.aa_ic = &x86_isa_chipset;
hac.hac_acpi.aa_dmat = &pci_bus_dma_tag;
#ifdef _LP64
hac.hac_acpi.aa_dmat64 = &pci_bus_dma64_tag;
#else
hac.hac_acpi.aa_dmat64 = NULL;
#endif /* _LP64 */
config_found_ia(self, "acpibus", &hac.hac_acpi, 0);
}
#endif /* NACPICA */
memset(&hac, 0, sizeof(hac));
hac.hac_pba.pba_iot = x86_bus_space_io;
hac.hac_pba.pba_memt = x86_bus_space_mem;
hac.hac_pba.pba_dmat = &pci_bus_dma_tag;
#ifdef _LP64
hac.hac_pba.pba_dmat64 = &pci_bus_dma64_tag;
#else
hac.hac_pba.pba_dmat64 = NULL;
#endif /* _LP64 */
hac.hac_pba.pba_flags = PCI_FLAGS_MEM_OKAY | PCI_FLAGS_IO_OKAY;
hac.hac_pba.pba_bridgetag = NULL;
hac.hac_pba.pba_bus = 0;
#if NACPICA > 0 && defined(ACPI_SCANPCI)
if (mpacpi_active)
mp_pci_scan(self, &hac.hac_pba, pcibusprint);
else
#endif
#if defined(MPBIOS) && defined(MPBIOS_SCANPCI)
if (mpbios_scanned != 0)
mp_pci_scan(self, &hac.hac_pba, pcibusprint);
else
#endif
config_found_ia(self, "pcibus", &hac.hac_pba, pcibusprint);
#if NACPICA > 0
if (mp_verbose)
acpi_pci_link_state();
#endif
#if NISA > 0
if (isa_has_been_seen == 0) {
memset(&hac, 0, sizeof(hac));
hac.hac_iba._iba_busname = "isa";
hac.hac_iba.iba_iot = x86_bus_space_io;
hac.hac_iba.iba_memt = x86_bus_space_mem;
hac.hac_iba.iba_dmat = &isa_bus_dma_tag;
hac.hac_iba.iba_ic = NULL; /* No isa DMA yet */
config_found_ia(self, "isabus", &hac.hac_iba, isabusprint);
}
#endif /* NISA */
#endif /* NPCI */
if (xendomain_is_privileged()) {
xenprivcmd_init();
xen_shm_init();
}
#endif /* DOM0OPS */
hypervisor_machdep_attach();
if (!pmf_device_register(self, hypervisor_suspend, hypervisor_resume))
aprint_error_dev(self, "couldn't establish power handler\n");
}
