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(); }