void
cpu_startup()
{
vaddr_t minaddr, maxaddr;
/*
* Good {morning,afternoon,evening,night}.
*/
printf(version);
printf("real mem = %lu (%luMB)\n", ptoa(physmem),
ptoa(physmem)/1024/1024);
/*
* Grab machine dependent memory spaces
*/
platform->startup();
/*
* Allocate a submap for exec arguments. This map effectively
* limits the number of processes exec'ing at any time.
*/
minaddr = vm_map_min(kernel_map);
exec_map = uvm_km_suballoc(kernel_map, &minaddr, &maxaddr,
16 * NCARGS, VM_MAP_PAGEABLE, FALSE, NULL);
/*
* Allocate map for physio.
*/
phys_map = uvm_km_suballoc(kernel_map, &minaddr, &maxaddr,
VM_PHYS_SIZE, 0, FALSE, NULL);
printf("avail mem = %lu (%luMB)\n", ptoa(uvmexp.free),
ptoa(uvmexp.free)/1024/1024);
/*
* Set up buffers, so they can be used to read disk labels.
*/
bufinit();
/*
* Configure the system.
*/
if (boothowto & RB_CONFIG) {
#ifdef BOOT_CONFIG
user_config();
#else
printf("kernel does not support -c; continuing..\n");
#endif
}
}
/* ARGSUSED */
static void
print_mdoc_head(MDOC_ARGS)
{
print_gen_head(h);
bufinit(h);
bufcat_fmt(h, "%s(%s)", m->title, m->msec);
if (m->arch)
bufcat_fmt(h, " (%s)", m->arch);
print_otag(h, TAG_TITLE, 0, NULL);
print_text(h, h->buf);
}
/*
* initialisation function
* We start here as soon as we have a stack.
* Here we initialize the various systems
* and devices that need to be initialized.
*/
STARTUP(void kmain())
{
// TODO: move these to the appropriate headers
void vtinit();
void grayinit();
void loadavinit();
void battinit();
void usageinit();
void bogomips();
calloutinit();
lcdinit();
meminit();
grayinit();
vtinit();
linkinit();
audioinit();
sched_init();
procinit();
bufinit();
flashinit();
inodeinit();
loadavinit();
battinit();
usageinit();
#if 1
kprintf("%s build %s\n", uname_sysname, uname_version);
#else
kprintf("%s v%s\n", uname_sysname, uname_release);
kputs(
"Copyright 2005-2011 Christopher Williams <*****@*****.**>\n"
"Some portions copyright 2003, 2005 PpHd\n"
"\n"
"This program comes with ABSOLUTELY NO WARRANTY.\n"
"You may redistribute copies of this program\n"
"under the terms of the GNU General Public License.\n"
"\n");
#endif
if (realtime.tv_sec < 1000000000L) { /* before ~2001 */
extern const unsigned long build_date;
realtime.tv_sec = build_date;
realtime.tv_nsec = 0;
}
G.seconds = realtime.tv_sec;
uptime.tv_sec = uptime.tv_nsec = 0;
spl0();
bogomips();
}
static int
mdoc_nm_pre(MDOC_ARGS)
{
struct htmlpair tag;
struct roffsu su;
int len;
switch (n->type) {
case MDOC_ELEM:
synopsis_pre(h, n);
PAIR_CLASS_INIT(&tag, "name");
print_otag(h, TAG_B, 1, &tag);
if (NULL == n->child && meta->name)
print_text(h, meta->name);
return(1);
case MDOC_HEAD:
print_otag(h, TAG_TD, 0, NULL);
if (NULL == n->child && meta->name)
print_text(h, meta->name);
return(1);
case MDOC_BODY:
print_otag(h, TAG_TD, 0, NULL);
return(1);
default:
break;
}
synopsis_pre(h, n);
PAIR_CLASS_INIT(&tag, "synopsis");
print_otag(h, TAG_TABLE, 1, &tag);
for (len = 0, n = n->child; n; n = n->next)
if (MDOC_TEXT == n->type)
len += html_strlen(n->string);
if (0 == len && meta->name)
len = html_strlen(meta->name);
SCALE_HS_INIT(&su, len);
bufinit(h);
bufcat_su(h, "width", &su);
PAIR_STYLE_INIT(&tag, h);
print_otag(h, TAG_COL, 1, &tag);
print_otag(h, TAG_COL, 0, NULL);
print_otag(h, TAG_TBODY, 0, NULL);
print_otag(h, TAG_TR, 0, NULL);
return(1);
}
static void errhandler(struct muth *muth, va_list args)
{
vavar(FILE *, in);
char buf[1024];
char *p;
bufinit(buf);
while(fgets(buf, sizeof(buf), in) != NULL) {
p = buf + strlen(buf) - 1;
while((p >= buf) && (*p == '\n'))
*(p--) = 0;
if(buf[0])
flog(LOG_INFO, "child said: %s", buf);
}
fclose(in);
}
static void
cpu_startup(void *arg)
{
vm_paddr_t physsz;
int i;
tick_tc.tc_get_timecount = tick_get_timecount;
tick_tc.tc_poll_pps = NULL;
tick_tc.tc_counter_mask = ~0u;
tick_tc.tc_frequency = tick_freq;
tick_tc.tc_name = "tick";
tick_tc.tc_quality = UP_TICK_QUALITY;
#ifdef SMP
/*
* We do not know if each CPU's tick counter is synchronized.
*/
if (cpu_mp_probe())
tick_tc.tc_quality = MP_TICK_QUALITY;
#endif
tc_init(&tick_tc);
physsz = 0;
for (i = 0; i < sparc64_nmemreg; i++)
physsz += sparc64_memreg[i].mr_size;
printf("real memory = %lu (%lu MB)\n", physsz,
physsz / (1024 * 1024));
realmem = (long)physsz;
vm_ksubmap_init(&kmi);
bufinit();
vm_pager_bufferinit();
EVENTHANDLER_REGISTER(shutdown_final, sparc64_shutdown_final, NULL,
SHUTDOWN_PRI_LAST);
printf("avail memory = %lu (%lu MB)\n", cnt.v_free_count * PAGE_SIZE,
cnt.v_free_count / ((1024 * 1024) / PAGE_SIZE));
if (bootverbose)
printf("machine: %s\n", sparc64_model);
#ifdef notyet
cpu_identify(rdpr(ver), tick_freq, PCPU_GET(cpuid));
#endif
}
/*
* XXX Finish up the deferred buffer cache allocation and initialization.
*/
void
x86_64_bufinit()
{
int i, base, residual;
base = bufpages / nbuf;
residual = bufpages % nbuf;
for (i = 0; i < nbuf; i++) {
vsize_t curbufsize;
vaddr_t curbuf;
struct vm_page *pg;
/*
* Each buffer has MAXBSIZE bytes of VM space allocated. Of
* that MAXBSIZE space, we allocate and map (base+1) pages
* for the first "residual" buffers, and then we allocate
* "base" pages for the rest.
*/
curbuf = (vaddr_t) buffers + (i * MAXBSIZE);
curbufsize = PAGE_SIZE * ((i < residual) ? (base+1) : base);
while (curbufsize) {
/*
* Attempt to allocate buffers from the first
* 16M of RAM to avoid bouncing file system
* transfers.
*/
pg = uvm_pagealloc_strat(NULL, 0, NULL, 0,
UVM_PGA_STRAT_FALLBACK, VM_FREELIST_FIRST16);
if (pg == NULL)
panic("cpu_startup: not enough memory for "
"buffer cache");
pmap_kenter_pa(curbuf, VM_PAGE_TO_PHYS(pg),
VM_PROT_READ|VM_PROT_WRITE);
curbuf += PAGE_SIZE;
curbufsize -= PAGE_SIZE;
}
}
/*
* Set up buffers, so they can be used to read disk labels.
*/
bufinit();
}
/* ARGSUSED */
static int
mdoc_sx_pre(MDOC_ARGS)
{
struct htmlpair tag[2];
bufinit(h);
bufcat(h, "#x");
for (n = n->child; n; n = n->next) {
bufcat_id(h, n->string);
if (n->next)
bufcat_id(h, " ");
}
PAIR_CLASS_INIT(&tag[0], "link-sec");
PAIR_HREF_INIT(&tag[1], h->buf);
print_otag(h, TAG_I, 1, tag);
print_otag(h, TAG_A, 2, tag);
return(1);
}
static void
cpu_startup(void *dummy)
{
if (boothowto & RB_VERBOSE)
bootverbose++;
printf("real memory = %ju (%juK bytes)\n", ptoa((uintmax_t)realmem),
ptoa((uintmax_t)realmem) / 1024);
/*
* Display any holes after the first chunk of extended memory.
*/
if (bootverbose) {
int indx;
printf("Physical memory chunk(s):\n");
for (indx = 0; phys_avail[indx + 1] != 0; indx += 2) {
vm_paddr_t size1 = phys_avail[indx + 1] - phys_avail[indx];
printf("0x%08jx - 0x%08jx, %ju bytes (%ju pages)\n",
(uintmax_t)phys_avail[indx],
(uintmax_t)phys_avail[indx + 1] - 1,
(uintmax_t)size1,
(uintmax_t)size1 / PAGE_SIZE);
}
}
vm_ksubmap_init(&kmi);
printf("avail memory = %ju (%juMB)\n",
ptoa((uintmax_t)cnt.v_free_count),
ptoa((uintmax_t)cnt.v_free_count) / 1048576);
cpu_init_interrupts();
/*
* Set up buffers, so they can be used to read disk labels.
*/
bufinit();
vm_pager_bufferinit();
}
static int
man_RS_pre(MAN_ARGS)
{
struct htmlpair tag;
struct roffsu su;
if (MAN_HEAD == n->type)
return(0);
else if (MAN_BODY == n->type)
return(1);
SCALE_HS_INIT(&su, INDENT);
if (n->head->child)
a2width(n->head->child, &su);
bufinit(h);
bufcat_su(h, "margin-left", &su);
PAIR_STYLE_INIT(&tag, h);
print_otag(h, TAG_DIV, 1, &tag);
return(1);
}
static void
cpu_booke_startup(void *dummy)
{
int indx;
unsigned long size;
/* Initialise the decrementer-based clock. */
decr_init();
/* Good {morning,afternoon,evening,night}. */
cpu_setup(PCPU_GET(cpuid));
printf("real memory = %lu (%ld MB)\n", ptoa(physmem),
ptoa(physmem) / 1048576);
realmem = physmem;
/* Display any holes after the first chunk of extended memory. */
if (bootverbose) {
printf("Physical memory chunk(s):\n");
for (indx = 0; phys_avail[indx + 1] != 0; indx += 2) {
size = phys_avail[indx + 1] - phys_avail[indx];
printf("0x%08x - 0x%08x, %lu bytes (%lu pages)\n",
phys_avail[indx], phys_avail[indx + 1] - 1,
size, size / PAGE_SIZE);
}
}
vm_ksubmap_init(&kmi);
printf("avail memory = %lu (%ld MB)\n", ptoa(vm_cnt.v_free_count),
ptoa(vm_cnt.v_free_count) / 1048576);
/* Set up buffers, so they can be used to read disk labels. */
bufinit();
vm_pager_bufferinit();
/* Cpu supports execution permissions on the pages. */
elf32_nxstack = 1;
}
int sendreq2(int sock, struct hthead *req, int fd, int flags)
{
int ret, i;
struct charbuf buf;
bufinit(buf);
bufcatstr2(buf, req->method);
bufcatstr2(buf, req->url);
bufcatstr2(buf, req->ver);
bufcatstr2(buf, req->rest);
for(i = 0; i < req->noheaders; i++) {
bufcatstr2(buf, req->headers[i][0]);
bufcatstr2(buf, req->headers[i][1]);
}
bufcatstr2(buf, "");
ret = sendfd2(sock, fd, buf.b, buf.d, flags);
buffree(buf);
if(ret < 0)
return(-1);
else
return(0);
}
/* ARGSUSED */
static int
mdoc_ss_pre(MDOC_ARGS)
{
struct htmlpair tag;
if (MDOC_BLOCK == n->type) {
PAIR_CLASS_INIT(&tag, "subsection");
print_otag(h, TAG_DIV, 1, &tag);
return(1);
} else if (MDOC_BODY == n->type)
return(1);
bufinit(h);
for (n = n->child; n; n = n->next) {
bufcat_id(h, n->string);
if (n->next)
bufcat_id(h, " ");
}
PAIR_ID_INIT(&tag, h->buf);
print_otag(h, TAG_H2, 1, &tag);
return(1);
}
/* ARGSUSED */
static int
mdoc_mt_pre(MDOC_ARGS)
{
struct htmlpair tag[2];
struct tag *t;
PAIR_CLASS_INIT(&tag[0], "link-mail");
for (n = n->child; n; n = n->next) {
assert(MDOC_TEXT == n->type);
bufinit(h);
bufcat(h, "mailto:");
bufcat(h, n->string);
PAIR_HREF_INIT(&tag[1], h->buf);
t = print_otag(h, TAG_A, 2, tag);
print_text(h, n->string);
print_tagq(h, t);
}
return(0);
}
void
buffmt_includes(struct html *h, const char *name)
{
const char *p, *pp;
pp = h->base_includes;
bufinit(h);
while (NULL != (p = strchr(pp, '%'))) {
bufncat(h, pp, (size_t)(p - pp));
switch (*(p + 1)) {
case('I'):
bufcat(h, name);
break;
default:
bufncat(h, p, 2);
break;
}
pp = p + 2;
}
if (pp)
bufcat(h, pp);
}
void
bsd_bufferinit()
{
kern_return_t ret;
cons.t_dev = makedev(12, 0);
bsd_startupearly();
ret = kmem_suballoc(kernel_map,
(vm_offset_t *) &mbutl,
(vm_size_t) (nmbclusters * MCLBYTES),
FALSE,
TRUE,
&mb_map);
if (ret != KERN_SUCCESS)
panic("Failed to allocate mb_map\n");
/*
* Set up buffers, so they can be used to read disk labels.
*/
bufinit();
}
void
cpu_startup()
{
vaddr_t minaddr, maxaddr;
extern char cpu_model[];
/*
* Initialize error message buffer.
*/
initmsgbuf((caddr_t)msgbufp, round_page(MSGBUFSIZE));
/*
* Good {morning,afternoon,evening,night}.
* Also call CPU init on systems that need that.
*/
printf("%s%s [%08X %08X]\n", version, cpu_model, vax_cpudata, vax_siedata);
if (dep_call->cpu_conf)
(*dep_call->cpu_conf)();
printf("real mem = %u (%uMB)\n", ptoa(physmem),
ptoa(physmem)/1024/1024);
mtpr(AST_NO, PR_ASTLVL);
spl0();
/*
* Allocate a submap for exec arguments. This map effectively limits
* the number of processes exec'ing at any time.
*/
minaddr = vm_map_min(kernel_map);
exec_map = uvm_km_suballoc(kernel_map, &minaddr, &maxaddr,
16 * NCARGS, VM_MAP_PAGEABLE, FALSE, NULL);
#if VAX46 || VAX48 || VAX49 || VAX53 || VAX60
/*
* Allocate a submap for physio. This map effectively limits the
* number of processes doing physio at any one time.
*
* Note that machines on which all mass storage I/O controllers
* can perform address translation, do not need this.
*/
if (vax_boardtype == VAX_BTYP_46 || vax_boardtype == VAX_BTYP_48 ||
vax_boardtype == VAX_BTYP_49 || vax_boardtype == VAX_BTYP_1303 ||
vax_boardtype == VAX_BTYP_60)
phys_map = uvm_km_suballoc(kernel_map, &minaddr, &maxaddr,
VM_PHYS_SIZE, 0, FALSE, NULL);
#endif
printf("avail mem = %lu (%luMB)\n", ptoa(uvmexp.free),
ptoa(uvmexp.free)/1024/1024);
/*
* Set up buffers, so they can be used to read disk labels.
*/
bufinit();
#ifdef DDB
if (boothowto & RB_KDB)
Debugger();
#endif
/*
* Configure the system.
*/
if (boothowto & RB_CONFIG) {
#ifdef BOOT_CONFIG
user_config();
#else
printf("kernel does not support -c; continuing..\n");
#endif
}
}
/* ARGSUSED */
static int
mdoc_fn_pre(MDOC_ARGS)
{
struct tag *t;
struct htmlpair tag[2];
char nbuf[BUFSIZ];
const char *sp, *ep;
int sz, i, pretty;
pretty = MDOC_SYNPRETTY & n->flags;
synopsis_pre(h, n);
/* Split apart into type and name. */
assert(n->child->string);
sp = n->child->string;
ep = strchr(sp, ' ');
if (NULL != ep) {
PAIR_CLASS_INIT(&tag[0], "ftype");
t = print_otag(h, TAG_I, 1, tag);
while (ep) {
sz = MIN((int)(ep - sp), BUFSIZ - 1);
(void)memcpy(nbuf, sp, (size_t)sz);
nbuf[sz] = '\0';
print_text(h, nbuf);
sp = ++ep;
ep = strchr(sp, ' ');
}
print_tagq(h, t);
}
PAIR_CLASS_INIT(&tag[0], "fname");
/*
* FIXME: only refer to IDs that we know exist.
*/
#if 0
if (MDOC_SYNPRETTY & n->flags) {
nbuf[0] = '\0';
html_idcat(nbuf, sp, BUFSIZ);
PAIR_ID_INIT(&tag[1], nbuf);
} else {
strlcpy(nbuf, "#", BUFSIZ);
html_idcat(nbuf, sp, BUFSIZ);
PAIR_HREF_INIT(&tag[1], nbuf);
}
#endif
t = print_otag(h, TAG_B, 1, tag);
if (sp) {
strlcpy(nbuf, sp, BUFSIZ);
print_text(h, nbuf);
}
print_tagq(h, t);
h->flags |= HTML_NOSPACE;
print_text(h, "(");
bufinit(h);
PAIR_CLASS_INIT(&tag[0], "farg");
bufcat_style(h, "white-space", "nowrap");
PAIR_STYLE_INIT(&tag[1], h);
for (n = n->child->next; n; n = n->next) {
i = 1;
if (MDOC_SYNPRETTY & n->flags)
i = 2;
t = print_otag(h, TAG_I, i, tag);
print_text(h, n->string);
print_tagq(h, t);
if (n->next) {
h->flags |= HTML_NOSPACE;
print_text(h, ",");
}
}
h->flags |= HTML_NOSPACE;
print_text(h, ")");
if (pretty) {
h->flags |= HTML_NOSPACE;
print_text(h, ";");
}
return(0);
}
void
cpu_startup()
{
struct pdc_model pdc_model;
register const struct hppa_board_info *bip;
vm_offset_t minaddr, maxaddr;
vm_size_t size;
int base, residual;
int err, i;
#ifdef DEBUG
extern int pmapdebug;
int opmapdebug = pmapdebug;
pmapdebug = 0;
#endif
/* good night */
printf(version);
/* identify system type */
if ((err = pdc_call((iodcio_t)pdc, 0, PDC_MODEL, PDC_MODEL_INFO,
&pdc_model)) < 0) {
#ifdef DEBUG
printf("WARNING: PDC_MODEL failed (%d)\n", err);
#endif
} else {
i = pdc_model.hvers >> 4; /* board type */
for (bip = hppa_knownboards;
bip->bi_id >= 0 && bip->bi_id != i; bip++);
if (bip->bi_id >= 0) {
char *p;
switch(pdc_model.arch_rev) {
case 0: p = "1.0"; break;
case 4: p = "1.1"; break;
case 8: p = "2.0"; break;
default: p = "?.?"; break;
}
/* my babe said: 6010, 481, 0, 0, 77b657b1, 0, 4 */
sprintf(cpu_model, "HP9000/%s PA-RISC %s",
bip->bi_name, p);
} else
sprintf(cpu_model, "HP9000/(UNKNOWN %x)", i);
printf("%s\n", cpu_model);
}
printf("real mem = %d (%d reserved for PROM, %d used by OpenBSD)\n",
ctob(totalphysmem), ctob(resvmem), ctob(physmem));
/*
* Now allocate buffers proper. They are different than the above
* in that they usually occupy more virtual memory than physical.
*/
size = MAXBSIZE * nbuf;
buffer_map = kmem_suballoc(kernel_map, (vm_offset_t *)&buffers,
&maxaddr, size, TRUE);
minaddr = (vm_offset_t)buffers;
if (vm_map_find(buffer_map, vm_object_allocate(size), (vm_offset_t)0,
&minaddr, size, FALSE) != KERN_SUCCESS)
panic("cpu_startup: cannot allocate buffers");
base = bufpages / nbuf;
residual = bufpages % nbuf;
for (i = 0; i < nbuf; i++) {
/*
* First <residual> buffers get (base+1) physical pages
* allocated for them. The rest get (base) physical pages.
*
* The rest of each buffer occupies virtual space,
* but has no physical memory allocated for it.
*/
vm_map_pageable(buffer_map, minaddr, minaddr +
CLBYTES * (base + (i < residual)), FALSE);
vm_map_simplify(buffer_map, minaddr);
minaddr += MAXBSIZE;
}
/*
* Allocate a submap for exec arguments. This map effectively
* limits the number of processes exec'ing at any time.
*/
exec_map = kmem_suballoc(kernel_map, &minaddr, &maxaddr,
16*NCARGS, TRUE);
/*
* Allocate a submap for physio
*/
phys_map = kmem_suballoc(kernel_map, &minaddr, &maxaddr,
VM_PHYS_SIZE, TRUE);
/*
* Finally, allocate mbuf pool. Since mclrefcnt is an off-size
* we use the more space efficient malloc in place of kmem_alloc.
*/
mclrefcnt = (char *)malloc(NMBCLUSTERS+CLBYTES/MCLBYTES,
M_MBUF, M_NOWAIT);
bzero(mclrefcnt, NMBCLUSTERS+CLBYTES/MCLBYTES);
mb_map = kmem_suballoc(kernel_map, (vm_offset_t *)&mbutl, &maxaddr,
VM_MBUF_SIZE, FALSE);
/*
* Initialize callouts
*/
callfree = callout;
for (i = 1; i < ncallout; i++)
callout[i-1].c_next = &callout[i];
callout[i-1].c_next = NULL;
#ifdef DEBUG
pmapdebug = opmapdebug;
#endif
printf("avail mem = %ld\n", ptoa(cnt.v_free_count));
printf("using %d buffers containing %d bytes of memory\n",
nbuf, bufpages * CLBYTES);
/*
* Set up buffers, so they can be used to read disk labels.
*/
bufinit();
/*
* Configure the system.
*/
if (boothowto & RB_CONFIG) {
#ifdef BOOT_CONFIG
user_config();
#else
printf("kernel does not support -c; continuing..\n");
#endif
}
hppa_malloc_ok = 1;
configure();
}
/*
* Machine-dependent startup code
*/
void
cpu_startup()
{
#ifdef DEBUG
extern int pmapdebug;
int opmapdebug = pmapdebug;
#endif
vaddr_t minaddr, maxaddr;
paddr_t msgbufpa;
extern struct user *proc0paddr;
#ifdef DEBUG
pmapdebug = 0;
#endif
if (CPU_ISSUN4M)
stackgap_random = STACKGAP_RANDOM_SUN4M;
/*
* Re-map the message buffer from its temporary address
* at KERNBASE to MSGBUF_VA.
*/
/* Get physical address of the message buffer */
pmap_extract(pmap_kernel(), (vaddr_t)KERNBASE, &msgbufpa);
/* Invalidate the current mapping at KERNBASE. */
pmap_kremove((vaddr_t)KERNBASE, PAGE_SIZE);
pmap_update(pmap_kernel());
/* Enter the new mapping */
pmap_map(MSGBUF_VA, msgbufpa, msgbufpa + PAGE_SIZE,
PROT_READ | PROT_WRITE);
/* Re-initialize the message buffer. */
initmsgbuf((caddr_t)(MSGBUF_VA + (CPU_ISSUN4 ? 4096 : 0)), MSGBUFSIZE);
proc0.p_addr = proc0paddr;
/*
* Good {morning,afternoon,evening,night}.
*/
printf(version);
/*identifycpu();*/
printf("real mem = %lu (%luMB)\n", ptoa(physmem),
ptoa(physmem)/1024/1024);
/*
* uvm_km_init() has allocated all the virtual memory below the
* end of the kernel image. If VM_MIN_KERNEL_ADDRESS is below
* KERNBASE, we need to reclaim that range.
*/
if (vm_min_kernel_address < (vaddr_t)KERNBASE) {
uvm_unmap(kernel_map, vm_min_kernel_address, (vaddr_t)KERNBASE);
}
/*
* Allocate a submap for exec arguments. This map effectively
* limits the number of processes exec'ing at any time.
*/
minaddr = vm_map_min(kernel_map);
exec_map = uvm_km_suballoc(kernel_map, &minaddr, &maxaddr,
16*NCARGS, VM_MAP_PAGEABLE, FALSE, NULL);
/*
* Set up userland PIE limits. PIE is disabled on sun4/4c/4e due
* to the limited address space.
*/
if (CPU_ISSUN4M) {
vm_pie_max_addr = VM_MAXUSER_ADDRESS / 4;
}
dvma_init();
#ifdef DEBUG
pmapdebug = opmapdebug;
#endif
printf("avail mem = %lu (%luMB)\n", ptoa(uvmexp.free),
ptoa(uvmexp.free)/1024/1024);
/*
* Set up buffers, so they can be used to read disk labels.
*/
bufinit();
}
/*------------------------------------------------------------------------
*
* sysinit - Initialize all Xinu data structures and devices
*
*------------------------------------------------------------------------
*/
static void sysinit()
{
int32 i;
struct procent *prptr; /* Ptr to process table entry */
struct sentry *semptr; /* Ptr to semaphore table entry */
/* Platform Specific Initialization */
platinit();
/* kprintf("\033[39;49m\n\r%s\n\n\r", VERSION);*/
/* Initialize the interrupt vectors */
initevec();
/* Initialize free memory list */
meminit();
/* Initialize system variables */
/* Count the Null process as the first process in the system */
prcount = 1;
/* Scheduling is not currently blocked */
Defer.ndefers = 0;
/* Initialize process table entries free */
for (i = 0; i < NPROC; i++) {
prptr = &proctab[i];
prptr->prstate = PR_FREE;
prptr->prname[0] = NULLCH;
prptr->prstkbase = NULL;
prptr->prprio = 0;
}
/* Initialize the Null process entry */
prptr = &proctab[NULLPROC];
prptr->prstate = PR_CURR;
prptr->prprio = 0;
strncpy(prptr->prname, "prnull", 7);
prptr->prstkbase = getstk(NULLSTK);
prptr->prstklen = NULLSTK;
prptr->prstkptr = 0;
currpid = NULLPROC;
/* Initialize semaphores */
for (i = 0; i < NSEM; i++) {
semptr = &semtab[i];
semptr->sstate = S_FREE;
semptr->scount = 0;
semptr->squeue = newqueue();
}
/* Initialize buffer pools */
bufinit();
/* Create a ready list for processes */
readylist = newqueue();
/* Initialize the real time clock */
clkinit();
for (i = 0; i < NDEVS; i++) {
init(i);
}
return;
}
/*
* Machine-dependent startup code
*/
void
cpu_startup()
{
unsigned i;
caddr_t v;
long sz;
int base, residual;
#ifdef DEBUG
extern int pmapdebug;
int opmapdebug = pmapdebug;
#endif
vaddr_t minaddr, maxaddr;
vsize_t size;
extern struct user *proc0paddr;
#ifdef DEBUG
pmapdebug = 0;
#endif
proc0.p_addr = proc0paddr;
/*
* Good {morning,afternoon,evening,night}.
*/
printf(version);
/*identifycpu();*/
printf("total memory = %d\n", physmem * PAGE_SIZE);
/*
* Find out how much space we need, allocate it,
* and then give everything true virtual addresses.
*/
sz = (long)allocsys(NULL);
if ((v = (caddr_t)uvm_km_alloc(kernel_map, round_page(sz))) == 0)
panic("startup: no room for %lx bytes of tables", sz);
if (allocsys(v) - v != sz)
panic("startup: table size inconsistency");
/*
* allocate virtual and physical memory for the buffers.
*/
size = MAXBSIZE * nbuf; /* # bytes for buffers */
/* allocate VM for buffers... area is not managed by VM system */
if (uvm_map(kernel_map, (vaddr_t *) &buffers, round_page(size),
NULL, UVM_UNKNOWN_OFFSET,
UVM_MAPFLAG(UVM_PROT_NONE, UVM_PROT_NONE, UVM_INH_NONE,
UVM_ADV_NORMAL, 0)) != 0)
panic("cpu_startup: cannot allocate VM for buffers");
minaddr = (vaddr_t) buffers;
if ((bufpages / nbuf) >= btoc(MAXBSIZE)) {
bufpages = btoc(MAXBSIZE) * nbuf; /* do not overallocate RAM */
}
base = bufpages / nbuf;
residual = bufpages % nbuf;
/* now allocate RAM for buffers */
for (i = 0 ; i < nbuf ; i++) {
vaddr_t curbuf;
vsize_t curbufsize;
struct vm_page *pg;
/*
* each buffer has MAXBSIZE bytes of VM space allocated. of
* that MAXBSIZE space we allocate and map (base+1) pages
* for the first "residual" buffers, and then we allocate
* "base" pages for the rest.
*/
curbuf = (vaddr_t) buffers + (i * MAXBSIZE);
curbufsize = NBPG * ((i < residual) ? (base+1) : base);
while (curbufsize) {
pg = uvm_pagealloc(NULL, 0, NULL, 0);
if (pg == NULL)
panic("cpu_startup: "
"not enough RAM for buffer cache");
pmap_enter(kernel_map->pmap, curbuf,
VM_PAGE_TO_PHYS(pg), VM_PROT_READ|VM_PROT_WRITE,
VM_PROT_READ|VM_PROT_WRITE|PMAP_WIRED);
curbuf += PAGE_SIZE;
curbufsize -= PAGE_SIZE;
}
}
pmap_update();
/*
* Allocate a submap for exec arguments. This map effectively
* limits the number of processes exec'ing at any time.
*/
exec_map = uvm_km_suballoc(kernel_map, &minaddr, &maxaddr,
16*NCARGS, VM_MAP_PAGEABLE, FALSE, NULL);
/*
* Finally, allocate mbuf cluster submap.
*/
mb_map = uvm_km_suballoc(kernel_map, &minaddr, &maxaddr,
VM_MBUF_SIZE, VM_MAP_INTRSAFE, FALSE, NULL);
#ifdef DEBUG
pmapdebug = opmapdebug;
#endif
printf("avail memory = %ld\n", (long)uvmexp.free * PAGE_SIZE);
printf("using %d buffers containing %ld of memory\n", nbuf,
(long)bufpages * PAGE_SIZE);
/*
* Set up buffers, so they can be used to read disk labels.
*/
bufinit();
#if 0
pmap_redzone();
#endif
}
int
setup(const char *dev)
{
long bmapsize;
struct stat statb;
int doskipclean;
u_int64_t maxfilesize;
int open_flags;
struct uvnode *ivp;
struct ubuf *bp;
int i, isdirty;
long sn, curseg;
SEGUSE *sup;
havesb = 0;
doskipclean = skipclean;
if (stat(dev, &statb) < 0) {
pfatal("Can't stat %s: %s\n", dev, strerror(errno));
return (0);
}
if (!S_ISCHR(statb.st_mode) && skipclean) {
pfatal("%s is not a character device", dev);
if (reply("CONTINUE") == 0)
return (0);
}
if (nflag)
open_flags = O_RDONLY;
else
open_flags = O_RDWR;
if ((fsreadfd = open(dev, open_flags)) < 0) {
pfatal("Can't open %s: %s\n", dev, strerror(errno));
return (0);
}
if (nflag) {
if (preen)
pfatal("NO WRITE ACCESS");
printf("** %s (NO WRITE)\n", dev);
quiet = 0;
} else if (!preen && !quiet)
printf("** %s\n", dev);
fsmodified = 0;
lfdir = 0;
/* Initialize time in case we have to write */
time(&write_time);
bufinit(0); /* XXX we could make a better guess */
fs = lfs_init(fsreadfd, bflag, idaddr, 0, debug);
if (fs == NULL) {
if (preen)
printf("%s: ", cdevname());
errexit("BAD SUPER BLOCK OR IFILE INODE NOT FOUND");
}
/* Resize buffer cache now that we have a superblock to guess from. */
bufrehash((fs->lfs_segtabsz + maxino / fs->lfs_ifpb) << 4);
if (fs->lfs_pflags & LFS_PF_CLEAN) {
if (doskipclean) {
if (!quiet)
pwarn("%sile system is clean; not checking\n",
preen ? "f" : "** F");
return (-1);
}
if (!preen)
pwarn("** File system is already clean\n");
}
if (idaddr) {
daddr_t tdaddr;
SEGSUM *sp;
FINFO *fp;
int bc;
if (debug)
pwarn("adjusting offset, serial for -i 0x%lx\n",
(unsigned long)idaddr);
tdaddr = lfs_sntod(fs, lfs_dtosn(fs, idaddr));
if (lfs_sntod(fs, lfs_dtosn(fs, tdaddr)) == tdaddr) {
if (tdaddr == fs->lfs_start)
tdaddr += lfs_btofsb(fs, LFS_LABELPAD);
for (i = 0; i < LFS_MAXNUMSB; i++) {
if (fs->lfs_sboffs[i] == tdaddr)
tdaddr += lfs_btofsb(fs, LFS_SBPAD);
if (fs->lfs_sboffs[i] > tdaddr)
break;
}
}
fs->lfs_offset = tdaddr;
if (debug)
pwarn("begin with offset/serial 0x%x/%d\n",
(int)fs->lfs_offset, (int)fs->lfs_serial);
while (tdaddr < idaddr) {
bread(fs->lfs_devvp, LFS_FSBTODB(fs, tdaddr),
fs->lfs_sumsize,
NULL, 0, &bp);
sp = (SEGSUM *)bp->b_data;
if (sp->ss_sumsum != cksum(&sp->ss_datasum,
fs->lfs_sumsize -
sizeof(sp->ss_sumsum))) {
brelse(bp, 0);
if (debug)
printf("bad cksum at %x\n",
(unsigned)tdaddr);
break;
}
fp = (FINFO *)(sp + 1);
bc = howmany(sp->ss_ninos, LFS_INOPB(fs)) <<
(fs->lfs_version > 1 ? fs->lfs_ffshift :
fs->lfs_bshift);
for (i = 0; i < sp->ss_nfinfo; i++) {
bc += fp->fi_lastlength + ((fp->fi_nblocks - 1)
<< fs->lfs_bshift);
fp = (FINFO *)(fp->fi_blocks + fp->fi_nblocks);
}
tdaddr += lfs_btofsb(fs, bc) + 1;
fs->lfs_offset = tdaddr;
fs->lfs_serial = sp->ss_serial + 1;
brelse(bp, 0);
}
/*
* Set curseg, nextseg appropriately -- inlined from
* lfs_newseg()
*/
curseg = lfs_dtosn(fs, fs->lfs_offset);
fs->lfs_curseg = lfs_sntod(fs, curseg);
for (sn = curseg + fs->lfs_interleave;;) {
sn = (sn + 1) % fs->lfs_nseg;
if (sn == curseg)
errx(1, "init: no clean segments");
LFS_SEGENTRY(sup, fs, sn, bp);
isdirty = sup->su_flags & SEGUSE_DIRTY;
brelse(bp, 0);
if (!isdirty)
break;
}
/* Skip superblock if necessary */
for (i = 0; i < LFS_MAXNUMSB; i++)
if (fs->lfs_offset == fs->lfs_sboffs[i])
fs->lfs_offset += lfs_btofsb(fs, LFS_SBPAD);
++fs->lfs_nactive;
fs->lfs_nextseg = lfs_sntod(fs, sn);
if (debug) {
pwarn("offset = 0x%" PRIx32 ", serial = %" PRId64 "\n",
fs->lfs_offset, fs->lfs_serial);
pwarn("curseg = %" PRIx32 ", nextseg = %" PRIx32 "\n",
fs->lfs_curseg, fs->lfs_nextseg);
}
if (!nflag && !skipclean) {
fs->lfs_idaddr = idaddr;
fsmodified = 1;
sbdirty();
}
}
if (debug) {
pwarn("idaddr = 0x%lx\n", idaddr ? (unsigned long)idaddr :
(unsigned long)fs->lfs_idaddr);
pwarn("dev_bsize = %lu\n", dev_bsize);
pwarn("lfs_bsize = %lu\n", (unsigned long) fs->lfs_bsize);
pwarn("lfs_fsize = %lu\n", (unsigned long) fs->lfs_fsize);
pwarn("lfs_frag = %lu\n", (unsigned long) fs->lfs_frag);
pwarn("lfs_inopb = %lu\n", (unsigned long) fs->lfs_inopb);
}
if (fs->lfs_version == 1)
maxfsblock = fs->lfs_size * (fs->lfs_bsize / dev_bsize);
else
maxfsblock = fs->lfs_size;
maxfilesize = calcmaxfilesize(fs->lfs_bshift);
if (/* fs->lfs_minfree < 0 || */ fs->lfs_minfree > 99) {
pfatal("IMPOSSIBLE MINFREE=%d IN SUPERBLOCK",
fs->lfs_minfree);
if (reply("SET TO DEFAULT") == 1) {
fs->lfs_minfree = 10;
sbdirty();
}
}
if (fs->lfs_bmask != fs->lfs_bsize - 1) {
pwarn("INCORRECT BMASK=0x%x IN SUPERBLOCK (SHOULD BE 0x%x)",
(unsigned int) fs->lfs_bmask,
(unsigned int) fs->lfs_bsize - 1);
fs->lfs_bmask = fs->lfs_bsize - 1;
if (preen)
printf(" (FIXED)\n");
if (preen || reply("FIX") == 1) {
sbdirty();
}
}
if (fs->lfs_ffmask != fs->lfs_fsize - 1) {
pwarn("INCORRECT FFMASK=%" PRId64 " IN SUPERBLOCK",
fs->lfs_ffmask);
fs->lfs_ffmask = fs->lfs_fsize - 1;
if (preen)
printf(" (FIXED)\n");
if (preen || reply("FIX") == 1) {
sbdirty();
}
}
if (fs->lfs_fbmask != (1 << fs->lfs_fbshift) - 1) {
pwarn("INCORRECT FBMASK=%" PRId64 " IN SUPERBLOCK",
fs->lfs_fbmask);
fs->lfs_fbmask = (1 << fs->lfs_fbshift) - 1;
if (preen)
printf(" (FIXED)\n");
if (preen || reply("FIX") == 1) {
sbdirty();
}
}
if (fs->lfs_maxfilesize != maxfilesize) {
pwarn(
"INCORRECT MAXFILESIZE=%llu IN SUPERBLOCK (SHOULD BE %llu WITH BSHIFT %d)",
(unsigned long long) fs->lfs_maxfilesize,
(unsigned long long) maxfilesize, (int)fs->lfs_bshift);
if (preen)
printf(" (FIXED)\n");
if (preen || reply("FIX") == 1) {
fs->lfs_maxfilesize = maxfilesize;
sbdirty();
}
}
if (fs->lfs_maxsymlinklen != ULFS1_MAXSYMLINKLEN) {
pwarn("INCORRECT MAXSYMLINKLEN=%d IN SUPERBLOCK",
fs->lfs_maxsymlinklen);
fs->lfs_maxsymlinklen = ULFS1_MAXSYMLINKLEN;
if (preen)
printf(" (FIXED)\n");
if (preen || reply("FIX") == 1) {
sbdirty();
}
}
/*
* Read in the Ifile; we'll be using it a lot.
* XXX If the Ifile is corrupted we are in bad shape. We need to
* XXX run through the segment headers of the entire disk to
* XXX reconstruct the inode table, then pretend all segments are
* XXX dirty while we do the rest.
*/
ivp = fs->lfs_ivnode;
maxino = ((VTOI(ivp)->i_ffs1_size - (fs->lfs_cleansz + fs->lfs_segtabsz)
* fs->lfs_bsize) / fs->lfs_bsize) * fs->lfs_ifpb;
if (debug)
pwarn("maxino = %llu\n", (unsigned long long)maxino);
for (i = 0; i < VTOI(ivp)->i_ffs1_size; i += fs->lfs_bsize) {
bread(ivp, i >> fs->lfs_bshift, fs->lfs_bsize, NOCRED, 0, &bp);
/* XXX check B_ERROR */
brelse(bp, 0);
}
/*
* allocate and initialize the necessary maps
*/
din_table = ecalloc(maxino, sizeof(*din_table));
seg_table = ecalloc(fs->lfs_nseg, sizeof(SEGUSE));
/* Get segment flags */
for (i = 0; i < fs->lfs_nseg; i++) {
LFS_SEGENTRY(sup, fs, i, bp);
seg_table[i].su_flags = sup->su_flags & ~SEGUSE_ACTIVE;
if (preen)
seg_table[i].su_nbytes = sup->su_nbytes;
brelse(bp, 0);
}
/* Initialize Ifile entry */
din_table[fs->lfs_ifile] = fs->lfs_idaddr;
seg_table[lfs_dtosn(fs, fs->lfs_idaddr)].su_nbytes += LFS_DINODE1_SIZE;
#ifndef VERBOSE_BLOCKMAP
bmapsize = roundup(howmany(maxfsblock, NBBY), sizeof(int16_t));
blockmap = ecalloc(bmapsize, sizeof(char));
#else
bmapsize = maxfsblock * sizeof(ino_t);
blockmap = ecalloc(maxfsblock, sizeof(ino_t));
#endif
statemap = ecalloc(maxino, sizeof(char));
typemap = ecalloc(maxino, sizeof(char));
lncntp = ecalloc(maxino, sizeof(int16_t));
if (preen) {
n_files = fs->lfs_nfiles;
n_blks = fs->lfs_dsize - fs->lfs_bfree;
numdirs = maxino;
inplast = 0;
listmax = numdirs + 10;
inpsort = ecalloc(listmax, sizeof(struct inoinfo *));
inphead = ecalloc(numdirs, sizeof(struct inoinfo *));
}
return (1);
ckfini(0);
return (0);
}
void
kinitlong(unsigned long pmemsz)
{
#if (NEWTMR)
uint32_t tmrcnt = 0;
#endif
/* initialise interrupt management */
#if (VBE)
trapinitprot();
#endif
/* initialise virtual memory */
vminitlong((uint64_t *)kernpagemapl4tab);
#if 0
/* FIXME: map possible device memory */
vmmapseg((uint32_t *)&_pagetab, DEVMEMBASE, DEVMEMBASE, 0xffffffffU,
PAGEPRES | PAGEWRITE | PAGENOCACHE);
#endif
// schedinit();
/* zero kernel BSS segment */
kbzero(&_bssvirt, (uint32_t)&_ebssvirt - (uint32_t)&_bssvirt);
/* set kernel I/O permission bitmap to all 1-bits */
kmemset(&kerniomap, 0xff, sizeof(kerniomap));
/* INITIALIZE CONSOLES AND SCREEN */
#if (VBE)
vbeinitscr();
#endif
#if (VBE) && (NEWFONT)
consinit(768 / vbefontw, 1024 / vbefonth);
#elif (VBE)
consinit(768 >> 3, 1024 >> 3);
#endif
/* TODO: use memory map from GRUB? */
// vminitphys((uintptr_t)&_epagetab, pmemsz);
vminitphys((uintptr_t)&_epagetab, pmemsz);
meminit(pmemsz);
tssinit(0);
#if (VBE) && (NEWFONT)
// consinit(768 / vbefontw, 1024 / vbefonth);
#elif (VBE)
consinit(768 >> 3, 1024 >> 3);
#endif
#if (SMBIOS)
smbiosinit();
#endif
#if (PS2DRV)
ps2init();
#endif
#if (VBE) && (PLASMA)
plasmaloop();
#endif
#if (VBE)
vbeprintinfo();
#endif
logoprint();
// vminitphys((uintptr_t)&_ebss, pmemsz - (unsigned long)&_ebss);
/* HID devices */
#if (PCI)
/* initialise PCI bus driver */
pciinit();
#endif
#if (ATA)
/* initialise ATA driver */
atainit();
#endif
#if (SB16)
/* initialise Soundblaster 16 driver */
sb16init();
#endif
#if (ACPI)
/* initialise ACPI subsystem */
acpiinit();
#endif
/* initialise block I/O buffer cache */
if (!bufinit()) {
kprintf("failed to allocate buffer cache\n");
while (1) {
;
}
}
/* allocate unused device regions (in 3.5G..4G) */
// pageaddzone(DEVMEMBASE, &vmshmq, 0xffffffffU - DEVMEMBASE + 1);
#if (SMP) || (APIC)
//#if (SMP)
/* multiprocessor initialisation */
// mpinit();
//#endif
if (mpncpu == 1) {
kprintf("found %ld processor\n", mpncpu);
} else {
kprintf("found %ld processors\n", mpncpu);
}
#if (HPET)
/* initialise high precision event timers */
hpetinit();
#endif
#if (NEWTMR)
tmrcnt = apicinitcpu(0);
#else
apicinitcpu(0);
#endif
#if (IOAPIC)
ioapicinit(0);
#endif
#endif /* SMP || APIC */
#if (SMP)
if (mpmultiproc) {
mpstart();
}
#endif
/* CPU interface */
taskinit();
// tssinit(0);
// machinit();
/* execution environment */
procinit(PROCKERN);
// k_curtask = &k_curproc->task;
// sysinit();
kprintf("DMA buffers (%ul x %ul kilobytes) @ 0x%p\n",
DMANCHAN, DMACHANBUFSIZE >> 10, DMABUFBASE);
kprintf("VM page tables @ 0x%p\n", (unsigned long)&_pagetab);
// kprintf("%ld kilobytes physical memory\n", pmemsz >> 10);
kprintf("%ld kilobytes kernel memory\n", (uint32_t)&_ebss >> 10);
kprintf("%ld kilobytes allocated physical memory (%ld wired, %ld total)\n",
(vmpagestat.nwired + vmpagestat.nmapped + vmpagestat.nbuf) << (PAGESIZELOG2 - 10),
vmpagestat.nwired << (PAGESIZELOG2 - 10),
vmpagestat.nphys << (PAGESIZELOG2 - 10));
k_curcpu = &cputab[0];
cpuinit(k_curcpu);
schedinit();
#if (APIC)
apicstarttmr(tmrcnt);
#else
pitinit();
#endif
schedloop();
/* NOTREACHED */
}
static void
print_mdoc_node(MDOC_ARGS)
{
int child;
struct tag *t;
struct htmlpair tag;
child = 1;
t = h->tags.head;
bufinit(h);
switch (n->type) {
case (MDOC_ROOT):
child = mdoc_root_pre(m, n, h);
break;
case (MDOC_TEXT):
/* No tables in this mode... */
assert(NULL == h->tblt);
/*
* Make sure that if we're in a literal mode already
* (i.e., within a <PRE>) don't print the newline.
*/
if (' ' == *n->string && MDOC_LINE & n->flags)
if ( ! (HTML_LITERAL & h->flags))
print_otag(h, TAG_BR, 0, NULL);
if (MDOC_DELIMC & n->flags)
h->flags |= HTML_NOSPACE;
print_text(h, n->string);
if (MDOC_DELIMO & n->flags)
h->flags |= HTML_NOSPACE;
return;
case (MDOC_EQN):
PAIR_CLASS_INIT(&tag, "eqn");
print_otag(h, TAG_SPAN, 1, &tag);
print_text(h, n->eqn->data);
break;
case (MDOC_TBL):
/*
* This will take care of initialising all of the table
* state data for the first table, then tearing it down
* for the last one.
*/
print_tbl(h, n->span);
return;
default:
/*
* Close out the current table, if it's open, and unset
* the "meta" table state. This will be reopened on the
* next table element.
*/
if (h->tblt) {
print_tblclose(h);
t = h->tags.head;
}
assert(NULL == h->tblt);
if (mdocs[n->tok].pre && ENDBODY_NOT == n->end)
child = (*mdocs[n->tok].pre)(m, n, h);
break;
}
if (HTML_KEEP & h->flags) {
if (n->prev && n->prev->line != n->line) {
h->flags &= ~HTML_KEEP;
h->flags |= HTML_PREKEEP;
} else if (NULL == n->prev) {
if (n->parent && n->parent->line != n->line) {
h->flags &= ~HTML_KEEP;
h->flags |= HTML_PREKEEP;
}
}
}
if (child && n->child)
print_mdoc_nodelist(m, n->child, h);
print_stagq(h, t);
bufinit(h);
switch (n->type) {
case (MDOC_ROOT):
mdoc_root_post(m, n, h);
break;
case (MDOC_EQN):
break;
default:
if (mdocs[n->tok].post && ENDBODY_NOT == n->end)
(*mdocs[n->tok].post)(m, n, h);
break;
}
}
static struct hthead *parsereq(struct bufio *in)
{
struct hthead *req;
struct charbuf method, url, ver;
int c;
req = NULL;
bufinit(method);
bufinit(url);
bufinit(ver);
while(1) {
c = biogetc(in);
if(c == ' ') {
break;
} else if((c == EOF) || (c < 32) || (c >= 128)) {
goto fail;
} else {
bufadd(method, c);
if(method.d >= 128)
goto fail;
}
}
while(1) {
c = biogetc(in);
if(c == ' ') {
break;
} else if((c == EOF) || (c < 32)) {
goto fail;
} else {
bufadd(url, c);
if(url.d >= 65536)
goto fail;
}
}
while(1) {
c = biogetc(in);
if(c == 10) {
break;
} else if(c == 13) {
} else if((c == EOF) || (c < 32) || (c >= 128)) {
goto fail;
} else {
bufadd(ver, c);
if(ver.d >= 128)
goto fail;
}
}
bufadd(method, 0);
bufadd(url, 0);
bufadd(ver, 0);
req = mkreq(method.b, url.b, ver.b);
if(parseheadersb(req, in))
goto fail;
trimx(req);
goto out;
fail:
if(req != NULL) {
freehthead(req);
req = NULL;
}
out:
buffree(method);
buffree(url);
buffree(ver);
return(req);
}
/* ARGSUSED */
static int
mdoc_bl_pre(MDOC_ARGS)
{
int i;
struct htmlpair tag[3];
struct roffsu su;
char buf[BUFSIZ];
if (MDOC_BODY == n->type) {
if (LIST_column == n->norm->Bl.type)
print_otag(h, TAG_TBODY, 0, NULL);
return(1);
}
if (MDOC_HEAD == n->type) {
if (LIST_column != n->norm->Bl.type)
return(0);
/*
* For each column, print out the <COL> tag with our
* suggested width. The last column gets min-width, as
* in terminal mode it auto-sizes to the width of the
* screen and we want to preserve that behaviour.
*/
for (i = 0; i < (int)n->norm->Bl.ncols; i++) {
a2width(n->norm->Bl.cols[i], &su);
bufinit(h);
if (i < (int)n->norm->Bl.ncols - 1)
bufcat_su(h, "width", &su);
else
bufcat_su(h, "min-width", &su);
PAIR_STYLE_INIT(&tag[0], h);
print_otag(h, TAG_COL, 1, tag);
}
return(0);
}
SCALE_VS_INIT(&su, 0);
bufcat_su(h, "margin-top", &su);
bufcat_su(h, "margin-bottom", &su);
PAIR_STYLE_INIT(&tag[0], h);
assert(lists[n->norm->Bl.type]);
strlcpy(buf, "list ", BUFSIZ);
strlcat(buf, lists[n->norm->Bl.type], BUFSIZ);
PAIR_INIT(&tag[1], ATTR_CLASS, buf);
/* Set the block's left-hand margin. */
if (n->norm->Bl.offs) {
a2offs(n->norm->Bl.offs, &su);
bufcat_su(h, "margin-left", &su);
}
switch (n->norm->Bl.type) {
case(LIST_bullet):
/* FALLTHROUGH */
case(LIST_dash):
/* FALLTHROUGH */
case(LIST_hyphen):
/* FALLTHROUGH */
case(LIST_item):
print_otag(h, TAG_UL, 2, tag);
break;
case(LIST_enum):
print_otag(h, TAG_OL, 2, tag);
break;
case(LIST_diag):
/* FALLTHROUGH */
case(LIST_hang):
/* FALLTHROUGH */
case(LIST_inset):
/* FALLTHROUGH */
case(LIST_ohang):
/* FALLTHROUGH */
case(LIST_tag):
print_otag(h, TAG_DL, 2, tag);
break;
case(LIST_column):
print_otag(h, TAG_TABLE, 2, tag);
break;
default:
abort();
/* NOTREACHED */
}
return(1);
}
int
setup(char *dev)
{
long cg, size, asked, i, j, bmapsize;
struct disklabel *lp;
off_t sizepb;
struct stat statb;
struct fs proto;
int doskipclean;
int32_t maxsymlinklen, nindir, inopb;
u_int64_t maxfilesize;
char *realdev;
havesb = 0;
fswritefd = fsreadfd = -1;
doskipclean = skipclean;
if ((fsreadfd = opendev(dev, O_RDONLY, 0, &realdev)) < 0) {
printf("Can't open %s: %s\n", dev, strerror(errno));
return (0);
}
if (strncmp(dev, realdev, PATH_MAX) != 0) {
blockcheck(unrawname(realdev));
strlcpy(rdevname, realdev, sizeof(rdevname));
setcdevname(rdevname, dev, preen);
}
if (fstat(fsreadfd, &statb) < 0) {
printf("Can't stat %s: %s\n", realdev, strerror(errno));
close(fsreadfd);
return (0);
}
if (!S_ISCHR(statb.st_mode)) {
pfatal("%s is not a character device", realdev);
if (reply("CONTINUE") == 0) {
close(fsreadfd);
return (0);
}
}
if (preen == 0) {
printf("** %s", realdev);
if (strncmp(dev, realdev, PATH_MAX) != 0)
printf(" (%s)", dev);
}
if (nflag || (fswritefd = opendev(dev, O_WRONLY, 0, NULL)) < 0) {
fswritefd = -1;
if (preen)
pfatal("NO WRITE ACCESS");
printf(" (NO WRITE)");
}
if (preen == 0)
printf("\n");
fsmodified = 0;
lfdir = 0;
initbarea(&sblk);
initbarea(&asblk);
sblk.b_un.b_buf = malloc(SBSIZE);
asblk.b_un.b_buf = malloc(SBSIZE);
if (sblk.b_un.b_buf == NULL || asblk.b_un.b_buf == NULL)
errexit("cannot allocate space for superblock\n");
if ((lp = getdisklabel(NULL, fsreadfd)) != NULL)
dev_bsize = secsize = lp->d_secsize;
else
dev_bsize = secsize = DEV_BSIZE;
/*
* Read in the superblock, looking for alternates if necessary
*/
if (readsb(1) == 0) {
if (bflag || preen || calcsb(realdev, fsreadfd, &proto) == 0)
return(0);
if (reply("LOOK FOR ALTERNATE SUPERBLOCKS") == 0)
return (0);
for (i = 0; i < sizeof(altsbtry) / sizeof(altsbtry[0]); i++) {
bflag = altsbtry[i];
/* proto partially setup by calcsb */
if (readsb(0) != 0 &&
proto.fs_fsize == sblock.fs_fsize &&
proto.fs_bsize == sblock.fs_bsize)
goto found;
}
for (cg = 0; cg < proto.fs_ncg; cg++) {
bflag = fsbtodb(&proto, cgsblock(&proto, cg));
if (readsb(0) != 0)
break;
}
if (cg >= proto.fs_ncg) {
printf("%s %s\n%s %s\n%s %s\n",
"SEARCH FOR ALTERNATE SUPER-BLOCK",
"FAILED. YOU MUST USE THE",
"-b OPTION TO FSCK_FFS TO SPECIFY THE",
"LOCATION OF AN ALTERNATE",
"SUPER-BLOCK TO SUPPLY NEEDED",
"INFORMATION; SEE fsck_ffs(8).");
return(0);
}
found:
doskipclean = 0;
pwarn("USING ALTERNATE SUPERBLOCK AT %d\n", bflag);
}
if (debug)
printf("clean = %d\n", sblock.fs_clean);
if (sblock.fs_clean & FS_ISCLEAN) {
if (doskipclean) {
pwarn("%sile system is clean; not checking\n",
preen ? "f" : "** F");
return (-1);
}
if (!preen)
pwarn("** File system is already clean\n");
}
maxfsblock = sblock.fs_size;
maxino = sblock.fs_ncg * sblock.fs_ipg;
sizepb = sblock.fs_bsize;
maxfilesize = sblock.fs_bsize * NDADDR - 1;
for (i = 0; i < NIADDR; i++) {
sizepb *= NINDIR(&sblock);
maxfilesize += sizepb;
}
/*
* Check and potentially fix certain fields in the super block.
*/
if (sblock.fs_optim != FS_OPTTIME && sblock.fs_optim != FS_OPTSPACE) {
pfatal("UNDEFINED OPTIMIZATION IN SUPERBLOCK");
if (reply("SET TO DEFAULT") == 1) {
sblock.fs_optim = FS_OPTTIME;
sbdirty();
}
}
if ((sblock.fs_minfree < 0 || sblock.fs_minfree > 99)) {
pfatal("IMPOSSIBLE MINFREE=%d IN SUPERBLOCK",
sblock.fs_minfree);
if (reply("SET TO DEFAULT") == 1) {
sblock.fs_minfree = 10;
sbdirty();
}
}
if (sblock.fs_npsect < sblock.fs_nsect ||
sblock.fs_npsect > sblock.fs_nsect*2) {
pwarn("IMPOSSIBLE NPSECT=%d IN SUPERBLOCK",
sblock.fs_npsect);
sblock.fs_npsect = sblock.fs_nsect;
if (preen)
printf(" (FIXED)\n");
if (preen || reply("SET TO DEFAULT") == 1) {
sbdirty();
dirty(&asblk);
}
}
if (sblock.fs_bmask != ~(sblock.fs_bsize - 1)) {
pwarn("INCORRECT BMASK=%x IN SUPERBLOCK",
sblock.fs_bmask);
sblock.fs_bmask = ~(sblock.fs_bsize - 1);
if (preen)
printf(" (FIXED)\n");
if (preen || reply("FIX") == 1) {
sbdirty();
dirty(&asblk);
}
}
if (sblock.fs_fmask != ~(sblock.fs_fsize - 1)) {
pwarn("INCORRECT FMASK=%x IN SUPERBLOCK",
sblock.fs_fmask);
sblock.fs_fmask = ~(sblock.fs_fsize - 1);
if (preen)
printf(" (FIXED)\n");
if (preen || reply("FIX") == 1) {
sbdirty();
dirty(&asblk);
}
}
if (1 << sblock.fs_bshift != sblock.fs_bsize) {
pwarn("INCORRECT BSHIFT=%d IN SUPERBLOCK", sblock.fs_bshift);
sblock.fs_bshift = ffs(sblock.fs_bsize) - 1;
if (preen)
printf(" (FIXED)\n");
if (preen || reply("FIX") == 1) {
sbdirty();
dirty(&asblk);
}
}
if (1 << sblock.fs_fshift != sblock.fs_fsize) {
pwarn("INCORRECT FSHIFT=%d IN SUPERBLOCK", sblock.fs_fshift);
sblock.fs_fshift = ffs(sblock.fs_fsize) - 1;
if (preen)
printf(" (FIXED)\n");
if (preen || reply("FIX") == 1) {
sbdirty();
dirty(&asblk);
}
}
if (sblock.fs_inodefmt < FS_44INODEFMT) {
pwarn("Format of filesystem is too old.\n");
pwarn("Must update to modern format using a version of fsck\n");
pfatal("from before release 5.0 with the command ``fsck -c 2''\n");
exit(8);
}
if (sblock.fs_maxfilesize != maxfilesize) {
pwarn("INCORRECT MAXFILESIZE=%llu IN SUPERBLOCK",
(unsigned long long)sblock.fs_maxfilesize);
sblock.fs_maxfilesize = maxfilesize;
if (preen)
printf(" (FIXED)\n");
if (preen || reply("FIX") == 1) {
sbdirty();
dirty(&asblk);
}
}
maxsymlinklen = sblock.fs_magic == FS_UFS1_MAGIC ?
MAXSYMLINKLEN_UFS1 : MAXSYMLINKLEN_UFS2;
if (sblock.fs_maxsymlinklen != maxsymlinklen) {
pwarn("INCORRECT MAXSYMLINKLEN=%d IN SUPERBLOCK",
sblock.fs_maxsymlinklen);
sblock.fs_maxsymlinklen = maxsymlinklen;
if (preen)
printf(" (FIXED)\n");
if (preen || reply("FIX") == 1) {
sbdirty();
dirty(&asblk);
}
}
if (sblock.fs_qbmask != ~sblock.fs_bmask) {
pwarn("INCORRECT QBMASK=%lx IN SUPERBLOCK",
(unsigned long)sblock.fs_qbmask);
sblock.fs_qbmask = ~sblock.fs_bmask;
if (preen)
printf(" (FIXED)\n");
if (preen || reply("FIX") == 1) {
sbdirty();
dirty(&asblk);
}
}
if (sblock.fs_qfmask != ~sblock.fs_fmask) {
pwarn("INCORRECT QFMASK=%lx IN SUPERBLOCK",
(unsigned long)sblock.fs_qfmask);
sblock.fs_qfmask = ~sblock.fs_fmask;
if (preen)
printf(" (FIXED)\n");
if (preen || reply("FIX") == 1) {
sbdirty();
dirty(&asblk);
}
}
if (sblock.fs_cgsize != fragroundup(&sblock, CGSIZE(&sblock))) {
pwarn("INCONSISTENT CGSIZE=%d\n", sblock.fs_cgsize);
sblock.fs_cgsize = fragroundup(&sblock, CGSIZE(&sblock));
if (preen)
printf(" (FIXED)\n");
if (preen || reply("FIX") == 1) {
sbdirty();
dirty(&asblk);
}
}
if (sblock.fs_magic == FS_UFS2_MAGIC)
inopb = sblock.fs_bsize / sizeof(struct ufs2_dinode);
else
inopb = sblock.fs_bsize / sizeof(struct ufs1_dinode);
if (INOPB(&sblock) != inopb) {
pwarn("INCONSISTENT INOPB=%d\n", INOPB(&sblock));
sblock.fs_inopb = inopb;
if (preen)
printf(" (FIXED)\n");
if (preen || reply("FIX") == 1) {
sbdirty();
dirty(&asblk);
}
}
if (sblock.fs_magic == FS_UFS2_MAGIC)
nindir = sblock.fs_bsize / sizeof(int64_t);
else
nindir = sblock.fs_bsize / sizeof(int32_t);
if (NINDIR(&sblock) != nindir) {
pwarn("INCONSISTENT NINDIR=%d\n", NINDIR(&sblock));
sblock.fs_nindir = nindir;
if (preen)
printf(" (FIXED)\n");
if (preen || reply("FIX") == 1) {
sbdirty();
dirty(&asblk);
}
}
if (asblk.b_dirty && !bflag) {
memcpy(&altsblock, &sblock, (size_t)sblock.fs_sbsize);
flush(fswritefd, &asblk);
}
/*
* read in the summary info.
*/
asked = 0;
sblock.fs_csp = calloc(1, sblock.fs_cssize);
if (sblock.fs_csp == NULL) {
printf("cannot alloc %u bytes for cylinder group summary area\n",
(unsigned)sblock.fs_cssize);
goto badsblabel;
}
for (i = 0, j = 0; i < sblock.fs_cssize; i += sblock.fs_bsize, j++) {
size = sblock.fs_cssize - i < sblock.fs_bsize ?
sblock.fs_cssize - i : sblock.fs_bsize;
if (bread(fsreadfd, (char *)sblock.fs_csp + i,
fsbtodb(&sblock, sblock.fs_csaddr + j * sblock.fs_frag),
size) != 0 && !asked) {
pfatal("BAD SUMMARY INFORMATION");
if (reply("CONTINUE") == 0) {
ckfini(0);
errexit("%s", "");
}
asked++;
}
}
/*
* allocate and initialize the necessary maps
*/
bmapsize = roundup(howmany(maxfsblock, NBBY), sizeof(int16_t));
blockmap = calloc((unsigned)bmapsize, sizeof(char));
if (blockmap == NULL) {
printf("cannot alloc %u bytes for blockmap\n",
(unsigned)bmapsize);
goto badsblabel;
}
inostathead = calloc((unsigned)(sblock.fs_ncg),
sizeof(struct inostatlist));
if (inostathead == NULL) {
printf("cannot alloc %u bytes for inostathead\n",
(unsigned)(sizeof(struct inostatlist) * (sblock.fs_ncg)));
goto badsblabel;
}
numdirs = MAX(sblock.fs_cstotal.cs_ndir, 128);
inplast = 0;
listmax = numdirs + 10;
inpsort = calloc((unsigned)listmax, sizeof(struct inoinfo *));
if (inpsort == NULL) {
printf("cannot alloc %zu bytes for inpsort\n",
(unsigned)listmax * sizeof(struct inoinfo *));
goto badsblabel;
}
inphead = calloc((unsigned)numdirs, sizeof(struct inoinfo *));
if (inphead == NULL) {
printf("cannot alloc %zu bytes for inphead\n",
(unsigned)numdirs * sizeof(struct inoinfo *));
goto badsblabel;
}
bufinit();
if (sblock.fs_flags & FS_DOSOFTDEP)
usedsoftdep = 1;
else
usedsoftdep = 0;
return (1);
badsblabel:
ckfini(0);
return (0);
}
static void sysinit(void)
{
int32 i;
struct procent *prptr; /* ptr to process table entry */
struct sentry *semptr; /* prr to semaphore table entry */
struct memblk *memptr; /* ptr to memory block */
/* Initialize system variables */
/* Count the Null process as the first process in the system */
prcount = 1;
/* Scheduling is not currently blocked */
Defer.ndefers = 0;
/* Initialize the free memory list */
maxheap = (void *)addressp2k(MAXADDR);
memlist.mnext = (struct memblk *)minheap;
/* Overlay memblk structure on free memory and set fields */
memptr = (struct memblk *)minheap;
memptr->mnext = NULL;
memptr->mlength = memlist.mlength = (uint32)(maxheap - minheap);
/* Initialize process table entries free */
for (i = 0; i < NPROC; i++) {
prptr = &proctab[i];
prptr->prstate = PR_FREE;
prptr->prname[0] = NULLCH;
prptr->prstkbase = NULL;
prptr->prprio = 0;
}
/* Initialize the Null process entry */
prptr = &proctab[NULLPROC];
prptr->prstate = PR_CURR;
prptr->prprio = 0;
strncpy(prptr->prname, "prnull", 7);
prptr->prstkbase = minheap;
prptr->prstklen = NULLSTK;
prptr->prstkptr = 0;
currpid = NULLPROC;
/* Initialize semaphores */
for (i = 0; i < NSEM; i++) {
semptr = &semtab[i];
semptr->sstate = S_FREE;
semptr->scount = 0;
semptr->squeue = newqueue();
}
/* Initialize buffer pools */
bufinit();
/* Create a ready list for processes */
readylist = newqueue();
/* Initialize real time clock */
clkinit();
/* Initialize non-volative RAM storage */
#if 0
nvramInit();
#endif
/* Initialize devices */
for (i = 0; i < NDEVS; i++) {
init(i);
}
return;
}
/*
* cpu_startup: allocate memory for variable-sized tables, initialize CPU, and
* do auto-configuration.
*/
void
cpu_startup()
{
vaddr_t minaddr, maxaddr;
#ifdef PMAPDEBUG
extern int pmapdebug;
int opmapdebug = pmapdebug;
pmapdebug = 0; /* Shut up pmap debug during bootstrap. */
#endif
/*
* Good {morning,afternoon,evening,night}.
*/
printf(version);
printf("real mem = %u (%uMB)\n", ptoa(physmem),
ptoa(physmem)/1024/1024);
printf("rsvd mem = %u (%uMB)\n", ptoa(rsvdmem),
ptoa(rsvdmem)/1024/1024);
/*
* Determine how many buffers to allocate.
* We allocate bufcachepercent% of memory for buffer space.
*/
if (bufpages == 0)
bufpages = physmem * bufcachepercent / 100;
/* Restrict to at most 25% filled kvm. */
if (bufpages >
(VM_MAX_KERNEL_ADDRESS-VM_MIN_KERNEL_ADDRESS) / PAGE_SIZE / 4)
bufpages = (VM_MAX_KERNEL_ADDRESS-VM_MIN_KERNEL_ADDRESS) /
PAGE_SIZE / 4;
/*
* Allocate a submap for exec arguments. This map effectively
* limits the number of processes exec'ing at any time.
*/
minaddr = vm_map_min(kernel_map);
exec_map = uvm_km_suballoc(kernel_map, &minaddr, &maxaddr,
16 * NCARGS, VM_MAP_PAGEABLE, FALSE, NULL);
/* Allocate a submap for physio. */
phys_map = uvm_km_suballoc(kernel_map, &minaddr, &maxaddr,
VM_PHYS_SIZE, 0, FALSE, NULL);
#ifdef PMAPDEBUG
pmapdebug = opmapdebug;
#endif
printf("avail mem = %u (%uMB)\n", ptoa(uvmexp.free),
ptoa(uvmexp.free)/1024/1024);
extent_malloc_flags = EX_MALLOCOK;
/*
* Set up CPU-specific registers, cache, etc.
*/
initcpu();
/*
* Set up buffers, so they can be used to read disk labels.
*/
bufinit();
/*
* Configure the system.
*/
if (boothowto & RB_CONFIG) {
#ifdef BOOT_CONFIG
user_config();
#else
printf("kernel does not support -c; continuing..\n");
#endif
}
}