/**
* @brief Setup fixture.
*/
void setup(void) {
Mem_Init();
Fs_Init(FS_NONE);
Cmd_Init();
}
/**
* @brief Setup fixture.
*/
void setup(void) {
Mem_Init();
Fs_Init(false);
}
/*
* @brief Initializes the master server.
*/
static void Init(void) {
Z_Init();
Fs_Init(false);
}
void
main()
{
Proc_PID pid;
int i;
/*
* Initialize variables specific to a given kernel.
* IMPORTANT: Only variable assignments and nothing else can be
* done in this routine.
*/
Main_InitVars();
/*
* Initialize machine dependent info. MUST BE CALLED HERE!!!.
*/
Mach_Init();
Sync_Init();
/*
* Initialize the debugger.
*/
Dbg_Init();
/*
* Initialize the system module, particularly the fact that there is an
* implicit DISABLE_INTR on every processor.
*/
if (main_PrintInitRoutines) {
Mach_MonPrintf("Calling Sys_Init().\n");
}
Sys_Init();
/*
* Now allow memory to be allocated by the "Vm_BootAlloc" call. Memory
* can be allocated by this method until "Vm_Init" is called. After this
* then the normal memory allocator must be used.
*/
if (main_PrintInitRoutines) {
Mach_MonPrintf("Calling Vm_BootInit().\n");
}
Vm_BootInit();
/*
* Initialize all devices.
*/
if (main_PrintInitRoutines) {
Mach_MonPrintf("Calling Dev_Init().\n");
}
Dev_Init();
/*
* Initialize the mappings of keys to call dump routines.
* Must be after Dev_Init.
*/
if (main_DoDumpInit) {
if (main_PrintInitRoutines) {
Mach_MonPrintf("Calling Dump_Init().\n");
}
Dump_Init();
}
/*
* Initialize the timer, signal, process, scheduling and synchronization
* modules' data structures.
*/
if (main_PrintInitRoutines) {
Mach_MonPrintf("Calling Proc_Init().\n");
}
Proc_Init();
if (main_PrintInitRoutines) {
Mach_MonPrintf("Calling Sync_LockStatInit().\n");
}
Sync_LockStatInit();
if (main_PrintInitRoutines) {
Mach_MonPrintf("Calling Timer_Init().\n");
}
Timer_Init();
if (main_PrintInitRoutines) {
Mach_MonPrintf("Calling Sig_Init().\n");
}
Sig_Init();
if (main_PrintInitRoutines) {
Mach_MonPrintf("Calling Sched_Init().\n");
}
Sched_Init();
/*
* Sys_Printfs are not allowed before this point.
*/
main_PanicOK++;
printf("Sprite kernel: %s\n", SpriteVersion());
/*
* Set up bins for the memory allocator.
*/
if (main_PrintInitRoutines) {
Mach_MonPrintf("Calling Fs_Bin\n");
}
Fs_Bin();
if (main_PrintInitRoutines) {
Mach_MonPrintf("Calling Net_Bin\n");
}
Net_Bin();
/*
* Initialize virtual memory. After this point must use the normal
* memory allocator to allocate memory. If you use Vm_BootAlloc then
* will get a panic into the debugger.
*/
if (main_PrintInitRoutines) {
Mach_MonPrintf("Calling Vm_Init\n");
}
Vm_Init();
/*
* malloc can be called from this point on.
*/
/*
* Initialize the main process. Must be called before any new
* processes are created.
* Dependencies: Proc_InitTable, Sched_Init, Vm_Init, Mem_Init
*/
if (main_PrintInitRoutines) {
Mach_MonPrintf("Calling Proc_InitMainProc\n");
}
Proc_InitMainProc();
/*
* Initialize the network and the routes. It would be nice if we
* could call Net_Init earlier so that we can use the debugger earlier
* but we must call Vm_Init first. VM could be changed so that we
* could move the call earlier however.
*/
if (main_PrintInitRoutines) {
Mach_MonPrintf("Calling Net_Init\n");
}
Net_Init();
if (main_PrintInitRoutines) {
Mach_MonPrintf("Calling Net_RouteInit\n");
}
Net_RouteInit();
/*
* Enable server process manager.
*/
if (main_PrintInitRoutines) {
Mach_MonPrintf("Calling Proc_ServerInit\n");
}
Proc_ServerInit();
/*
* Initialize the recovery module. Do before Rpc and after Vm_Init.
*/
if (main_PrintInitRoutines) {
Mach_MonPrintf("Calling Recov_Init\n");
}
Recov_Init();
/*
* Initialize the data structures for the Rpc system. This uses
* Vm_RawAlloc to so it must be called after Vm_Init.
* Dependencies: Timer_Init, Vm_Init, Net_Init, Recov_Init
*/
if (main_PrintInitRoutines) {
Mach_MonPrintf("Calling Rpc_Init\n");
}
Rpc_Init();
/*
* Configure devices that may or may not exist. This needs to be
* done after Proc_InitMainProc because the initialization routines
* use SetJump which uses the proc table entry for the main process.
*/
if (main_PrintInitRoutines) {
Mach_MonPrintf("Calling Dev_Config\n");
}
Dev_Config();
/*
* Initialize profiling after the timer and vm stuff is set up.
* Dependencies: Timer_Init, Vm_Init
*/
if (main_DoProf) {
Prof_Init();
}
/*
* Allow interrupts from now on.
*/
if (main_PrintInitRoutines) {
Mach_MonPrintf("Enabling interrupts\n");
}
ENABLE_INTR();
if (main_Debug) {
DBG_CALL;
}
/*
* Sleep for a few seconds to calibrate the idle time ticks.
*/
Sched_TimeTicks();
/*
* Start profiling, if desired.
*/
if (main_DoProf) {
(void) Prof_Start();
}
/*
* Do an initial RPC to get a boot timestamp. This allows
* servers to detect when we crash and reboot. This will set the
* system clock too, although rdate is usually done from user level later.
*/
if (main_PrintInitRoutines) {
Mach_MonPrintf("Call Rpc_Start\n");
}
Rpc_Start();
/*
* Initialize the file system.
*/
if (main_PrintInitRoutines) {
Mach_MonPrintf("Call Fs_Init\n");
}
Fs_Init();
/*
* Before starting up any more processes get a current directory
* for the main process. Subsequent new procs will inherit it.
*/
if (main_PrintInitRoutines) {
Mach_MonPrintf("Call Fs_ProcInit\n");
}
Fs_ProcInit();
if (main_PrintInitRoutines) {
Mach_MonPrintf("Bunch of call funcs\n");
}
/*
* Start the clock daemon and the routine that opens up the swap directory.
*/
Proc_CallFunc(Vm_Clock, (ClientData) NIL, 0);
Proc_CallFunc(Vm_OpenSwapDirectory, (ClientData) NIL, 0);
/*
* Start the process that synchronizes the filesystem caches
* with the data kept on disk.
*/
Proc_CallFunc(Fsutil_SyncProc, (ClientData) NIL, 0);
/*
* Create a few RPC server processes and the Rpc_Daemon process which
* will create more server processes if needed.
*/
if (main_NumRpcServers > 0) {
for (i=0 ; i<main_NumRpcServers ; i++) {
(void) Rpc_CreateServer((int *) &pid);
}
}
(void) Proc_NewProc((Address) Rpc_Daemon, PROC_KERNEL, FALSE, &pid,
"Rpc_Daemon", FALSE);
if (main_PrintInitRoutines) {
Mach_MonPrintf("Creating Proc server procs\n");
}
/*
* Create processes to execute functions.
*/
(void) Proc_ServerProcCreate(FSCACHE_MAX_CLEANER_PROCS +
VM_MAX_PAGE_OUT_PROCS);
/*
* Create a recovery process to monitor other hosts. Can't use
* Proc_CallFunc's to do this because they can be used up waiting
* for page faults against down servers. (Alternatively the VM
* code could be fixed up to retry page faults later instead of
* letting the Proc_ServerProc wait for recovery.)
*/
(void) Proc_NewProc((Address) Recov_Proc, PROC_KERNEL, FALSE, &pid,
"Recov_Proc", FALSE);
/*
* Set up process migration recovery management.
*/
if (main_PrintInitRoutines) {
Mach_MonPrintf("Calling Proc_MigInit\n");
}
Proc_MigInit();
/*
* Call the routine to start test kernel processes.
*/
if (main_PrintInitRoutines) {
Mach_MonPrintf("Calling Main_HookRoutine\n");
}
Main_HookRoutine();
/*
* Print out the amount of memory used.
*/
printf("MEMORY %d bytes allocated for kernel\n",
vmMemEnd - mach_KernStart);
/*
* Start up the first user process.
*/
if (main_PrintInitRoutines) {
Mach_MonPrintf("Creating Init\n");
}
(void) Proc_NewProc((Address) Init, PROC_KERNEL, FALSE, &pid,
"Init", FALSE);
(void) Sync_WaitTime(time_OneYear);
printf("Main exiting\n");
Proc_Exit(0);
}
/*
* @brief Setup fixture.
*/
void setup(void) {
Mem_Init();
Fs_Init(true);
}
/**
* @brief
*/
static void Init(void) {
SDL_Init(SDL_INIT_TIMER);
Mem_Init();
Cmd_Init();
Cvar_Init();
verbose = Cvar_Add("verbose", "0", 0, "Print verbose debugging information");
dedicated = Cvar_Add("dedicated", "0", CVAR_NO_SET, "Run a dedicated server");
if (strstr(Sys_ExecutablePath(), "-dedicated")) {
Cvar_ForceSet("dedicated", "1");
}
if (dedicated->value) {
Cvar_ForceSet("threads", "0");
}
game = Cvar_Add("game", DEFAULT_GAME, CVAR_LATCH | CVAR_SERVER_INFO, "The game module name");
game->modified = g_strcmp0(game->string, DEFAULT_GAME);
threads = Cvar_Add("threads", "0", CVAR_ARCHIVE, "Specifies the number of threads to create");
threads->modified = false;
time_demo = Cvar_Add("time_demo", "0", CVAR_LO_ONLY, "Benchmark and stress test");
time_scale = Cvar_Add("time_scale", "1.0", CVAR_LO_ONLY, "Controls time lapse");
const char *s = va("Quetoo %s %s %s", VERSION, __DATE__, BUILD_HOST);
Cvar_Add("version", s, CVAR_SERVER_INFO | CVAR_NO_SET, NULL);
quetoo.Debug = Debug;
quetoo.Error = Error;
quetoo.Print = Print;
quetoo.Verbose = Verbose;
quetoo.Warn = Warn;
Fs_Init(true);
Thread_Init(threads->integer);
Con_Init();
Cmd_Add("mem_stats", MemStats_f, CMD_SYSTEM, "Print memory stats");
Cmd_Add("debug", Debug_f, CMD_SYSTEM, "Control debugging output");
Cmd_Add("quit", Quit_f, CMD_SYSTEM, "Quit Quetoo");
Netchan_Init();
Sv_Init();
Cl_Init();
Com_Print("Quetoo %s %s %s initialized\n", VERSION, __DATE__, BUILD_HOST);
// reset debug value since Cbuf may change it from Com's "all" init
Com_SetDebug("0");
// execute any +commands specified on the command line
Cbuf_InsertFromDefer();
Cbuf_Execute();
// dedicated server, nothing specified, use Edge
if (dedicated->value && !Com_WasInit(QUETOO_SERVER)) {
Cbuf_AddText("map edge\n");
Cbuf_Execute();
}
}
/*
* @brief Setup fixture.
*/
void setup(void) {
Z_Init();
Fs_Init(true);
}
