/*
* Detect known Virtual Machine hosts by inspecting the emulated BIOS.
*/
enum vmm_guest_type
detect_virtual(void)
{
char *sysenv;
int i;
sysenv = kgetenv("smbios.bios.vendor");
if (sysenv != NULL) {
for (i = 0; vmm_bnames[i].str != NULL; i++)
if (strcmp(sysenv, vmm_bnames[i].str) == 0) {
kfreeenv(sysenv);
return (vmm_bnames[i].type);
}
kfreeenv(sysenv);
}
sysenv = kgetenv("smbios.system.product");
if (sysenv != NULL) {
for (i = 0; vmm_pnames[i].str != NULL; i++)
if (strcmp(sysenv, vmm_pnames[i].str) == 0) {
kfreeenv(sysenv);
return (vmm_pnames[i].type);
}
kfreeenv(sysenv);
}
return (VMM_GUEST_NONE);
}
/*
* Device bus method procedures
*/
static int
sili_probe (device_t dev)
{
const struct sili_device *ad;
if (kgetenv("hint.sili.disabled"))
return(ENXIO);
if (kgetenv("hint.sili.force150"))
SiliForceGen1 = -1;
if (kgetenv("hint.sili.nofeatures"))
SiliNoFeatures = -1;
ad = sili_lookup_device(dev);
if (ad) {
device_set_desc(dev, ad->name);
return(-5); /* higher priority the NATA */
}
return(ENXIO);
}
static int
ahci_attach (device_t dev)
{
struct ahci_softc *sc = device_get_softc(dev);
char name[16];
int error;
sc->sc_ad = ahci_lookup_device(dev);
if (sc->sc_ad == NULL)
return(ENXIO);
/*
* Some chipsets do not properly implement the AHCI spec and may
* require the link speed to be specifically requested.
*/
if (kgetenv("hint.ahci.force150"))
AhciForceGen = 1;
if (kgetenv("hint.ahci.force300"))
AhciForceGen = 2;
if (kgetenv("hint.ahci.force600"))
AhciForceGen = 3;
if (kgetenv("hint.ahci.nofeatures"))
AhciNoFeatures = -1;
if (kgetenv("hint.ahci.forcefbss"))
sc->sc_flags |= AHCI_F_FORCE_FBSS;
sysctl_ctx_init(&sc->sysctl_ctx);
ksnprintf(name, sizeof(name), "%s%d",
device_get_name(dev), device_get_unit(dev));
sc->sysctl_tree = SYSCTL_ADD_NODE(&sc->sysctl_ctx,
SYSCTL_STATIC_CHILDREN(_hw),
OID_AUTO, name, CTLFLAG_RD, 0, "");
error = sc->sc_ad->ad_attach(dev);
if (error) {
sysctl_ctx_free(&sc->sysctl_ctx);
sc->sysctl_tree = NULL;
}
return (error);
}
/*
* Device bus method procedures
*/
static int
ahci_probe (device_t dev)
{
const struct ahci_device *ad;
if (kgetenv("hint.ahci.disabled"))
return(ENXIO);
ad = ahci_lookup_device(dev);
if (ad) {
device_set_desc(dev, ad->name);
return(-5); /* higher priority the NATA */
}
return(ENXIO);
}
static void
fadt_probe(void)
{
struct acpi_fadt *fadt;
vm_paddr_t fadt_paddr;
enum intr_trigger trig;
enum intr_polarity pola;
int enabled = 1;
char *env;
fadt_paddr = sdt_search(ACPI_FADT_SIG);
if (fadt_paddr == 0) {
kprintf("fadt_probe: can't locate FADT\n");
return;
}
fadt = sdt_sdth_map(fadt_paddr);
KKASSERT(fadt != NULL);
/*
* FADT in ACPI specification 1.0 - 4.0
*/
if (fadt->fadt_hdr.sdth_rev < 1 || fadt->fadt_hdr.sdth_rev > 4) {
kprintf("fadt_probe: unsupported FADT revision %d\n",
fadt->fadt_hdr.sdth_rev);
goto back;
}
if (fadt->fadt_hdr.sdth_len < sizeof(*fadt)) {
kprintf("fadt_probe: invalid FADT length %u\n",
fadt->fadt_hdr.sdth_len);
goto back;
}
kgetenv_int("hw.acpi.sci.enabled", &enabled);
if (!enabled)
goto back;
acpi_sci_irq = fadt->fadt_sci_int;
env = kgetenv("hw.acpi.sci.trigger");
if (env == NULL)
goto back;
trig = INTR_TRIGGER_CONFORM;
if (strcmp(env, "edge") == 0)
trig = INTR_TRIGGER_EDGE;
else if (strcmp(env, "level") == 0)
trig = INTR_TRIGGER_LEVEL;
kfreeenv(env);
if (trig == INTR_TRIGGER_CONFORM)
goto back;
env = kgetenv("hw.acpi.sci.polarity");
if (env == NULL)
goto back;
pola = INTR_POLARITY_CONFORM;
if (strcmp(env, "high") == 0)
pola = INTR_POLARITY_HIGH;
else if (strcmp(env, "low") == 0)
pola = INTR_POLARITY_LOW;
kfreeenv(env);
if (pola == INTR_POLARITY_CONFORM)
goto back;
acpi_sci_trig = trig;
acpi_sci_pola = pola;
back:
if (acpi_sci_irq >= 0) {
FADT_VPRINTF("SCI irq %d, %s/%s\n", acpi_sci_irq,
intr_str_trigger(acpi_sci_trig),
intr_str_polarity(acpi_sci_pola));
} else {
FADT_VPRINTF("SCI is disabled\n");
}
sdt_sdth_unmap(&fadt->fadt_hdr);
}
int
vfs_mountroot_devfs(void)
{
struct vnode *vp;
struct nchandle nch;
struct nlookupdata nd;
struct mount *mp;
struct vfsconf *vfsp;
int error;
struct ucred *cred = proc0.p_ucred;
const char *devfs_path, *init_chroot;
char *dev_malloced = NULL;
if ((init_chroot = kgetenv("init_chroot")) != NULL) {
size_t l;
l = strlen(init_chroot) + sizeof("/dev");
dev_malloced = kmalloc(l, M_MOUNT, M_WAITOK);
ksnprintf(dev_malloced, l, "%s/dev", init_chroot);
devfs_path = dev_malloced;
} else {
devfs_path = "/dev";
}
/*
* Lookup the requested path and extract the nch and vnode.
*/
error = nlookup_init_raw(&nd,
devfs_path, UIO_SYSSPACE, NLC_FOLLOW,
cred, &rootnch);
if (error == 0) {
devfs_debug(DEVFS_DEBUG_DEBUG, "vfs_mountroot_devfs: nlookup_init is ok...\n");
if ((error = nlookup(&nd)) == 0) {
devfs_debug(DEVFS_DEBUG_DEBUG, "vfs_mountroot_devfs: nlookup is ok...\n");
if (nd.nl_nch.ncp->nc_vp == NULL) {
devfs_debug(DEVFS_DEBUG_SHOW, "vfs_mountroot_devfs: nlookup: simply not found\n");
error = ENOENT;
}
}
}
if (dev_malloced != NULL)
kfree(dev_malloced, M_MOUNT), dev_malloced = NULL;
devfs_path = NULL;
if (error) {
nlookup_done(&nd);
devfs_debug(DEVFS_DEBUG_SHOW, "vfs_mountroot_devfs: nlookup failed, error: %d\n", error);
return (error);
}
/*
* Extract the locked+refd ncp and cleanup the nd structure
*/
nch = nd.nl_nch;
cache_zero(&nd.nl_nch);
nlookup_done(&nd);
/*
* now we have the locked ref'd nch and unreferenced vnode.
*/
vp = nch.ncp->nc_vp;
if ((error = vget(vp, LK_EXCLUSIVE)) != 0) {
cache_put(&nch);
devfs_debug(DEVFS_DEBUG_SHOW, "vfs_mountroot_devfs: vget failed\n");
return (error);
}
cache_unlock(&nch);
if ((error = vinvalbuf(vp, V_SAVE, 0, 0)) != 0) {
cache_drop(&nch);
vput(vp);
devfs_debug(DEVFS_DEBUG_SHOW, "vfs_mountroot_devfs: vinvalbuf failed\n");
return (error);
}
if (vp->v_type != VDIR) {
cache_drop(&nch);
vput(vp);
devfs_debug(DEVFS_DEBUG_SHOW, "vfs_mountroot_devfs: vp is not VDIR\n");
return (ENOTDIR);
}
vfsp = vfsconf_find_by_name("devfs");
vsetflags(vp, VMOUNT);
/*
* Allocate and initialize the filesystem.
*/
mp = kmalloc(sizeof(struct mount), M_MOUNT, M_ZERO|M_WAITOK);
mount_init(mp);
vfs_busy(mp, LK_NOWAIT);
mp->mnt_op = vfsp->vfc_vfsops;
mp->mnt_vfc = vfsp;
vfsp->vfc_refcount++;
mp->mnt_stat.f_type = vfsp->vfc_typenum;
mp->mnt_flag |= vfsp->vfc_flags & MNT_VISFLAGMASK;
strncpy(mp->mnt_stat.f_fstypename, vfsp->vfc_name, MFSNAMELEN);
mp->mnt_stat.f_owner = cred->cr_uid;
vn_unlock(vp);
/*
* Mount the filesystem.
*/
error = VFS_MOUNT(mp, "/dev", NULL, cred);
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
/*
* Put the new filesystem on the mount list after root. The mount
* point gets its own mnt_ncmountpt (unless the VFS already set one
* up) which represents the root of the mount. The lookup code
* detects the mount point going forward and checks the root of
* the mount going backwards.
*
* It is not necessary to invalidate or purge the vnode underneath
* because elements under the mount will be given their own glue
* namecache record.
*/
if (!error) {
if (mp->mnt_ncmountpt.ncp == NULL) {
/*
* allocate, then unlock, but leave the ref intact
*/
cache_allocroot(&mp->mnt_ncmountpt, mp, NULL);
cache_unlock(&mp->mnt_ncmountpt);
}
mp->mnt_ncmounton = nch; /* inherits ref */
nch.ncp->nc_flag |= NCF_ISMOUNTPT;
/* XXX get the root of the fs and cache_setvp(mnt_ncmountpt...) */
vclrflags(vp, VMOUNT);
mountlist_insert(mp, MNTINS_LAST);
vn_unlock(vp);
//checkdirs(&mp->mnt_ncmounton, &mp->mnt_ncmountpt);
error = vfs_allocate_syncvnode(mp);
if (error) {
devfs_debug(DEVFS_DEBUG_SHOW, "vfs_mountroot_devfs: vfs_allocate_syncvnode failed\n");
}
vfs_unbusy(mp);
error = VFS_START(mp, 0);
vrele(vp);
} else {
vfs_rm_vnodeops(mp, NULL, &mp->mnt_vn_coherency_ops);
vfs_rm_vnodeops(mp, NULL, &mp->mnt_vn_journal_ops);
vfs_rm_vnodeops(mp, NULL, &mp->mnt_vn_norm_ops);
vfs_rm_vnodeops(mp, NULL, &mp->mnt_vn_spec_ops);
vfs_rm_vnodeops(mp, NULL, &mp->mnt_vn_fifo_ops);
vclrflags(vp, VMOUNT);
mp->mnt_vfc->vfc_refcount--;
vfs_unbusy(mp);
kfree(mp, M_MOUNT);
cache_drop(&nch);
vput(vp);
devfs_debug(DEVFS_DEBUG_SHOW, "vfs_mountroot_devfs: mount failed\n");
}
devfs_debug(DEVFS_DEBUG_DEBUG, "rootmount_devfs done with error: %d\n", error);
return (error);
}
/*
* Find and mount the root filesystem
*/
static void
vfs_mountroot(void *junk)
{
cdev_t save_rootdev = rootdev;
int i;
int dummy;
/*
* Make sure all disk devices created so far have also been probed,
* and also make sure that the newly created device nodes for
* probed disks are ready, too.
*
* Messages can fly around here so get good synchronization
* coverage.
*
* XXX - Delay an additional 2 seconds to help drivers which pickup
* devices asynchronously and are not caught by CAM's initial
* probe.
*/
sync_devs();
tsleep(&dummy, 0, "syncer", hz*2);
/*
* The root filesystem information is compiled in, and we are
* booted with instructions to use it.
*/
#ifdef ROOTDEVNAME
if ((boothowto & RB_DFLTROOT) &&
!vfs_mountroot_try(ROOTDEVNAME))
return;
#endif
/*
* We are booted with instructions to prompt for the root filesystem,
* or to use the compiled-in default when it doesn't exist.
*/
if (boothowto & (RB_DFLTROOT | RB_ASKNAME)) {
if (!vfs_mountroot_ask())
return;
}
/*
* We've been given the generic "use CDROM as root" flag. This is
* necessary because one media may be used in many different
* devices, so we need to search for them.
*/
if (boothowto & RB_CDROM) {
for (i = 0; cdrom_rootdevnames[i] != NULL; i++) {
if (!vfs_mountroot_try(cdrom_rootdevnames[i]))
return;
}
}
/*
* Try to use the value read by the loader from /etc/fstab, or
* supplied via some other means. This is the preferred
* mechanism.
*/
if (!vfs_mountroot_try(kgetenv("vfs.root.mountfrom")))
return;
/*
* If a vfs set rootdev, try it (XXX VINUM HACK!)
*/
if (save_rootdev != NULL) {
rootdev = save_rootdev;
if (!vfs_mountroot_try(""))
return;
}
/*
* Try values that may have been computed by the machine-dependant
* legacy code.
*/
if (rootdevnames[0] && !vfs_mountroot_try(rootdevnames[0]))
return;
if (rootdevnames[1] && !vfs_mountroot_try(rootdevnames[1]))
return;
/*
* If we have a compiled-in default, and haven't already tried it, try
* it now.
*/
#ifdef ROOTDEVNAME
if (!(boothowto & RB_DFLTROOT))
if (!vfs_mountroot_try(ROOTDEVNAME))
return;
#endif
/*
* Everything so far has failed, prompt on the console if we haven't
* already tried that.
*/
if (!(boothowto & (RB_DFLTROOT | RB_ASKNAME)) && !vfs_mountroot_ask())
return;
panic("Root mount failed, startup aborted.");
}
static void
fadt_probe(void)
{
ACPI_TABLE_FADT *fadt;
vm_paddr_t fadt_paddr;
enum intr_trigger trig;
enum intr_polarity pola;
int enabled = 1;
char *env;
fadt_paddr = sdt_search(ACPI_SIG_FADT);
if (fadt_paddr == 0) {
kprintf("fadt_probe: can't locate FADT\n");
return;
}
fadt = sdt_sdth_map(fadt_paddr);
KKASSERT(fadt != NULL);
/*
* FADT in ACPI specification 1.0 - 6.0
*/
if (fadt->Header.Revision < 1 || fadt->Header.Revision > 6) {
kprintf("fadt_probe: unknown FADT revision %d\n",
fadt->Header.Revision);
}
if (fadt->Header.Length < ACPI_FADT_V1_SIZE) {
kprintf("fadt_probe: invalid FADT length %u (< %u)\n",
fadt->Header.Length, ACPI_FADT_V1_SIZE);
goto back;
}
kgetenv_int("hw.acpi.sci.enabled", &enabled);
if (!enabled)
goto back;
acpi_sci_irq = fadt->SciInterrupt;
env = kgetenv("hw.acpi.sci.trigger");
if (env == NULL)
goto back;
trig = INTR_TRIGGER_CONFORM;
if (strcmp(env, "edge") == 0)
trig = INTR_TRIGGER_EDGE;
else if (strcmp(env, "level") == 0)
trig = INTR_TRIGGER_LEVEL;
kfreeenv(env);
if (trig == INTR_TRIGGER_CONFORM)
goto back;
env = kgetenv("hw.acpi.sci.polarity");
if (env == NULL)
goto back;
pola = INTR_POLARITY_CONFORM;
if (strcmp(env, "high") == 0)
pola = INTR_POLARITY_HIGH;
else if (strcmp(env, "low") == 0)
pola = INTR_POLARITY_LOW;
kfreeenv(env);
if (pola == INTR_POLARITY_CONFORM)
goto back;
acpi_sci_trig = trig;
acpi_sci_pola = pola;
back:
if (acpi_sci_irq >= 0) {
FADT_VPRINTF("SCI irq %d, %s/%s\n", acpi_sci_irq,
intr_str_trigger(acpi_sci_trig),
intr_str_polarity(acpi_sci_pola));
} else {
FADT_VPRINTF("SCI is disabled\n");
}
sdt_sdth_unmap(&fadt->Header);
}
int
main(int argc, char **argv)
{
char *env, *eq, *val;
int ch, error;
error = 0;
val = NULL;
env = NULL;
while ((ch = getopt(argc, argv, "hNquv")) != -1) {
switch (ch) {
case 'h':
hflag++;
break;
case 'N':
Nflag++;
break;
case 'q':
qflag++;
break;
case 'u':
uflag++;
break;
case 'v':
vflag++;
break;
default:
usage();
}
}
argc -= optind;
argv += optind;
if (argc > 0) {
env = argv[0];
eq = strchr(env, '=');
if (eq != NULL) {
*eq++ = '\0';
val = eq;
}
argv++;
argc--;
}
if ((hflag || Nflag) && env != NULL)
usage();
if (argc > 0 || ((uflag || vflag) && env == NULL))
usage();
if (env == NULL) {
error = kdumpenv();
if (error && !qflag)
warn("kdumpenv");
} else if (val == NULL) {
if (uflag) {
error = kunsetenv(env);
if (error && !qflag)
warnx("unable to unset %s", env);
} else {
error = kgetenv(env);
if (error && !qflag)
warnx("unable to get %s", env);
}
} else {
error = ksetenv(env, val);
if (error && !qflag)
warnx("unable to set %s to %s", env, val);
}
return (error);
}
