Cleanups for 4.4BSD-Lite

[unix-history] / usr / src / sys / kern / init_main.c

diff --git a/usr/src/sys/kern/init_main.c b/usr/src/sys/kern/init_main.c
index 93f3019..f546fe9 100644 (file)
--- a/usr/src/sys/kern/init_main.c
+++ b/usr/src/sys/kern/init_main.c
@@ -1,40 +1,44 @@
 /*
 /*

- * Copyright (c) 1982, 1986, 1989, 1991 Regents of the University of California.
- * All rights reserved.
+ * Copyright (c) 1982, 1986, 1989, 1991, 1992, 1993
+ *     The Regents of the University of California.  All rights reserved.

  *
  * %sccs.include.redist.c%
  *
  *
  * %sccs.include.redist.c%
  *

- *     @(#)init_main.c 7.37 (Berkeley) %G%
+ *     @(#)init_main.c 8.2 (Berkeley) %G%

  */
 
  */
 

-#include "param.h"
-#include "filedesc.h"
-#include "kernel.h"
-#include "mount.h"
-#include "map.h"
-#include "proc.h"
-#include "resourcevar.h"
-#include "signalvar.h"
-#include "systm.h"
-#include "vnode.h"
-#include "seg.h"
-#include "conf.h"
-#include "buf.h"
-#include "clist.h"
-#include "malloc.h"
-#include "protosw.h"
-#include "reboot.h"
-#include "user.h"
-
-
-#include "machine/cpu.h"
-
-#include "vm/vm.h"
+#include <sys/param.h>
+#include <sys/filedesc.h>
+#include <sys/kernel.h>
+#include <sys/mount.h>
+#include <sys/map.h>
+#include <sys/proc.h>
+#include <sys/resourcevar.h>
+#include <sys/signalvar.h>
+#include <sys/systm.h>
+#include <sys/vnode.h>
+#include <sys/conf.h>
+#include <sys/buf.h>
+#include <sys/clist.h>
+#include <sys/device.h>
+#include <sys/protosw.h>
+#include <sys/reboot.h>
+#include <sys/user.h>
+
+
+#include <machine/cpu.h>
+
+#include <vm/vm.h>
+
+#ifdef HPFPLIB
+char   copyright[] =
+"Copyright (c) 1982, 1986, 1989, 1991, 1993\n\tThe Regents of the University of California.\nCopyright (c) 1992 Hewlett-Packard Company\nCopyright (c) 1992 Motorola Inc.\nAll rights reserved.\n\n";
+#else
+char   copyright[] =
+"Copyright (c) 1982, 1986, 1989, 1991, 1993\n\tThe Regents of the University of California.  All rights reserved.\n\n";
+#endif

 
 

-/*
- * Components of process 0;
- * never freed.
- */
+/* Components of the first process -- never freed. */

 struct session session0;
 struct pgrp pgrp0;
 struct proc proc0;
 struct session session0;
 struct pgrp pgrp0;
 struct proc proc0;


@@ -46,27 +50,34 @@ struct      proc *curproc = &proc0;
 struct proc *initproc, *pageproc;
 
 int    cmask = CMASK;
 struct proc *initproc, *pageproc;
 
 int    cmask = CMASK;

-extern caddr_t proc0paddr;
-extern int (*mountroot)();
+extern struct user *proc0paddr;
+
+struct vnode *rootvp, *swapdev_vp;
+int    boothowto;
+struct timeval boottime;
+struct timeval runtime;

 
 /*
 
 /*

- * System startup; initialize the world, create process 0,
- * mount root filesystem, and fork to create init and pagedaemon.
- * Most of the hard work is done in the lower-level initialization
- * routines including startup(), which does memory initialization
- * and autoconfiguration.
+ * System startup; initialize the world, create process 0, mount root
+ * filesystem, and fork to create init and pagedaemon.  Most of the
+ * hard work is done in the lower-level initialization routines including
+ * startup(), which does memory initialization and autoconfiguration.

  */
  */

