convert VOP_UNLOCK and vrele into vput's; add proc parameter to union_dircache

[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 f2d427b..249f6c6 100644 (file)
--- a/usr/src/sys/kern/init_main.c
+++ b/usr/src/sys/kern/init_main.c
@@ -1,42 +1,52 @@
 /*
 /*

- * 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.
+ * (c) UNIX System Laboratories, Inc.
+ * All or some portions of this file are derived from material licensed
+ * to the University of California by American Telephone and Telegraph
+ * Co. or Unix System Laboratories, Inc. and are reproduced herein with
+ * the permission of UNIX System Laboratories, Inc.

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

- *     @(#)init_main.c 7.50 (Berkeley) %G%
+ *     @(#)init_main.c 8.16 (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 "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/errno.h>
+#include <sys/exec.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 <sys/syscallargs.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[] =
 char   copyright[] =

-"Copyright (c) 1982,1986,1989,1991 The Regents of the University of California.\nAll rights reserved.\n\n";
+"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;


@@ -49,32 +59,36 @@ struct      proc *initproc, *pageproc;
 
 int    cmask = CMASK;
 extern struct user *proc0paddr;
 
 int    cmask = CMASK;
 extern struct user *proc0paddr;

-extern int (*mountroot)();

 
 struct vnode *rootvp, *swapdev_vp;
 int    boothowto;
 struct timeval boottime;
 struct timeval runtime;
 
 
 struct vnode *rootvp, *swapdev_vp;
 int    boothowto;
 struct timeval boottime;
 struct timeval runtime;
 

+static void start_init __P((struct proc *p, void *framep));
+

 /*
 /*

- * 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()
+main(framep)
+       void *framep;

 {
 {

-       register int i;

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

-       int s, rval[2];
+       register struct pdevinit *pdev;
+       register int i;
+       int s;
+       register_t rval[2];
+       extern struct pdevinit pdevinit[];

        extern void roundrobin __P((void *));
        extern void schedcpu __P((void *));
 
        /*
        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;


@@ -90,36 +104,35 @@ main()
        cpu_startup();
 
        /*
        cpu_startup();
 
        /*

-        * set up system process 0 (swapper)
+        * Initialize process and pgrp structures.

         */
         */

-       p = &proc0;
-       curproc = p;
+       procinit();

 
 

-       allproc = (volatile struct proc *)p;
-       p->p_prev = (struct proc **)&allproc;
+       /*
+        * Create process 0 (the swapper).
+        */
+       LIST_INSERT_HEAD(&allproc, p, p_list);

        p->p_pgrp = &pgrp0;
        p->p_pgrp = &pgrp0;

-       pgrphash[0] = &pgrp0;
-       pgrp0.pg_mem = p;
+       LIST_INSERT_HEAD(PGRPHASH(0), &pgrp0, pg_hash);
+       LIST_INIT(&pgrp0.pg_members);
+       LIST_INSERT_HEAD(&pgrp0.pg_members, p, p_pglist);
+

        pgrp0.pg_session = &session0;
        session0.s_count = 1;
        session0.s_leader = p;
 
        pgrp0.pg_session = &session0;
        session0.s_count = 1;
        session0.s_leader = p;
 

-       p->p_flag = SLOAD|SSYS;
+       p->p_flag = P_INMEM | P_SYSTEM;

        p->p_stat = SRUN;
        p->p_nice = NZERO;
        bcopy("swapper", p->p_comm, sizeof ("swapper"));
 
        p->p_stat = SRUN;
        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 */
 
        cred0.p_refcnt = 1;
        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;


@@ -128,20 +141,20 @@ main()
        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);


@@ -151,53 +164,46 @@ main()
        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 = &p->p_addr->u_stats;
        p->p_sigacts = &p->p_addr->u_sigacts;
 
         */
        p->p_stats = &p->p_addr->u_stats;
        p->p_sigacts = &p->p_addr->u_sigacts;
 

-       rqinit();
-

        /*
        /*

-        * configure virtual memory system,
-        * set vm rlimits
+        * Charge root for one process.

         */
         */

+       (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 and rootdev.
-        */
+       /* Initialize the file systems. */

        vfsinit();
        vfsinit();

-       if (bdevvp(swapdev, &swapdev_vp) || bdevvp(rootdev, &rootvp))
-               panic("can't setup bdevvp's");

 
 

-       /*
-        * Start real time and statistics clocks.
-        */
+       /* Start real time and statistics clocks. */

        initclocks();
 
        initclocks();
 

-       /*
-        * Initialize tables, protocols, and set up well-known inodes.
-        */
+       /* 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();


@@ -205,89 +211,48 @@ main()
        splx(s);
 
 #ifdef GPROF
        splx(s);
 
 #ifdef GPROF

+       /* Initialize kernel profiling. */

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

-       /* kick off timeout driven events by calling first time */
+       /* Kick off timeout driven events by calling first time. */

        roundrobin(NULL);
        schedcpu(NULL);
 
        roundrobin(NULL);
        schedcpu(NULL);
 

-       /*
-        * Set up the root file system and vnode.
-        */
-       if ((*mountroot)())
+       /* Mount the root file system. */
+       if (vfs_mountroot())

                panic("cannot mount root");
                panic("cannot mount root");

-       /*
-        * Get vnode for '/'.
-        * Setup rootdir and fdp->fd_fd.fd_cdir to point to it.
-        */
-       if (VFS_ROOT(rootfs, &rootdir))
+       mountlist.cqh_first->mnt_flag |= MNT_ROOTFS;
+
+       /* Get the vnode for '/'.  Set fdp->fd_fd.fd_cdir to reference it. */
+       if (VFS_ROOT(mountlist.cqh_first, &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, 0, p);

        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 mi_switch() after the time got set.

         */
         */

-       runtime = mono_time = boottime = time;
-       p->p_stats->p_start = p->p_rtime = runtime;
+       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);

+
+       /* Create process 1 (init(8)). */

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

-               extern int icode[];             /* user init code */
-               extern int szicode;             /* size of icode */
-               static char initflags[] = "-sf";
-               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.
-                */
-               ip = initflags + 1;
-               if (boothowto&RB_SINGLE)
-                       *ip++ = 's';
-#ifdef notyet
-               if (boothowto&RB_FASTBOOT)
-                       *ip++ = 'f';
-#endif
-               if (ip == initflags + 1)
-                       *ip++ = '-';
-               *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 ||
-                   addr != VM_MIN_ADDRESS)
-                       panic("init: couldn't allocate at zero");
-
-               /* need just enough stack to exec from */
-               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;
-               (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 */
+               start_init(curproc, framep);
+               return;

        }
 
        }
 

