void
configure()
{
extern int boothowto;
if (config_rootfound("backplane", NULL) == NULL)
panic("backplane not configured");
#if GENERIC
if ((boothowto & RB_ASKNAME) == 0)
setroot();
setconf();
#else
setroot();
#endif
/*
* Configure swap area and related system
* parameter based on device(s) used.
*/
swapconf();
dumpconf();
cold = 0;
mtpr(GC_CCF, PR_TXDB); /* Clear cold start flag in cpu */
}
/*
* Determine i/o configuration for a machine.
*/
configure()
{
register int *ip;
extern caddr_t Sysbase;
vbafind(numvba, (caddr_t)vmem, VMEMmap);
numvba++;
/*
* Write protect the scb. It is strange
* that this code is here, but this is as soon
* as we are done mucking with it, and the
* write-enable was done in assembly language
* to which we will never return.
*/
ip = (int *)&Sysmap[2]; *ip &= ~PG_PROT; *ip |= PG_KR;
mtpr(TBIS, Sysbase+2*NBPG);
#if GENERIC
if ((boothowto & RB_ASKNAME) == 0)
setroot();
setconf();
#else
setroot();
#endif
/*
* Configure swap area and related system
* parameter based on device(s) used.
*/
swapconf();
cold = 0;
}
void
cpu_rootconf(void)
{
if (booted_device == NULL) {
printf("FATAL: boot device not found, check your firmware "
"settings!\n");
setroot(NULL, 0);
return;
}
if (config_handle_wedges(booted_device, booted_partition) == 0)
setroot(booted_wedge, 0);
else
setroot(booted_device, booted_partition);
}
static void mk_new_int(JRB l, JRB r, JRB p, int il)
{
JRB newnode;
newnode = (JRB) calloc(1, sizeof(struct jrb_node));
setint(newnode);
setred(newnode);
setnormal(newnode);
newnode->flink = l;
newnode->blink = r;
newnode->parent = p;
setlext(newnode, l);
setrext(newnode, r);
l->parent = newnode;
r->parent = newnode;
setleft(l);
setright(r);
if (ishead(p)) {
p->parent = newnode;
setroot(newnode);
} else if (il) {
setleft(newnode);
p->flink = newnode;
} else {
setright(newnode);
p->blink = newnode;
}
recolor(newnode);
}
/*
* Now that we are fully operational, we can checksum the
* disks, and using some heuristics, hopefully are able to
* always determine the correct root disk.
*/
void
diskconf()
{
extern struct timeout scoop_checkdisk;
dev_t tmpdev;
#if 0
/*
* Configure root, swap, and dump area. This is
* currently done by running the same checksum
* algorithm over all known disks, as was done in
* /boot. Then we basically fixup the *dev vars
* from the info we gleaned from this.
*/
dkcsumattach();
#endif
/*
* XXX
* zaurus bootblocks currently pass in "bsd" instead of
* "device:bsd", or any such thing, making this a real pain.
*/
if (bootdv == NULL)
bootdv = parsedisk("wd0a", strlen("wd0a"), 0, &tmpdev);
if (bootdv == NULL)
printf("boot device: lookup '%s' failed.\n", boot_file);
else
printf("boot device: %s\n", bootdv->dv_xname);
setroot(bootdv, 0, RB_USERREQ);
dumpconf();
timeout_add(&scoop_checkdisk, hz/25);
}
Rb_node rb_insert_b(Rb_node n, char *key, char *val)
{
Rb_node newleft, newright, newnode, p;
if (ishead(n)) {
if (n->p.root == n) { /* Tree is empty */
mk_new_ext(newnode, key, val);
insert(newnode, n);
n->p.root = newnode;
newnode->p.parent = n;
setroot(newnode);
return newnode;
} else {
mk_new_ext(newright, key, val);
insert(newright, n);
newleft = newright->c.list.blink;
setnormal(newleft);
mk_new_int(newleft, newright, newleft->p.parent, isleft(newleft));
p = rprev(newright);
if (!ishead(p)) p->k.lext = newright;
return newright;
}
} else {
mk_new_ext(newleft, key, val);
insert(newleft, n);
setnormal(n);
mk_new_int(newleft, n, n->p.parent, isleft(n));
p = lprev(newleft);
if (!ishead(p)) p->v.rext = newleft;
return newleft;
}
}
static void mk_new_int(Rb_node l, Rb_node r, Rb_node p, int il)
{
Rb_node newnode;
newnode = (Rb_node) malloc(sizeof(struct rb_node));
setint(newnode);
setred(newnode);
setnormal(newnode);
newnode->c.child.left = l;
newnode->c.child.right = r;
newnode->p.parent = p;
newnode->k.lext = l;
newnode->v.rext = r;
l->p.parent = newnode;
r->p.parent = newnode;
setleft(l);
setright(r);
if (ishead(p)) {
p->p.root = newnode;
setroot(newnode);
} else if (il) {
setleft(newnode);
p->c.child.left = newnode;
} else {
setright(newnode);
p->c.child.right = newnode;
}
recolor(newnode);
}
void
cpu_rootconf()
{
/* No boot information */
setroot(0, 0);
}
static JRB jrb_insert_b(JRB n, Jval key, Jval val)
{
JRB newleft, newright, newnode, p;
if (ishead(n)) {
if (n->parent == n) { /* Tree is empty */
mk_new_ext(newnode, key, val);
insert(newnode, n);
n->parent = newnode;
newnode->parent = n;
setroot(newnode);
return newnode;
} else {
mk_new_ext(newright, key, val);
insert(newright, n);
newleft = newright->blink;
setnormal(newleft);
mk_new_int(newleft, newright, newleft->parent, isleft(newleft));
p = rprev(newright);
if (!ishead(p)) setlext(p, newright);
return newright;
}
} else {
mk_new_ext(newleft, key, val);
insert(newleft, n);
setnormal(n);
mk_new_int(newleft, n, n->parent, isleft(n));
p = lprev(newleft);
if (!ishead(p)) setrext(p, newleft);
return newleft;
}
}
void
cpu_rootconf()
{
#if 1 /* XXX to be reworked with helps of 2nd stage loaders XXX */
int i;
char *devname, *cp;
extern char bootarg[64];
cp = bootarg;
devname = "sd0";
for (i = 0; i < sizeof(bootarg); i++) {
if (*cp == '\0')
break;
if (*cp == 'E' && memcmp("ENADDR=", cp, 7) == 0) {
devname = "le0";
break;
}
cp++;
}
booted_device = find_dev_byname(devname);
#endif
printf("boot device: %s\n",
(booted_device) ? booted_device->dv_xname : "<unknown>");
setroot(booted_device, 0); /* XXX partition 'a' XXX */
}
/*
* Set up the root device from the boot args
*/
void
cpu_rootconf(void)
{
printf("boot device: %s\n",
booted_device != NULL ? booted_device->dv_xname : "<unknown>");
setroot(booted_device, booted_partition);
}
void
cpu_rootconf()
{
if (booted_device == NULL) /* XXX: Platform support. Match to boot device. */
printf("WARNING: can't figure what device matches \"%s\"\n", "XXX");
setroot(booted_device, booted_partition);
}
void
cpu_rootconf(void)
{
aprint_normal("boot device: %s\n",
(booted_device != NULL) ? booted_device->dv_xname : "<unknown>");
setroot(booted_device, booted_partition);
}
void
diskconf()
{
setroot();
#if 0
dumpconf();
#endif
}
void
diskconf(void)
{
printf("boot device: %s\n",
(bootdv) ? bootdv->dv_xname : "<unknown>");
setroot(bootdv, 0, RB_USERREQ);
dumpconf();
}
void
diskconf(void)
{
printf("boot device: %s\n",
bootdv ? bootdv->dv_xname : "<unknown>");
setroot(bootdv, booted_partition, RB_USERREQ);
dumpconf();
}
void
cpu_rootconf(void)
{
device_t rdev;
rdev = device_find_by_xname("md0");
setroot(rdev, 0);
}
void
cpu_rootconf(void)
{
findroot();
matchbiosdisks();
if (booted_wedge) {
KASSERT(booted_device != NULL);
aprint_normal("boot device: %s (%s)\n",
device_xname(booted_wedge), device_xname(booted_device));
setroot(booted_wedge, 0);
} else {
aprint_normal("boot device: %s\n",
booted_device ? device_xname(booted_device) : "<unknown>");
setroot(booted_device, booted_partition);
}
}
void
cpu_rootconf(void)
{
printf("boot device: %s\n",
booted_device ? booted_device->dv_xname : "<unknown>");
setroot(booted_device, booted_device ? bootdev_data->partition : 0);
}
void
cpu_rootconf()
{
findroot();
printf("boot device: %s\n",
booted_device ? booted_device->dv_xname : "<unknown>");
setroot(booted_device, booted_partition);
}
/*
* Set up the root device from the boot args
*/
void
cpu_rootconf(void)
{
#ifndef MEMORY_DISK_IS_ROOT
set_root_device();
printf("boot device: %s\n",
booted_device != NULL ? booted_device->dv_xname : "<unknown>");
#endif
setroot(booted_device, booted_partition);
}
void
cpu_rootconf(void)
{
/* XXXCGD don't know how to find the root device */
printf("boot device: %s\n",
booted_device ? booted_device->dv_xname : "<unknown>");
setroot(booted_device, booted_partition);
}
void
diskconf(void)
{
if (bootdv == NULL)
printf("boot device: unknown (rpb %d/%d)\n",
rpb.devtyp, rpb.unit);
else
printf("boot device: %s\n", bootdv->dv_xname);
setroot(bootdv, booted_partition, RB_USERREQ);
dumpconf();
}
void
diskconf(void)
{
print_devpath("bootpath", &PAGE0->mem_boot);
#if NMPATH > 0
if (bootdv != NULL)
bootdv = mpath_bootdv(bootdv);
#endif
setroot(bootdv, 0, RB_USERREQ);
dumpconf();
}
void
diskconf(void)
{
printf("bootpath: %s\n", bootpath);
#if NMPATH > 0
if (bootdv != NULL)
bootdv = mpath_bootdv(bootdv);
#endif
setroot(bootdv, 0, RB_USERREQ);
dumpconf();
}
/*
* Now that we are fully operational, we can checksum the
* disks, and using some heuristics, hopefully are able to
* always determine the correct root disk.
*/
void
diskconf(void)
{
int majdev, unit, part = 0;
struct device *bootdv = NULL;
dev_t tmpdev;
char buf[128];
extern bios_bootmac_t *bios_bootmac;
dkcsumattach();
if ((bootdev & B_MAGICMASK) == (u_int)B_DEVMAGIC) {
majdev = B_TYPE(bootdev);
unit = B_UNIT(bootdev);
part = B_PARTITION(bootdev);
snprintf(buf, sizeof buf, "%s%d%c", findblkname(majdev),
unit, part + 'a');
bootdv = parsedisk(buf, strlen(buf), part, &tmpdev);
}
if (bios_bootmac) {
struct ifnet *ifp;
for (ifp = TAILQ_FIRST(&ifnet); ifp != NULL;
ifp = TAILQ_NEXT(ifp, if_list)) {
if (ifp->if_type == IFT_ETHER &&
bcmp(bios_bootmac->mac,
((struct arpcom *)ifp)->ac_enaddr,
ETHER_ADDR_LEN) == 0)
break;
}
if (ifp) {
#if defined(NFSCLIENT)
printf("PXE boot MAC address %s, interface %s\n",
ether_sprintf(bios_bootmac->mac), ifp->if_xname);
bootdv = parsedisk(ifp->if_xname, strlen(ifp->if_xname),
0, &tmpdev);
part = 0;
#endif
} else
printf("PXE boot MAC address %s, interface %s\n",
ether_sprintf(bios_bootmac->mac), "unknown");
}
setroot(bootdv, part, RB_USERREQ);
dumpconf();
#ifdef HIBERNATE
hibernate_resume();
#endif /* HIBERNATE */
}
void connect(int x, int y) {
if (getfa(x) == getfa(y)) {
setroot(x);
access(y);
splay(y);
makesame(y);
}
else{
size++;
d[size] = 1;
link(x, size);
link(y, size);
}
}
void
cpu_rootconf()
{
struct device *booted_device;
int booted_partition;
findroot(&booted_device, &booted_partition);
matchbiosdisks();
printf("boot device: %s\n",
booted_device ? booted_device->dv_xname : "<unknown>");
setroot(booted_device, booted_partition, i386_nam2blk);
}
void
cpu_rootconf(void)
{
printf("boot device: %s",
(booted_device) ? booted_device->dv_xname : "<unknown>");
if (bootpart)
printf(" (partition %d)\n", bootpart);
else
printf("\n");
setroot(booted_device, bootpart);
}
void
diskconf(void)
{
struct device *bootdv;
int bootpartition;
if (booted_device == NULL)
printf("WARNING: can't figure what device matches \"%s\"\n",
boot_dev);
bootdv = booted_device;
bootpartition = booted_partition;
setroot(bootdv, bootpartition, RB_USERREQ);
dumpconf();
}