-main(firstaddr)
-       int firstaddr;
+main()

 {
 {

-       register int i;

        register struct proc *p;
        register struct filedesc0 *fdp;
        register struct proc *p;
        register struct filedesc0 *fdp;

+       register struct pdevinit *pdev;
+       register int i;

        int s, rval[2];
        int s, rval[2];

+       extern int (*mountroot) __P((void));
+       extern struct pdevinit pdevinit[];
+       extern void roundrobin __P((void *));
+       extern void schedcpu __P((void *));

 
        /*
 
        /*

-        * Initialize curproc before any possible traps/probes
-        * to simplify trap processing.
+        * Initialize the current process pointer (curproc) before
+        * any possible traps/probes to simplify trap processing.

         */
        p = &proc0;
        curproc = p;
         */
        p = &proc0;
        curproc = p;


@@ -75,19 +86,18 @@ main(firstaddr)
         * in case of early panic or other messages.
         */
        consinit();
         * in case of early panic or other messages.
         */
        consinit();

+       printf(copyright);

 
        vm_mem_init();
        kmeminit();
 
        vm_mem_init();
        kmeminit();

-       startup(firstaddr);
+       cpu_startup();

 
 

-       /*
-        * set up system process 0 (swapper)
-        */
+       /* Create process 0 (the swapper). */

        p = &proc0;
        curproc = p;
 
        p = &proc0;
        curproc = p;
 

-       allproc = p;
-       p->p_prev = &allproc;
+       allproc = (volatile struct proc *)p;
+       p->p_prev = (struct proc **)&allproc;

        p->p_pgrp = &pgrp0;
        pgrphash[0] = &pgrp0;
        pgrp0.pg_mem = p;
        p->p_pgrp = &pgrp0;
        pgrphash[0] = &pgrp0;
        pgrp0.pg_mem = p;


@@ -100,16 +110,13 @@ main(firstaddr)
        p->p_nice = NZERO;
        bcopy("swapper", p->p_comm, sizeof ("swapper"));
 
        p->p_nice = NZERO;
        bcopy("swapper", p->p_comm, sizeof ("swapper"));
 

-       /*
-        * Setup credentials
-        */
+       /* Create credentials. */
+       cred0.p_refcnt = 1;

        p->p_cred = &cred0;
        p->p_ucred = crget();
        p->p_ucred->cr_ngroups = 1;     /* group 0 */
 
        p->p_cred = &cred0;
        p->p_ucred = crget();
        p->p_ucred->cr_ngroups = 1;     /* group 0 */
 

-       /*
-        * Create the file descriptor table for process 0.
-        */
+       /* Create the file descriptor table. */

        fdp = &filedesc0;
        p->p_fd = &fdp->fd_fd;
        fdp->fd_fd.fd_refcnt = 1;
        fdp = &filedesc0;
        p->p_fd = &fdp->fd_fd;
        fdp->fd_fd.fd_refcnt = 1;


@@ -118,20 +125,20 @@ main(firstaddr)
        fdp->fd_fd.fd_ofileflags = fdp->fd_dfileflags;
        fdp->fd_fd.fd_nfiles = NDFILE;
 
        fdp->fd_fd.fd_ofileflags = fdp->fd_dfileflags;
        fdp->fd_fd.fd_nfiles = NDFILE;
 

-       /*
-        * Set initial limits
-        */
+       /* Create the limits structures. */

        p->p_limit = &limit0;
        for (i = 0; i < sizeof(p->p_rlimit)/sizeof(p->p_rlimit[0]); i++)
                limit0.pl_rlimit[i].rlim_cur =
                    limit0.pl_rlimit[i].rlim_max = RLIM_INFINITY;
        p->p_limit = &limit0;
        for (i = 0; i < sizeof(p->p_rlimit)/sizeof(p->p_rlimit[0]); i++)
                limit0.pl_rlimit[i].rlim_cur =
                    limit0.pl_rlimit[i].rlim_max = RLIM_INFINITY;

-       limit0.pl_rlimit[RLIMIT_OFILE].rlim_cur = NOFILE;
+       limit0.pl_rlimit[RLIMIT_NOFILE].rlim_cur = NOFILE;

        limit0.pl_rlimit[RLIMIT_NPROC].rlim_cur = MAXUPRC;
        limit0.pl_rlimit[RLIMIT_NPROC].rlim_cur = MAXUPRC;

+       i = ptoa(cnt.v_free_count);
+       limit0.pl_rlimit[RLIMIT_RSS].rlim_max = i;
+       limit0.pl_rlimit[RLIMIT_MEMLOCK].rlim_max = i;
+       limit0.pl_rlimit[RLIMIT_MEMLOCK].rlim_cur = i / 3;

        limit0.p_refcnt = 1;
 
        limit0.p_refcnt = 1;
 

-       /*
-        * Allocate a prototype map so we have something to fork
-        */
+       /* Allocate a prototype map so we have something to fork. */

        p->p_vmspace = &vmspace0;
        vmspace0.vm_refcnt = 1;
        pmap_pinit(&vmspace0.vm_pmap);
        p->p_vmspace = &vmspace0;
        vmspace0.vm_refcnt = 1;
        pmap_pinit(&vmspace0.vm_pmap);


@@ -141,58 +148,48 @@ main(firstaddr)
        p->p_addr = proc0paddr;                         /* XXX */
 
        /*
        p->p_addr = proc0paddr;                         /* XXX */
 
        /*

-        * We continue to place resource usage info
-        * and signal actions in the user struct so they're pageable.
+        * We continue to place resource usage info and signal
+        * actions in the user struct so they're pageable.

         */
         */

-       p->p_stats = &((struct user *)p->p_addr)->u_stats;
-       p->p_sigacts = &((struct user *)p->p_addr)->u_sigacts;
-
-       rqinit();
+       p->p_stats = &p->p_addr->u_stats;
+       p->p_sigacts = &p->p_addr->u_sigacts;

 
        /*
 
        /*

-        * configure virtual memory system,
-        * set vm rlimits
+        * Initialize per uid information structure and charge
+        * root for one process.

         */
         */

+       usrinfoinit();
+       (void)chgproccnt(0, 1);
+
+       rqinit();
+
+       /* Configure virtual memory system, set vm rlimits. */

        vm_init_limits(p);
 
        vm_init_limits(p);
 

-       /*
-        * Initialize the file systems.
-        *
-        * Get vnodes for swapdev, argdev, and rootdev.
-        */
+       /* Initialize the file systems. */

        vfsinit();
        vfsinit();

-       if (bdevvp(swapdev, &swapdev_vp) ||
-           bdevvp(argdev, &argdev_vp) ||
-           bdevvp(rootdev, &rootvp))
-               panic("can't setup bdevvp's");
-
-       startrtclock();
-#if defined(vax)
-#include "kg.h"
-#if NKG > 0
-       startkgclock();
-#endif
-#endif

 
 

-       /*
-        * Initialize tables, protocols, and set up well-known inodes.
-        */
+       /* Start real time and statistics clocks. */
+       initclocks();
+
+       /* Initialize mbuf's. */

        mbinit();
        mbinit();

-       cinit();
+
+       /* Initialize clists. */
+       clist_init();
+

 #ifdef SYSVSHM
 #ifdef SYSVSHM

+       /* Initialize System V style shared memory. */

        shminit();
 #endif
        shminit();
 #endif

-#include "sl.h"
-#if NSL > 0
-       slattach();                     /* XXX */
-#endif
-#include "loop.h"
-#if NLOOP > 0
-       loattach();                     /* XXX */
-#endif
+
+       /* Attach pseudo-devices. */
+       for (pdev = pdevinit; pdev->pdev_attach != NULL; pdev++)
+               (*pdev->pdev_attach)(pdev->pdev_count);
+

        /*
        /*

-        * Block reception of incoming packets
-        * until protocols have been initialized.
+        * Initialize protocols.  Block reception of incoming packets
+        * until everything is ready.

         */
        s = splimp();
        ifinit();
         */
        s = splimp();
        ifinit();


@@ -200,83 +197,86 @@ main(firstaddr)
        splx(s);
 
 #ifdef GPROF
        splx(s);
 
 #ifdef GPROF

+       /* Initialize kernel profiling. */

        kmstartup();
 #endif
 
        kmstartup();
 #endif
 

-       /* kick off timeout driven events by calling first time */
-       roundrobin();
-       schedcpu();
-       enablertclock();                /* enable realtime clock interrupts */
+       /* Kick off timeout driven events by calling first time. */
+       roundrobin(NULL);
+       schedcpu(NULL);

 
 

-       /*
-        * Set up the root file system and vnode.
-        */
+       /* Mount the root file system. */

        if ((*mountroot)())
                panic("cannot mount root");
        if ((*mountroot)())
                panic("cannot mount root");

-       /*
-        * Get vnode for '/'.
-        * Setup rootdir and fdp->fd_fd.fd_cdir to point to it.
-        */
-       if (VFS_ROOT(rootfs, &rootdir))
+
+       /* Get the vnode for '/'.  Set fdp->fd_fd.fd_cdir to reference it. */
+       if (VFS_ROOT(rootfs, &rootvnode))

                panic("cannot find root vnode");
                panic("cannot find root vnode");

-       fdp->fd_fd.fd_cdir = rootdir;
+       fdp->fd_fd.fd_cdir = rootvnode;

        VREF(fdp->fd_fd.fd_cdir);
        VREF(fdp->fd_fd.fd_cdir);

-       VOP_UNLOCK(rootdir);
+       VOP_UNLOCK(rootvnode);

        fdp->fd_fd.fd_rdir = NULL;
        swapinit();
 
        /*
        fdp->fd_fd.fd_rdir = NULL;
        swapinit();
 
        /*

-        * Now can look at time, having had a chance
-        * to verify the time from the file system.
+        * Now can look at time, having had a chance to verify the time
+        * from the file system.  Reset p->p_rtime as it may have been
+        * munched in swtch() after the time got set.

         */
         */

-       boottime = p->p_stats->p_start = time;
+       p->p_stats->p_start = runtime = mono_time = boottime = time;
+       p->p_rtime.tv_sec = p->p_rtime.tv_usec = 0;

 
 

-       /*
-        * make init process
-        */
+       /* Initialize signal state for process 0. */

        siginit(p);
        siginit(p);

-       if (fork(p, (void *) NULL, rval))
+
+       /* Create process 1 (init(8)). */
+       if (fork(p, NULL, rval))

                panic("fork init");
        if (rval[1]) {
                panic("fork init");
        if (rval[1]) {

+               extern int icode[];             /* user init code */
+               extern int szicode;             /* size of icode */

                static char initflags[] = "-sf";
                static char initflags[] = "-sf";

-               char *ip = initflags + 1;
-               vm_offset_t addr = 0;
+               vm_offset_t addr;
+               char *ip;

 
                /*
 
                /*

-                * Now in process 1.  Set init flags into icode,
-                * get a minimal address space, copy out "icode",
-                * and return to it to do an exec of init.
+                * Now in process 1.  Set init flags into icode, get a minimal
+                * address space, copy out "icode", and return to it to do an
+                * exec of init.

                 */
                 */

-               p = curproc;
-               initproc = p;
+               ip = initflags + 1;

                if (boothowto&RB_SINGLE)
                        *ip++ = 's';
 #ifdef notyet
                if (boothowto&RB_FASTBOOT)
                        *ip++ = 'f';
 #endif
                if (boothowto&RB_SINGLE)
                        *ip++ = 's';
 #ifdef notyet
                if (boothowto&RB_FASTBOOT)
                        *ip++ = 'f';
 #endif

+               if (ip == initflags + 1)
+                       *ip++ = '-';

                *ip++ = '\0';
 
                *ip++ = '\0';
 

+               addr = VM_MIN_ADDRESS;
+               initproc = p = curproc;

                if (vm_allocate(&p->p_vmspace->vm_map, &addr,
                    round_page(szicode + sizeof(initflags)), FALSE) != 0 ||
                if (vm_allocate(&p->p_vmspace->vm_map, &addr,
                    round_page(szicode + sizeof(initflags)), FALSE) != 0 ||

-                   addr != 0)
+                   addr != VM_MIN_ADDRESS)

                        panic("init: couldn't allocate at zero");
 
                        panic("init: couldn't allocate at zero");
 

-               /* need just enough stack to exec from */
-               addr = trunc_page(VM_MAX_ADDRESS - PAGE_SIZE);
+               /* Need just enough stack from which to exec. */
+               addr = trunc_page(USRSTACK - PAGE_SIZE);

                if (vm_allocate(&p->p_vmspace->vm_map, &addr,
                    PAGE_SIZE, FALSE) != KERN_SUCCESS)
                        panic("vm_allocate init stack");
                p->p_vmspace->vm_maxsaddr = (caddr_t)addr;
                if (vm_allocate(&p->p_vmspace->vm_map, &addr,
                    PAGE_SIZE, FALSE) != KERN_SUCCESS)
                        panic("vm_allocate init stack");
                p->p_vmspace->vm_maxsaddr = (caddr_t)addr;

-               (void) copyout((caddr_t)icode, (caddr_t)0, (unsigned)szicode);
-               (void) copyout(initflags, (caddr_t)szicode, sizeof(initflags));
+               (void)copyout((caddr_t)icode, (caddr_t)VM_MIN_ADDRESS,
+                   (u_int)szicode);
+               (void)copyout(initflags, (caddr_t)(VM_MIN_ADDRESS + szicode),
+                   sizeof(initflags));

                return;                 /* returns to icode */
        }
 
                return;                 /* returns to icode */
        }
 

-       /*
-        * Start up pageout daemon (process 2).
-        */
-       if (fork(p, (void *) NULL, rval))
+       /* Create process 2 (the pageout daemon). */
+       if (fork(p, NULL, rval))

                panic("fork pager");
        if (rval[1]) {
                /*
                panic("fork pager");
        if (rval[1]) {
                /*


@@ -287,50 +287,10 @@ main(firstaddr)
                p->p_flag |= SLOAD|SSYS;                /* XXX */
                bcopy("pagedaemon", curproc->p_comm, sizeof ("pagedaemon"));
                vm_pageout();
                p->p_flag |= SLOAD|SSYS;                /* XXX */
                bcopy("pagedaemon", curproc->p_comm, sizeof ("pagedaemon"));
                vm_pageout();

-               /*NOTREACHED*/
+               /* NOTREACHED */

        }
 
        }
 

-       /*
-        * enter scheduling loop
-        */
-       sched();
-}
-
-/* MOVE TO vfs_bio.c (bufinit) XXX */
-/*
- * Initialize buffers and hash links for buffers.
- */
-bufinit()
-{
-       register int i;
-       register struct buf *bp, *dp;
-       register struct bufhd *hp;
-       int base, residual;
-
-       for (hp = bufhash, i = 0; i < BUFHSZ; i++, hp++)
-               hp->b_forw = hp->b_back = (struct buf *)hp;
-
-       for (dp = bfreelist; dp < &bfreelist[BQUEUES]; dp++) {
-               dp->b_forw = dp->b_back = dp->av_forw = dp->av_back = dp;
-               dp->b_flags = B_HEAD;
-       }
-       base = bufpages / nbuf;
-       residual = bufpages % nbuf;
-       for (i = 0; i < nbuf; i++) {
-               bp = &buf[i];
-               bp->b_dev = NODEV;
-               bp->b_bcount = 0;
-               bp->b_rcred = NOCRED;
-               bp->b_wcred = NOCRED;
-               bp->b_dirtyoff = 0;
-               bp->b_dirtyend = 0;
-               bp->b_un.b_addr = buffers + i * MAXBSIZE;
-               if (i < residual)
-                       bp->b_bufsize = (base + 1) * CLBYTES;
-               else
-                       bp->b_bufsize = base * CLBYTES;
-               binshash(bp, &bfreelist[BQ_AGE]);
-               bp->b_flags = B_BUSY|B_INVAL;
-               brelse(bp);
-       }
+       /* The scheduler is an infinite loop. */
+       scheduler();
+       /* NOTREACHED */

 }
 }