-       /*
-        * Start up pageout daemon (process 2).
-        */
+       /* Create process 2 (the pageout daemon). */

        if (fork(p, NULL, rval))
                panic("fork pager");
        if (rval[1]) {
        if (fork(p, NULL, rval))
                panic("fork pager");
        if (rval[1]) {


@@ -296,14 +261,125 @@ main()
                 */
                p = curproc;
                pageproc = p;
                 */
                p = curproc;
                pageproc = p;

-               p->p_flag |= SLOAD|SSYS;                /* XXX */
+               p->p_flag |= P_INMEM | P_SYSTEM;        /* XXX */

                bcopy("pagedaemon", curproc->p_comm, sizeof ("pagedaemon"));
                vm_pageout();
                bcopy("pagedaemon", curproc->p_comm, sizeof ("pagedaemon"));
                vm_pageout();

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

        }
 
        }
 

+       /* The scheduler is an infinite loop. */
+       scheduler();
+       /* NOTREACHED */
+}
+
+/*
+ * List of paths to try when searching for "init".
+ */
+static char *initpaths[] = {
+       "/sbin/init",
+       "/sbin/oinit",
+       "/sbin/init.bak",
+       NULL,
+};
+
+/*
+ * Start the initial user process; try exec'ing each pathname in "initpaths".
+ * The program is invoked with one argument containing the boot flags.
+ */
+static void
+start_init(p, framep)
+       struct proc *p;
+       void *framep;
+{
+       vm_offset_t addr;
+       struct execve_args /* {
+               syscallarg(char *) path;
+               syscallarg(char **) argp;
+               syscallarg(char **) envp;
+       } */ args;
+       int options, i, error;
+       register_t retval[2];
+       char flags[4] = "-", *flagsp;
+       char **pathp, *path, *ucp, **uap, *arg0, *arg1;
+
+       initproc = p;
+
+       /*
+        * We need to set the system call frame as if we were entered through
+        * a syscall() so that when we call execve() below, it will be able
+        * to set the entry point (see setregs) when it tries to exec.  The
+        * startup code in "locore.s" has allocated space for the frame and
+        * passed a pointer to that space as main's argument.
+        */
+       cpu_set_init_frame(p, framep);
+

        /*
        /*

-        * enter scheduling loop
+        * Need just enough stack to hold the faked-up "execve()" arguments.

         */
         */

-       sched();
+       addr = trunc_page(VM_MAX_ADDRESS - PAGE_SIZE);
+       if (vm_allocate(&p->p_vmspace->vm_map, &addr, PAGE_SIZE, FALSE) != 0)
+               panic("init: couldn't allocate argument space");
+       p->p_vmspace->vm_maxsaddr = (caddr_t)addr;
+
+       for (pathp = &initpaths[0]; (path = *pathp) != NULL; pathp++) {
+               /*
+                * Construct the boot flag argument.
+                */
+               options = 0;
+               flagsp = flags + 1;
+               ucp = (char *)USRSTACK;
+               if (boothowto & RB_SINGLE) {
+                       *flagsp++ = 's';
+                       options = 1;
+               }
+#ifdef notyet
+                if (boothowto & RB_FASTBOOT) {
+                       *flagsp++ = 'f';
+                       options = 1;
+               }
+#endif
+               /*
+                * Move out the flags (arg 1), if necessary.
+                */
+               if (options != 0) {
+                       *flagsp++ = '\0';
+                       i = flagsp - flags;
+                       (void)copyout((caddr_t)flags, (caddr_t)(ucp -= i), i);
+                       arg1 = ucp;
+               }
+
+               /*
+                * Move out the file name (also arg 0).
+                */
+               i = strlen(path) + 1;
+               (void)copyout((caddr_t)path, (caddr_t)(ucp -= i), i);
+               arg0 = ucp;
+
+               /*
+                * Move out the arg pointers.
+                */
+               uap = (char **)((long)ucp & ~ALIGNBYTES);
+               (void)suword((caddr_t)--uap, 0);        /* terminator */
+               if (options != 0)
+                       (void)suword((caddr_t)--uap, (long)arg1);
+               (void)suword((caddr_t)--uap, (long)arg0);
+
+               /*
+                * Point at the arguments.
+                */
+               SCARG(&args, path) = arg0;
+               SCARG(&args, argp) = uap;
+               SCARG(&args, envp) = NULL;
+
+               /*
+                * Now try to exec the program.  If can't for any reason
+                * other than it doesn't exist, complain.
+                */
+               if ((error = execve(p, &args, retval)) == 0)
+                       return;
+               if (error != ENOENT)
+                       printf("exec %s: error %d\n", path, error);
+       }
+       printf("init: not found\n");
+       panic("no init");

 }
 }