1994-05-24 10:09:53 +00:00
|
|
|
/*
|
1995-08-28 09:19:25 +00:00
|
|
|
* Copyright (c) 1995 Terrence R. Lambert
|
|
|
|
* All rights reserved.
|
|
|
|
*
|
1994-05-24 10:09:53 +00:00
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
|
|
* must display the following acknowledgement:
|
|
|
|
* This product includes software developed by the University of
|
|
|
|
* California, Berkeley and its contributors.
|
|
|
|
* 4. Neither the name of the University nor the names of its contributors
|
|
|
|
* may be used to endorse or promote products derived from this software
|
|
|
|
* without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
*
|
|
|
|
* @(#)init_main.c 8.9 (Berkeley) 1/21/94
|
1999-05-03 23:57:32 +00:00
|
|
|
* $Id: init_main.c,v 1.116 1999/04/29 22:51:59 dt Exp $
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
|
1996-10-28 11:34:57 +00:00
|
|
|
#include "opt_devfs.h"
|
1996-03-02 18:24:13 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/param.h>
|
1997-01-27 12:43:36 +00:00
|
|
|
#include <sys/file.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/filedesc.h>
|
|
|
|
#include <sys/kernel.h>
|
1997-01-16 15:58:32 +00:00
|
|
|
#include <sys/mount.h>
|
1995-12-04 16:48:58 +00:00
|
|
|
#include <sys/sysctl.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/proc.h>
|
|
|
|
#include <sys/resourcevar.h>
|
|
|
|
#include <sys/signalvar.h>
|
|
|
|
#include <sys/systm.h>
|
|
|
|
#include <sys/vnode.h>
|
1994-08-24 11:52:21 +00:00
|
|
|
#include <sys/sysent.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/reboot.h>
|
1995-10-08 00:06:22 +00:00
|
|
|
#include <sys/sysproto.h>
|
1995-12-07 12:48:31 +00:00
|
|
|
#include <sys/vmmeter.h>
|
1997-12-12 04:00:59 +00:00
|
|
|
#include <sys/unistd.h>
|
1998-10-09 23:42:47 +00:00
|
|
|
#include <sys/malloc.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
#include <machine/cpu.h>
|
|
|
|
|
|
|
|
#include <vm/vm.h>
|
1995-12-07 12:48:31 +00:00
|
|
|
#include <vm/vm_param.h>
|
|
|
|
#include <vm/vm_prot.h>
|
1997-02-10 02:22:35 +00:00
|
|
|
#include <sys/lock.h>
|
1995-12-07 12:48:31 +00:00
|
|
|
#include <vm/pmap.h>
|
|
|
|
#include <vm/vm_map.h>
|
|
|
|
#include <sys/user.h>
|
1997-03-01 17:49:09 +00:00
|
|
|
#include <sys/copyright.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1995-08-29 23:59:22 +00:00
|
|
|
extern struct linker_set sysinit_set; /* XXX */
|
|
|
|
|
|
|
|
extern void __main __P((void));
|
|
|
|
extern void main __P((void *framep));
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/* Components of the first process -- never freed. */
|
1995-12-10 13:45:30 +00:00
|
|
|
static struct session session0;
|
|
|
|
static struct pgrp pgrp0;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct proc proc0;
|
1995-12-10 13:45:30 +00:00
|
|
|
static struct pcred cred0;
|
1998-12-19 02:55:34 +00:00
|
|
|
static struct procsig procsig0;
|
1995-12-10 13:45:30 +00:00
|
|
|
static struct filedesc0 filedesc0;
|
|
|
|
static struct plimit limit0;
|
|
|
|
static struct vmspace vmspace0;
|
1995-08-28 09:19:25 +00:00
|
|
|
struct proc *initproc;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1996-02-23 19:44:10 +00:00
|
|
|
int cmask = CMASK;
|
1994-05-24 10:09:53 +00:00
|
|
|
extern struct user *proc0paddr;
|
|
|
|
|
1995-05-19 03:27:08 +00:00
|
|
|
struct vnode *rootvp;
|
1997-11-24 18:35:04 +00:00
|
|
|
int boothowto = 0; /* initialized so that it can be patched */
|
1995-12-04 16:48:58 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
struct timeval boottime;
|
1999-05-03 23:57:32 +00:00
|
|
|
SYSCTL_STRUCT(_kern, KERN_BOOTTIME, boottime, CTLFLAG_RD,
|
|
|
|
&boottime, timeval, "System boottime");
|
1995-12-04 16:48:58 +00:00
|
|
|
|
1995-08-28 09:19:25 +00:00
|
|
|
/*
|
|
|
|
* Promiscuous argument pass for start_init()
|
|
|
|
*
|
|
|
|
* This is a kludge because we use a return from main() rather than a call
|
1996-12-17 00:46:07 +00:00
|
|
|
* to a new routine in locore.s to kick the kernel alive from locore.s.
|
1995-08-28 09:19:25 +00:00
|
|
|
*/
|
|
|
|
static void *init_framep;
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1994-05-25 09:21:21 +00:00
|
|
|
#if __GNUC__ >= 2
|
|
|
|
void __main() {}
|
|
|
|
#endif
|
|
|
|
|
1995-08-28 09:19:25 +00:00
|
|
|
|
1994-05-25 09:21:21 +00:00
|
|
|
/*
|
1995-08-28 09:19:25 +00:00
|
|
|
* This ensures that there is at least one entry so that the sysinit_set
|
|
|
|
* symbol is not undefined. A sybsystem ID of SI_SUB_DUMMY is never
|
|
|
|
* executed.
|
1994-05-25 09:21:21 +00:00
|
|
|
*/
|
1995-08-28 09:19:25 +00:00
|
|
|
SYSINIT(placeholder, SI_SUB_DUMMY,SI_ORDER_ANY, NULL, NULL)
|
1994-08-27 16:14:39 +00:00
|
|
|
|
1998-10-09 23:42:47 +00:00
|
|
|
/*
|
|
|
|
* The sysinit table itself. Items are checked off as the are run.
|
|
|
|
* If we want to register new sysinit types, add them to newsysinit.
|
|
|
|
*/
|
|
|
|
struct sysinit **sysinit = (struct sysinit **)sysinit_set.ls_items;
|
|
|
|
struct sysinit **newsysinit;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Merge a new sysinit set into the current set, reallocating it if
|
|
|
|
* necessary. This can only be called after malloc is running.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
sysinit_add(set)
|
|
|
|
struct sysinit **set;
|
|
|
|
{
|
|
|
|
struct sysinit **newset;
|
|
|
|
struct sysinit **sipp;
|
|
|
|
struct sysinit **xipp;
|
|
|
|
int count = 0;
|
|
|
|
|
|
|
|
if (newsysinit)
|
1998-10-15 17:09:19 +00:00
|
|
|
for (sipp = newsysinit; *sipp; sipp++)
|
1998-10-09 23:42:47 +00:00
|
|
|
count++;
|
1998-10-15 17:09:19 +00:00
|
|
|
else
|
|
|
|
for (sipp = sysinit; *sipp; sipp++)
|
|
|
|
count++;
|
|
|
|
for (sipp = set; *sipp; sipp++)
|
|
|
|
count++;
|
|
|
|
count++; /* Trailing NULL */
|
1998-10-09 23:42:47 +00:00
|
|
|
newset = malloc(count * sizeof(*sipp), M_TEMP, M_NOWAIT);
|
|
|
|
if (newset == NULL)
|
|
|
|
panic("cannot malloc for sysinit");
|
|
|
|
xipp = newset;
|
1998-10-15 17:09:19 +00:00
|
|
|
if (newsysinit)
|
1998-10-09 23:42:47 +00:00
|
|
|
for (sipp = newsysinit; *sipp; sipp++)
|
|
|
|
*xipp++ = *sipp;
|
1998-10-15 17:09:19 +00:00
|
|
|
else
|
|
|
|
for (sipp = sysinit; *sipp; sipp++)
|
|
|
|
*xipp++ = *sipp;
|
|
|
|
for (sipp = set; *sipp; sipp++)
|
|
|
|
*xipp++ = *sipp;
|
|
|
|
*xipp = NULL;
|
|
|
|
if (newsysinit)
|
|
|
|
free(newsysinit, M_TEMP);
|
1998-10-09 23:42:47 +00:00
|
|
|
newsysinit = newset;
|
|
|
|
}
|
1994-05-25 09:21:21 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* 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.
|
1995-08-28 09:19:25 +00:00
|
|
|
*
|
|
|
|
* This allows simple addition of new kernel subsystems that require
|
|
|
|
* boot time initialization. It also allows substitution of subsystem
|
|
|
|
* (for instance, a scheduler, kernel profiler, or VM system) by object
|
1998-01-30 11:34:06 +00:00
|
|
|
* module. Finally, it allows for optional "kernel threads".
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1994-05-25 09:21:21 +00:00
|
|
|
void
|
1994-05-24 10:09:53 +00:00
|
|
|
main(framep)
|
|
|
|
void *framep;
|
|
|
|
{
|
1995-08-28 09:19:25 +00:00
|
|
|
|
|
|
|
register struct sysinit **sipp; /* system initialization*/
|
|
|
|
register struct sysinit **xipp; /* interior loop of sort*/
|
|
|
|
register struct sysinit *save; /* bubble*/
|
|
|
|
|
|
|
|
/*
|
1997-04-07 07:16:06 +00:00
|
|
|
* Copy the locore.s frame pointer for proc0, this is forked into
|
|
|
|
* all other processes.
|
1995-08-28 09:19:25 +00:00
|
|
|
*/
|
|
|
|
init_framep = framep;
|
|
|
|
|
1998-10-09 23:42:47 +00:00
|
|
|
restart:
|
1995-08-28 09:19:25 +00:00
|
|
|
/*
|
|
|
|
* Perform a bubble sort of the system initialization objects by
|
|
|
|
* their subsystem (primary key) and order (secondary key).
|
|
|
|
*/
|
1998-10-09 23:42:47 +00:00
|
|
|
for (sipp = sysinit; *sipp; sipp++) {
|
|
|
|
for (xipp = sipp + 1; *xipp; xipp++) {
|
|
|
|
if ((*sipp)->subsystem < (*xipp)->subsystem ||
|
|
|
|
((*sipp)->subsystem == (*xipp)->subsystem &&
|
1995-08-28 09:19:25 +00:00
|
|
|
(*sipp)->order < (*xipp)->order))
|
|
|
|
continue; /* skip*/
|
|
|
|
save = *sipp;
|
|
|
|
*sipp = *xipp;
|
|
|
|
*xipp = save;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Traverse the (now) ordered list of system initialization tasks.
|
|
|
|
* Perform each task, and continue on to the next task.
|
|
|
|
*
|
|
|
|
* The last item on the list is expected to be the scheduler,
|
|
|
|
* which will not return.
|
|
|
|
*/
|
1998-10-09 23:42:47 +00:00
|
|
|
for (sipp = sysinit; *sipp; sipp++) {
|
1997-12-12 04:00:59 +00:00
|
|
|
|
1998-10-09 23:42:47 +00:00
|
|
|
if ((*sipp)->subsystem == SI_SUB_DUMMY)
|
1995-08-28 09:19:25 +00:00
|
|
|
continue; /* skip dummy task(s)*/
|
|
|
|
|
1998-10-09 23:42:47 +00:00
|
|
|
if ((*sipp)->subsystem == SI_SUB_DONE)
|
|
|
|
continue;
|
|
|
|
|
1995-08-28 09:19:25 +00:00
|
|
|
switch( (*sipp)->type) {
|
|
|
|
case SI_TYPE_DEFAULT:
|
|
|
|
/* no special processing*/
|
1998-10-09 23:42:47 +00:00
|
|
|
(*((*sipp)->func))((*sipp)->udata);
|
1995-08-28 09:19:25 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SI_TYPE_KTHREAD:
|
|
|
|
/* kernel thread*/
|
1997-12-12 04:00:59 +00:00
|
|
|
if (fork1(&proc0, RFMEM|RFFDG|RFPROC))
|
|
|
|
panic("fork kernel thread");
|
|
|
|
cpu_set_fork_handler(pfind(proc0.p_retval[0]),
|
|
|
|
(*sipp)->func, (*sipp)->udata);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SI_TYPE_KPROCESS:
|
|
|
|
if (fork1(&proc0, RFFDG|RFPROC))
|
1995-08-28 09:19:25 +00:00
|
|
|
panic("fork kernel process");
|
1997-11-06 19:29:57 +00:00
|
|
|
cpu_set_fork_handler(pfind(proc0.p_retval[0]),
|
|
|
|
(*sipp)->func, (*sipp)->udata);
|
1995-08-28 09:19:25 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
1998-10-09 23:42:47 +00:00
|
|
|
panic("init_main: unrecognized init type");
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Check off the one we're just done */
|
|
|
|
(*sipp)->subsystem = SI_SUB_DONE;
|
|
|
|
|
|
|
|
/* Check if we've installed more sysinit items via KLD */
|
|
|
|
if (newsysinit != NULL) {
|
|
|
|
if (sysinit != (struct sysinit **)sysinit_set.ls_items)
|
|
|
|
free(sysinit, M_TEMP);
|
|
|
|
sysinit = newsysinit;
|
|
|
|
newsysinit = NULL;
|
|
|
|
goto restart;
|
1995-08-28 09:19:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1997-04-26 11:46:25 +00:00
|
|
|
panic("Shouldn't get here!");
|
1995-08-28 09:19:25 +00:00
|
|
|
/* NOTREACHED*/
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Start a kernel process. This is called after a fork() call in
|
|
|
|
* main() in the file kern/init_main.c.
|
|
|
|
*
|
|
|
|
* This function is used to start "internal" daemons.
|
|
|
|
*/
|
|
|
|
/* ARGSUSED*/
|
|
|
|
void
|
1995-09-09 18:10:37 +00:00
|
|
|
kproc_start(udata)
|
1999-01-29 23:18:50 +00:00
|
|
|
const void *udata;
|
1995-08-28 09:19:25 +00:00
|
|
|
{
|
1999-01-29 23:18:50 +00:00
|
|
|
const struct kproc_desc *kp = udata;
|
1995-08-28 09:19:25 +00:00
|
|
|
struct proc *p = curproc;
|
|
|
|
|
1997-04-26 11:46:25 +00:00
|
|
|
#ifdef DIAGNOSTIC
|
|
|
|
printf("Start pid=%d <%s>\n",p->p_pid, kp->arg0);
|
|
|
|
#endif
|
|
|
|
|
1995-08-28 09:19:25 +00:00
|
|
|
/* save a global descriptor, if desired*/
|
|
|
|
if( kp->global_procpp != NULL)
|
|
|
|
*kp->global_procpp = p;
|
|
|
|
|
|
|
|
/* this is a non-swapped system process*/
|
|
|
|
p->p_flag |= P_INMEM | P_SYSTEM;
|
|
|
|
|
|
|
|
/* set up arg0 for 'ps', et al*/
|
|
|
|
strcpy( p->p_comm, kp->arg0);
|
|
|
|
|
|
|
|
/* call the processes' main()...*/
|
|
|
|
(*kp->func)();
|
|
|
|
|
|
|
|
/* NOTREACHED */
|
1995-12-02 17:11:20 +00:00
|
|
|
panic("kproc_start: %s", kp->arg0);
|
1995-08-28 09:19:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
***************************************************************************
|
|
|
|
****
|
|
|
|
**** The following SYSINIT's belong elsewhere, but have not yet
|
|
|
|
**** been moved.
|
|
|
|
****
|
|
|
|
***************************************************************************
|
|
|
|
*/
|
|
|
|
#ifdef OMIT
|
|
|
|
/*
|
|
|
|
* Handled by vfs_mountroot (bad idea) at this time... should be
|
|
|
|
* done the same as 4.4Lite2.
|
|
|
|
*/
|
|
|
|
SYSINIT(swapinit, SI_SUB_SWAP, SI_ORDER_FIRST, swapinit, NULL)
|
|
|
|
#endif /* OMIT*/
|
|
|
|
|
1995-09-09 18:10:37 +00:00
|
|
|
static void print_caddr_t __P((void *data));
|
1995-08-29 23:59:22 +00:00
|
|
|
static void
|
|
|
|
print_caddr_t(data)
|
1995-09-09 18:10:37 +00:00
|
|
|
void *data;
|
1995-08-29 23:59:22 +00:00
|
|
|
{
|
|
|
|
printf("%s", (char *)data);
|
|
|
|
}
|
1995-12-02 17:11:20 +00:00
|
|
|
SYSINIT(announce, SI_SUB_COPYRIGHT, SI_ORDER_FIRST, print_caddr_t, copyright)
|
1995-08-28 09:19:25 +00:00
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
***************************************************************************
|
|
|
|
****
|
|
|
|
**** The two following SYSINT's are proc0 specific glue code. I am not
|
|
|
|
**** convinced that they can not be safely combined, but their order of
|
|
|
|
**** operation has been maintained as the same as the original init_main.c
|
|
|
|
**** for right now.
|
|
|
|
****
|
|
|
|
**** These probably belong in init_proc.c or kern_proc.c, since they
|
|
|
|
**** deal with proc0 (the fork template process).
|
|
|
|
****
|
|
|
|
***************************************************************************
|
|
|
|
*/
|
|
|
|
/* ARGSUSED*/
|
1995-12-10 13:45:30 +00:00
|
|
|
static void proc0_init __P((void *dummy));
|
|
|
|
static void
|
1995-12-02 17:11:20 +00:00
|
|
|
proc0_init(dummy)
|
|
|
|
void *dummy;
|
1995-08-28 09:19:25 +00:00
|
|
|
{
|
|
|
|
register struct proc *p;
|
|
|
|
register struct filedesc0 *fdp;
|
1996-10-20 21:01:46 +00:00
|
|
|
register unsigned i;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
p = &proc0;
|
|
|
|
|
1996-03-11 06:14:38 +00:00
|
|
|
/*
|
|
|
|
* Initialize process and pgrp structures.
|
|
|
|
*/
|
|
|
|
procinit();
|
|
|
|
|
1996-07-31 09:26:54 +00:00
|
|
|
/*
|
|
|
|
* Initialize sleep queue hash table
|
|
|
|
*/
|
|
|
|
sleepinit();
|
|
|
|
|
1997-08-05 00:02:08 +00:00
|
|
|
/*
|
|
|
|
* additional VM structures
|
|
|
|
*/
|
|
|
|
vm_init2();
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Create process 0 (the swapper).
|
|
|
|
*/
|
1996-03-11 06:14:38 +00:00
|
|
|
LIST_INSERT_HEAD(&allproc, p, p_list);
|
1994-05-24 10:09:53 +00:00
|
|
|
p->p_pgrp = &pgrp0;
|
1996-03-11 06:14:38 +00:00
|
|
|
LIST_INSERT_HEAD(PGRPHASH(0), &pgrp0, pg_hash);
|
|
|
|
LIST_INIT(&pgrp0.pg_members);
|
|
|
|
LIST_INSERT_HEAD(&pgrp0.pg_members, p, p_pglist);
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
pgrp0.pg_session = &session0;
|
|
|
|
session0.s_count = 1;
|
|
|
|
session0.s_leader = p;
|
|
|
|
|
1994-08-24 11:52:21 +00:00
|
|
|
p->p_sysent = &aout_sysvec;
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
p->p_flag = P_INMEM | P_SYSTEM;
|
|
|
|
p->p_stat = SRUN;
|
|
|
|
p->p_nice = NZERO;
|
1994-10-02 04:48:21 +00:00
|
|
|
p->p_rtprio.type = RTP_PRIO_NORMAL;
|
|
|
|
p->p_rtprio.prio = 0;
|
1994-09-01 11:20:11 +00:00
|
|
|
|
1997-06-16 00:29:36 +00:00
|
|
|
/*
|
|
|
|
* Link for kernel based threads
|
|
|
|
*/
|
|
|
|
p->p_peers = 0;
|
|
|
|
p->p_leader = p;
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
bcopy("swapper", p->p_comm, sizeof ("swapper"));
|
|
|
|
|
|
|
|
/* Create credentials. */
|
|
|
|
cred0.p_refcnt = 1;
|
|
|
|
p->p_cred = &cred0;
|
|
|
|
p->p_ucred = crget();
|
|
|
|
p->p_ucred->cr_ngroups = 1; /* group 0 */
|
|
|
|
|
This Implements the mumbled about "Jail" feature.
This is a seriously beefed up chroot kind of thing. The process
is jailed along the same lines as a chroot does it, but with
additional tough restrictions imposed on what the superuser can do.
For all I know, it is safe to hand over the root bit inside a
prison to the customer living in that prison, this is what
it was developed for in fact: "real virtual servers".
Each prison has an ip number associated with it, which all IP
communications will be coerced to use and each prison has its own
hostname.
Needless to say, you need more RAM this way, but the advantage is
that each customer can run their own particular version of apache
and not stomp on the toes of their neighbors.
It generally does what one would expect, but setting up a jail
still takes a little knowledge.
A few notes:
I have no scripts for setting up a jail, don't ask me for them.
The IP number should be an alias on one of the interfaces.
mount a /proc in each jail, it will make ps more useable.
/proc/<pid>/status tells the hostname of the prison for
jailed processes.
Quotas are only sensible if you have a mountpoint per prison.
There are no privisions for stopping resource-hogging.
Some "#ifdef INET" and similar may be missing (send patches!)
If somebody wants to take it from here and develop it into
more of a "virtual machine" they should be most welcome!
Tools, comments, patches & documentation most welcome.
Have fun...
Sponsored by: http://www.rndassociates.com/
Run for almost a year by: http://www.servetheweb.com/
1999-04-28 11:38:52 +00:00
|
|
|
/* Don't jail it */
|
|
|
|
p->p_prison = 0;
|
|
|
|
|
1998-12-19 02:55:34 +00:00
|
|
|
/* Create procsig. */
|
|
|
|
p->p_procsig = &procsig0;
|
1999-02-17 21:03:14 +00:00
|
|
|
p->p_procsig->ps_refcnt = 1;
|
1998-12-19 02:55:34 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/* Create the file descriptor table. */
|
|
|
|
fdp = &filedesc0;
|
|
|
|
p->p_fd = &fdp->fd_fd;
|
|
|
|
fdp->fd_fd.fd_refcnt = 1;
|
|
|
|
fdp->fd_fd.fd_cmask = cmask;
|
|
|
|
fdp->fd_fd.fd_ofiles = fdp->fd_dfiles;
|
|
|
|
fdp->fd_fd.fd_ofileflags = fdp->fd_dfileflags;
|
|
|
|
fdp->fd_fd.fd_nfiles = NDFILE;
|
|
|
|
|
|
|
|
/* 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;
|
1997-01-27 12:43:36 +00:00
|
|
|
limit0.pl_rlimit[RLIMIT_NOFILE].rlim_cur =
|
|
|
|
limit0.pl_rlimit[RLIMIT_NOFILE].rlim_max = maxfiles;
|
|
|
|
limit0.pl_rlimit[RLIMIT_NPROC].rlim_cur =
|
|
|
|
limit0.pl_rlimit[RLIMIT_NPROC].rlim_max = maxproc;
|
1994-05-24 10:09:53 +00:00
|
|
|
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;
|
1998-05-28 09:30:28 +00:00
|
|
|
limit0.p_cpulimit = RLIM_INFINITY;
|
1994-05-24 10:09:53 +00:00
|
|
|
limit0.p_refcnt = 1;
|
|
|
|
|
1998-05-28 09:30:28 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/* Allocate a prototype map so we have something to fork. */
|
1999-02-19 14:25:37 +00:00
|
|
|
pmap_pinit0(vmspace_pmap(&vmspace0));
|
1994-05-24 10:09:53 +00:00
|
|
|
p->p_vmspace = &vmspace0;
|
|
|
|
vmspace0.vm_refcnt = 1;
|
1994-05-25 09:21:21 +00:00
|
|
|
vm_map_init(&vmspace0.vm_map, round_page(VM_MIN_ADDRESS),
|
VM level code cleanups.
1) Start using TSM.
Struct procs continue to point to upages structure, after being freed.
Struct vmspace continues to point to pte object and kva space for kstack.
u_map is now superfluous.
2) vm_map's don't need to be reference counted. They always exist either
in the kernel or in a vmspace. The vmspaces are managed by reference
counts.
3) Remove the "wired" vm_map nonsense.
4) No need to keep a cache of kernel stack kva's.
5) Get rid of strange looking ++var, and change to var++.
6) Change more data structures to use our "zone" allocator. Added
struct proc, struct vmspace and struct vnode. This saves a significant
amount of kva space and physical memory. Additionally, this enables
TSM for the zone managed memory.
7) Keep ioopt disabled for now.
8) Remove the now bogus "single use" map concept.
9) Use generation counts or id's for data structures residing in TSM, where
it allows us to avoid unneeded restart overhead during traversals, where
blocking might occur.
10) Account better for memory deficits, so the pageout daemon will be able
to make enough memory available (experimental.)
11) Fix some vnode locking problems. (From Tor, I think.)
12) Add a check in ufs_lookup, to avoid lots of unneeded calls to bcmp.
(experimental.)
13) Significantly shrink, cleanup, and make slightly faster the vm_fault.c
code. Use generation counts, get rid of unneded collpase operations,
and clean up the cluster code.
14) Make vm_zone more suitable for TSM.
This commit is partially as a result of discussions and contributions from
other people, including DG, Tor Egge, PHK, and probably others that I
have forgotten to attribute (so let me know, if I forgot.)
This is not the infamous, final cleanup of the vnode stuff, but a necessary
step. Vnode mgmt should be correct, but things might still change, and
there is still some missing stuff (like ioopt, and physical backing of
non-merged cache files, debugging of layering concepts.)
1998-01-22 17:30:44 +00:00
|
|
|
trunc_page(VM_MAXUSER_ADDRESS));
|
1999-02-19 14:25:37 +00:00
|
|
|
vmspace0.vm_map.pmap = vmspace_pmap(&vmspace0);
|
1994-05-24 10:09:53 +00:00
|
|
|
p->p_addr = proc0paddr; /* XXX */
|
|
|
|
|
1998-06-07 17:13:14 +00:00
|
|
|
#ifndef __alpha__ /* XXX what is this? */
|
1995-08-28 09:19:25 +00:00
|
|
|
#define INCOMPAT_LITES2
|
|
|
|
#ifdef INCOMPAT_LITES2
|
1995-05-04 08:21:24 +00:00
|
|
|
/*
|
1998-04-17 22:37:19 +00:00
|
|
|
* proc0 needs to have a coherent frame base in its stack.
|
1995-05-04 08:21:24 +00:00
|
|
|
*/
|
1995-08-28 09:19:25 +00:00
|
|
|
cpu_set_init_frame(p, init_framep); /* XXX! */
|
|
|
|
#endif /* INCOMPAT_LITES2*/
|
1998-06-07 17:13:14 +00:00
|
|
|
#endif
|
1995-05-04 08:21:24 +00:00
|
|
|
|
1998-12-19 08:23:31 +00:00
|
|
|
/*
|
1994-05-24 10:09:53 +00:00
|
|
|
* 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;
|
|
|
|
|
|
|
|
/*
|
1996-03-11 06:14:38 +00:00
|
|
|
* Charge root for one process.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
(void)chgproccnt(0, 1);
|
1997-12-06 04:11:14 +00:00
|
|
|
|
|
|
|
/*
|
1999-04-29 22:51:59 +00:00
|
|
|
* Initialize the current process pointer (curproc) before
|
|
|
|
* any possible traps/probes to simplify trap processing.
|
1997-12-06 04:11:14 +00:00
|
|
|
*/
|
1999-04-29 22:51:59 +00:00
|
|
|
SET_CURPROC(p);
|
1997-12-06 04:11:14 +00:00
|
|
|
|
1995-08-28 09:19:25 +00:00
|
|
|
}
|
|
|
|
SYSINIT(p0init, SI_SUB_INTRINSIC, SI_ORDER_FIRST, proc0_init, NULL)
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1995-08-28 09:19:25 +00:00
|
|
|
/* ARGSUSED*/
|
1995-12-10 13:45:30 +00:00
|
|
|
static void proc0_post __P((void *dummy));
|
|
|
|
static void
|
1995-12-02 17:11:20 +00:00
|
|
|
proc0_post(dummy)
|
|
|
|
void *dummy;
|
1995-08-28 09:19:25 +00:00
|
|
|
{
|
1998-04-04 13:26:20 +00:00
|
|
|
struct timespec ts;
|
1996-09-23 04:37:54 +00:00
|
|
|
|
1994-05-25 09:21:21 +00:00
|
|
|
/*
|
1999-02-25 11:03:08 +00:00
|
|
|
* Now we can look at the time, having had a chance to verify the
|
|
|
|
* time from the file system. Pretend that proc0 started now.
|
1994-05-25 09:21:21 +00:00
|
|
|
*/
|
1998-04-08 09:01:53 +00:00
|
|
|
microtime(&proc0.p_stats->p_start);
|
1998-05-28 09:30:28 +00:00
|
|
|
proc0.p_runtime = 0;
|
1999-02-28 10:53:29 +00:00
|
|
|
microuptime(&switchtime);
|
1999-02-25 11:03:08 +00:00
|
|
|
switchticks = ticks;
|
1995-08-28 09:19:25 +00:00
|
|
|
|
1996-09-23 04:37:54 +00:00
|
|
|
/*
|
|
|
|
* Give the ``random'' number generator a thump.
|
1998-04-08 09:01:53 +00:00
|
|
|
* XXX: Does read_random() contain enough bits to be used here ?
|
1996-09-23 04:37:54 +00:00
|
|
|
*/
|
1998-04-04 13:26:20 +00:00
|
|
|
nanotime(&ts);
|
|
|
|
srandom(ts.tv_sec ^ ts.tv_nsec);
|
1996-09-23 04:37:54 +00:00
|
|
|
|
1995-08-28 09:19:25 +00:00
|
|
|
/* Initialize signal state for process 0. */
|
|
|
|
siginit(&proc0);
|
|
|
|
}
|
|
|
|
SYSINIT(p0post, SI_SUB_INTRINSIC_POST, SI_ORDER_FIRST, proc0_post, NULL)
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
1995-08-28 09:19:25 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
***************************************************************************
|
|
|
|
****
|
|
|
|
**** The following SYSINIT's and glue code should be moved to the
|
|
|
|
**** respective files on a per subsystem basis.
|
|
|
|
****
|
|
|
|
***************************************************************************
|
|
|
|
*/
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1997-09-21 22:00:25 +00:00
|
|
|
/* ARGSUSED */
|
|
|
|
static void root_conf __P((void *dummy));
|
|
|
|
static void
|
|
|
|
root_conf(dummy)
|
|
|
|
void *dummy;
|
|
|
|
{
|
|
|
|
cpu_rootconf();
|
|
|
|
}
|
|
|
|
SYSINIT(root_conf, SI_SUB_ROOT_CONF, SI_ORDER_FIRST, root_conf, NULL)
|
|
|
|
|
1995-08-28 09:19:25 +00:00
|
|
|
/* ARGSUSED*/
|
1995-12-10 13:45:30 +00:00
|
|
|
static void xxx_vfs_root_fdtab __P((void *dummy));
|
|
|
|
static void
|
1995-12-02 17:11:20 +00:00
|
|
|
xxx_vfs_root_fdtab(dummy)
|
|
|
|
void *dummy;
|
1995-08-28 09:19:25 +00:00
|
|
|
{
|
|
|
|
register struct filedesc0 *fdp = &filedesc0;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/* Get the vnode for '/'. Set fdp->fd_fd.fd_cdir to reference it. */
|
1995-08-11 11:31:18 +00:00
|
|
|
if (VFS_ROOT(mountlist.cqh_first, &rootvnode))
|
1994-05-24 10:09:53 +00:00
|
|
|
panic("cannot find root vnode");
|
|
|
|
fdp->fd_fd.fd_cdir = rootvnode;
|
|
|
|
VREF(fdp->fd_fd.fd_cdir);
|
1997-02-10 02:22:35 +00:00
|
|
|
VOP_UNLOCK(rootvnode, 0, &proc0);
|
1998-02-15 04:17:09 +00:00
|
|
|
fdp->fd_fd.fd_rdir = rootvnode;
|
1995-08-28 09:19:25 +00:00
|
|
|
}
|
|
|
|
SYSINIT(retrofit, SI_SUB_ROOT_FDTAB, SI_ORDER_FIRST, xxx_vfs_root_fdtab, NULL)
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
|
1995-08-28 09:19:25 +00:00
|
|
|
/*
|
|
|
|
***************************************************************************
|
|
|
|
****
|
|
|
|
**** The following code probably belongs in another file, like
|
|
|
|
**** kern/init_init.c. It is here for two reasons only:
|
|
|
|
****
|
|
|
|
**** 1) This code returns to startup the system; this is
|
|
|
|
**** abnormal for a kernel thread.
|
|
|
|
**** 2) This code promiscuously uses init_frame
|
|
|
|
****
|
|
|
|
***************************************************************************
|
|
|
|
*/
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1999-01-29 08:36:45 +00:00
|
|
|
static void kthread_init __P((const void *dummy));
|
1997-12-12 04:00:59 +00:00
|
|
|
SYSINIT_KP(init,SI_SUB_KTHREAD_INIT, SI_ORDER_FIRST, kthread_init, NULL)
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1994-05-25 09:21:21 +00:00
|
|
|
|
1997-04-07 07:16:06 +00:00
|
|
|
extern void prepare_usermode __P((void));
|
|
|
|
static void start_init __P((struct proc *p));
|
1995-08-28 09:19:25 +00:00
|
|
|
|
|
|
|
/* ARGSUSED*/
|
|
|
|
static void
|
1995-12-02 17:11:20 +00:00
|
|
|
kthread_init(dummy)
|
1999-01-29 08:36:45 +00:00
|
|
|
const void *dummy;
|
1995-08-28 09:19:25 +00:00
|
|
|
{
|
|
|
|
/* Create process 1 (init(8)). */
|
1997-04-07 07:16:06 +00:00
|
|
|
start_init(curproc);
|
|
|
|
|
|
|
|
prepare_usermode();
|
1994-11-06 05:01:58 +00:00
|
|
|
|
|
|
|
/*
|
1997-04-07 07:16:06 +00:00
|
|
|
* This returns to the fork trampoline, then to user mode.
|
1994-05-25 09:21:21 +00:00
|
|
|
*/
|
1995-08-28 09:19:25 +00:00
|
|
|
return;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
1995-08-28 09:19:25 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* List of paths to try when searching for "init".
|
|
|
|
*/
|
1999-04-20 21:15:13 +00:00
|
|
|
static char init_path[MAXPATHLEN] =
|
|
|
|
"/sbin/init;/sbin/oinit;/sbin/init.bak;/stand/sysinstall";
|
|
|
|
SYSCTL_STRING(_kern, OID_AUTO, init_path, CTLFLAG_RD, init_path, 0, "");
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/*
|
1999-04-20 21:15:13 +00:00
|
|
|
* Start the initial user process; try exec'ing each pathname in init_path.
|
1994-05-24 10:09:53 +00:00
|
|
|
* The program is invoked with one argument containing the boot flags.
|
|
|
|
*/
|
|
|
|
static void
|
1997-04-07 07:16:06 +00:00
|
|
|
start_init(p)
|
1994-05-24 10:09:53 +00:00
|
|
|
struct proc *p;
|
|
|
|
{
|
|
|
|
vm_offset_t addr;
|
|
|
|
struct execve_args args;
|
1999-04-20 21:15:13 +00:00
|
|
|
int options, error;
|
|
|
|
char *var, *path, *next, *s;
|
|
|
|
char *ucp, **uap, *arg0, *arg1;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
initproc = p;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Need just enough stack to hold the faked-up "execve()" arguments.
|
|
|
|
*/
|
1998-12-30 10:38:59 +00:00
|
|
|
addr = trunc_page(USRSTACK - PAGE_SIZE);
|
1999-04-20 21:15:13 +00:00
|
|
|
if (vm_map_find(&p->p_vmspace->vm_map, NULL, 0, &addr, PAGE_SIZE,
|
|
|
|
FALSE, VM_PROT_ALL, VM_PROT_ALL, 0) != 0)
|
1994-05-24 10:09:53 +00:00
|
|
|
panic("init: couldn't allocate argument space");
|
|
|
|
p->p_vmspace->vm_maxsaddr = (caddr_t)addr;
|
1994-05-25 09:21:21 +00:00
|
|
|
p->p_vmspace->vm_ssize = 1;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1999-04-20 21:15:13 +00:00
|
|
|
if ((var = getenv("init_path")) != NULL) {
|
|
|
|
strncpy(init_path, var, MAXPATHLEN);
|
|
|
|
init_path[sizeof init_path - 1] = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (path = init_path; path != '\0'; path = next) {
|
|
|
|
while (*path == ';')
|
|
|
|
path++;
|
|
|
|
if (path == '\0')
|
|
|
|
break;
|
|
|
|
for (next = path; *next != '\0' && *next != ';'; next++)
|
|
|
|
/* nothing */ ;
|
|
|
|
if (bootverbose)
|
1999-04-24 18:50:48 +00:00
|
|
|
printf("start_init: trying %.*s\n", (int)(next - path),
|
|
|
|
path);
|
1999-04-20 21:15:13 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Move out the boot flag argument.
|
|
|
|
*/
|
|
|
|
options = 0;
|
|
|
|
ucp = (char *)USRSTACK;
|
|
|
|
(void)subyte(--ucp, 0); /* trailing zero */
|
|
|
|
if (boothowto & RB_SINGLE) {
|
|
|
|
(void)subyte(--ucp, 's');
|
|
|
|
options = 1;
|
|
|
|
}
|
|
|
|
#ifdef notyet
|
|
|
|
if (boothowto & RB_FASTBOOT) {
|
|
|
|
(void)subyte(--ucp, 'f');
|
|
|
|
options = 1;
|
|
|
|
}
|
|
|
|
#endif
|
1995-04-10 07:44:31 +00:00
|
|
|
|
|
|
|
#ifdef BOOTCDROM
|
|
|
|
(void)subyte(--ucp, 'C');
|
|
|
|
options = 1;
|
1996-10-28 11:34:57 +00:00
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
if (options == 0)
|
|
|
|
(void)subyte(--ucp, '-');
|
|
|
|
(void)subyte(--ucp, '-'); /* leading hyphen */
|
|
|
|
arg1 = ucp;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Move out the file name (also arg 0).
|
|
|
|
*/
|
1999-04-20 21:15:13 +00:00
|
|
|
(void)subyte(--ucp, 0);
|
|
|
|
for (s = next - 1; s >= path; s--)
|
|
|
|
(void)subyte(--ucp, *s);
|
1994-05-24 10:09:53 +00:00
|
|
|
arg0 = ucp;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Move out the arg pointers.
|
|
|
|
*/
|
1998-10-06 11:55:40 +00:00
|
|
|
uap = (char **)((intptr_t)ucp & ~(sizeof(intptr_t)-1));
|
1998-07-15 05:21:48 +00:00
|
|
|
(void)suword((caddr_t)--uap, (long)0); /* terminator */
|
|
|
|
(void)suword((caddr_t)--uap, (long)(intptr_t)arg1);
|
|
|
|
(void)suword((caddr_t)--uap, (long)(intptr_t)arg0);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Point at the arguments.
|
|
|
|
*/
|
|
|
|
args.fname = arg0;
|
1994-05-25 09:21:21 +00:00
|
|
|
args.argv = uap;
|
|
|
|
args.envv = NULL;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Now try to exec the program. If can't for any reason
|
|
|
|
* other than it doesn't exist, complain.
|
1995-08-28 09:19:25 +00:00
|
|
|
*
|
|
|
|
* Otherwise return to main() which returns to btext
|
|
|
|
* which completes the system startup.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1997-11-06 19:29:57 +00:00
|
|
|
if ((error = execve(p, &args)) == 0)
|
1994-05-24 10:09:53 +00:00
|
|
|
return;
|
|
|
|
if (error != ENOENT)
|
1999-04-24 18:50:48 +00:00
|
|
|
printf("exec %.*s: error %d\n", (int)(next - path),
|
|
|
|
path, error);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
printf("init: not found\n");
|
|
|
|
panic("no init");
|
|
|
|
}
|