/*
================
FS_InitFilesystem
Called only at inital startup, not when the filesystem
is resetting due to a game change
================
*/
void FS_InitFilesystem( void ) {
#ifdef USE_AIO
struct aioinit init;
memset( &init, 0, sizeof( init ) );
init.aio_threads = 20;
init.aio_num = 64;
init.aio_idle_time = 300;
aio_init( &init );
Com_Printf( "Initialized AIO\n" );
#endif
// allow command line parms to override our defaults
// we have to specially handle this, because normal command
// line variable sets don't happen until after the filesystem
// has already been initialized
Com_StartupVariable( "fs_cdpath" );
Com_StartupVariable( "fs_basepath" );
Com_StartupVariable( "fs_homepath" );
Com_StartupVariable( "fs_game" );
Com_StartupVariable( "fs_copyfiles" );
Com_StartupVariable( "fs_dirbeforepak" );
Com_StartupVariable( "fs_extragames" );
#ifdef MACOS_X
Com_StartupVariable( "fs_apppath" );
#endif
if(!FS_FilenameCompare(Cvar_VariableString("fs_game"), BASEGAME))
Cvar_Set("fs_game", "");
// try to start up normally
FS_Startup( BASEGAME );
initialized = qtrue;
// if we can't find default.cfg, assume that the paths are
// busted and error out now, rather than getting an unreadable
// graphics screen when the font fails to load
if ( FS_ReadFile( "mpdefault.cfg", NULL ) <= 0 ) {
Com_Error( ERR_FATAL, "Couldn't load mpdefault.cfg" );
// bk001208 - SafeMode see below, FIXME?
}
Q_strncpyz(lastValidBase, fs_basepath->string, sizeof(lastValidBase));
Q_strncpyz(lastValidGame, fs_gamedirvar->string, sizeof(lastValidGame));
// bk001208 - SafeMode see below, FIXME?
}
static PyObject *
pyaio_init(PyObject *dummy, PyObject *args) {
struct aioinit *init;
int aio_threads, aio_num, aio_idle_time;
Py_XINCREF(args);
if (PyArg_ParseTuple(args, "iii", &aio_threads, &aio_num, &aio_idle_time)) {
init = malloc(sizeof(struct aioinit));
init->aio_threads = aio_threads;
init->aio_num = aio_num;
init->aio_idle_time = aio_idle_time;
aio_init(init);
free(init);
}
Py_XDECREF(args);
Py_XINCREF(Py_None);
return Py_None;
}
int
aioperf_aio_init(aioperf_manager_t *mgr)
{
struct aioinit *aio_mgr = NULL;
if (!(aio_mgr = (struct aioinit *)aioperf_memory_pool_alloc(mgr->pool,
sizeof(struct aioinit)))) {
printf("alloc error\n");
return AIOPERF_ERROR;
}
aioperf_memory_set(aio_mgr, 0, sizeof(struct aioinit));
aio_mgr->aio_threads = mgr->io_thread_num;
aio_mgr->aio_num = AIOPERF_QUEUE_SIZE;
aio_mgr->aio_idle_time = 5;
mgr->data = aio_mgr;
aio_init(aio_mgr);
return AIOPERF_OK;
}
int CDECL main(int argc, char *argv[])
{
Manager *manager;
char iometer[MAX_NETWORK_NAME];
int error = 0;
// struct dynamo_param param; //move up to global scope
#if defined(IOMTR_OS_LINUX)
struct aioinit aioDefaults;
memset(&aioDefaults, 0, sizeof(aioDefaults));
aioDefaults.aio_threads = 32;
aio_init(&aioDefaults);
kstatfd = InitIoctlInterface();
#if defined(IOMTR_CPU_XSCALE)
if ((ccntfd = InitCCNTInterface()) < 0) {
exit(1);
}
#endif
#endif
Banner();
#if !defined(DO_NOT_PARSE_BEFORE_MANAGER)
// In order to allow command line parameters to influence default values of
// the Manager class members, we need to parse parameters before instantiating
// the Manager, but to do this, we need to:
// Setup local storage -- could just be in the global param structure???
char blkdevlist[MAX_TARGETS][MAX_NAME];
char manager_name[MAX_WORKER_NAME];
char network_name[MAX_NETWORK_NAME];
char exclude_filesys[MAX_EXCLUDE_FILESYS];
// Init the local storage to match the original code
iometer[0] = 0;
manager_name[0] = 0;
exclude_filesys[0] = 0;
network_name[0] = 0;
// Setup the param structure to defaults and to point to buffers above
param.iometer = iometer;
param.manager_name = manager_name;
param.manager_computer_name = network_name;
param.manager_exclude_fs = exclude_filesys;
param.blkdevlist = &blkdevlist;
param.login_port_number = 0;
param.cpu_affinity = 0; // not specified or default
param.timer_type = TIMER_UNDEFINED; // use the default
param.disk_control = RAWDISK_VIEW_NOPART; // do not show raw disks with partitions
// The manager's GetVersionString method is not available yet since it does not exist,
// so we do away with the variable and have ParseParam rely directly on the source of
// the strings in ioversion.h. Not too clean but functional...
// g_pVersionStringWithDebug = NULL; // not needed
// Parse params and then instantiate the manager next...
ParseParam(argc, argv, ¶m);
#endif
manager = new Manager;
#if !defined(DO_NOT_PARSE_BEFORE_MANAGER)
// Restore the param globals retrieved above back to the manager
// since the manager buffers were not available prior to the parse call.
memcpy(manager->manager_name, manager_name, sizeof(manager_name));
memcpy(manager->prt->network_name, network_name, sizeof(network_name));
memcpy(manager->exclude_filesys, exclude_filesys, sizeof(exclude_filesys));
memcpy(manager->blkdevlist, blkdevlist, sizeof(blkdevlist));
#else // defined(DO_NOT_PARSE_BEFORE_MANAGER) // the original code
iometer[0] = 0;
manager->manager_name[0] = 0;
manager->exclude_filesys[0] = 0;
//provide a temporary global ptr to the version string for Syntax() to use
g_pVersionStringWithDebug = manager->GetVersionString(TRUE);
param.iometer = iometer;
param.manager_name = manager->manager_name;
param.manager_computer_name = manager->prt->network_name;
param.manager_exclude_fs = manager->exclude_filesys;
param.blkdevlist = &manager->blkdevlist;
param.login_port_number = 0;
param.cpu_affinity = 0; // not specified or default
param.timer_type = TIMER_UNDEFINED; // use the default
param.disk_control = RAWDISK_VIEW_NOPART; // do not show raw disks with partitions
ParseParam(argc, argv, ¶m);
g_pVersionStringWithDebug = NULL; //should use manager object after this...
#endif
iomtr_set_cpu_affinity(param.cpu_affinity);
// If there were command line parameters, indicate that they were recognized.
if (iometer[0] || manager->manager_name[0]) {
cout << "\nCommand line parameter(s):" << endl;
if (iometer[0]) {
cout << " Looking for Iometer on \"" << iometer << "\"" << endl;
}
if (manager->manager_name[0]) {
cout << " New manager name is \"" << manager->manager_name << "\"" << endl;
}
}
if (manager->exclude_filesys[0]) {
cout << "\nExcluding the following filesystem types:" << endl;
cout << " \"" << manager->exclude_filesys << "\"" << endl;
} else {
strcpy(manager->exclude_filesys, DEFAULT_EXCLUDE_FILESYS);
}
// cout << endl;
#if defined(IOMTR_OSFAMILY_UNIX)
#if defined(IOMTR_OS_LINUX) || defined(IOMTR_OS_OSX)
signal(SIGALRM, SIG_IGN);
#elif defined(IOMTR_OS_SOLARIS)
sigignore(SIGALRM);
#else
#warning ===> WARNING: You have to do some coding here to get the port done!
#endif
// Initialize the lock on UNIX platforms.
if (pthread_mutex_init(&lock_mt, NULL)) {
cout << "unable to init the lock" << endl;
error = 1;
goto CleanUp;
//exit(1);
}
// Block SIGPIPE signal. Needed to ensure that Network worker
// threads don't exit due to a broken pipe signal.
sigset_t sigset;
sigemptyset(&sigset);
sigaddset(&sigset, SIGPIPE);
if (sigprocmask(SIG_BLOCK, &sigset, NULL) < 0) {
cout << "sigprocmask() call failed." << endl;
cout << "dynamo could be unstable" << endl;
}
//
// the number of file descriptors a process may create can be a small value like 64.
//
struct rlimit rlimitp;
if (getrlimit(RLIMIT_NOFILE, &rlimitp) < 0) {
cout << "error " << errno << " trying to get rlimit (# file descriptors)" << endl;
} else {
// it succeeded. We leave out atleast 25 file descriptors for non-targets
// and compare with the hard limit.
unsigned int targets = MAX_TARGETS + 25;
if (rlimitp.rlim_max < targets) {
cout << "Only " << rlimitp.rlim_max << " file descriptors available" << endl;
rlimitp.rlim_cur = rlimitp.rlim_max;
} else {
// set the soft limit to the required value.
rlimitp.rlim_cur = targets;
}
if (setrlimit(RLIMIT_NOFILE, &rlimitp) < 0) {
cout << "error " << errno << " trying to set rlimit (# file descriptors)" << endl;
}
}
// Check for super-user permissions. If not super-user, we
// cannot get many of the info from the kernel.
if (getuid() || geteuid()) {
cout << "Dynamo not running as super-user." << endl;
cout << " All available disks might not be reported " << endl;
cout << " Cannot get TCP statistics from the kernel " << endl;
}
#ifdef IOMTR_SETTING_OVERRIDE_FS
// No command line args specifies destructive testing. Check to see if there
// are any environment variables specifying the same. We need to warn the user.
if (getenv("IOMTR_SETTING_OVERRIDE_FS") != NULL) {
cout << " ************ WARNING **************" << endl;
cout << " dynamo running in Destructive mode." << endl;
cout << " (overriding the not mounted fs)" << endl;
cout << " ************ WARNING **************" << endl;
}
#endif // IOMTR_SETTING_OVERRIDE_FS
#endif // IOMTR_OSFAMILY_UNIX
#if defined(IOMTR_OSFAMILY_NETWARE)
// Initialize the lock on NetWare platforms.
if (pthread_mutex_init(&lock_mt, NULL)) {
cout << "unable to init the lock" << endl;
error = 1;
goto CleanUp;
//exit(1);
}
#endif
#if defined(IOMTR_OSFAMILY_WINDOWS)
// IOmeter/Dynamo now utilizes Windows UAC for privilege elevation,
// but on version of Windows in which that is not supported we
// match the UNIX output above.
BOOL bReturned;
SID_IDENTIFIER_AUTHORITY NtAuthority = SECURITY_NT_AUTHORITY;
PSID AdminGroup;
bReturned = AllocateAndInitializeSid(
&NtAuthority,
2,
SECURITY_BUILTIN_DOMAIN_RID,
DOMAIN_ALIAS_RID_ADMINS,
0, 0, 0, 0, 0, 0,
&AdminGroup);
if(bReturned)
{
CheckTokenMembership( NULL, AdminGroup, &bReturned);
if (!bReturned)
{
cout << "Dynamo not running as an administrator." << endl;
cout << " All available disks might not be reported " << endl;
cout << endl;
}
FreeSid(AdminGroup);
}
#endif
// Ensure, that the endian type of the CPU is detectable
if ((IsBigEndian() != 0) && (IsBigEndian() != 1)) {
cout << "===> ERROR: Endian type of the CPU couldn't be detected." << endl;
cout << " [main() in " << __FILE__ << " line " << __LINE__ << "]" << endl;
error = 1;
goto CleanUp;
//exit(1);
}
// Entering infinite loop to allow Dynamo to run multiple tests. Outer while loop allows
// Dynamo to be reset from Iometer. If everything works smoothly, resets should be rare.
while (TRUE) {
// Initializing worker and logging into Iometer director.
if (!manager->Login(iometer, param.login_port_number))
break;
// Manager will continue to run until an error, or stopped by Iometer.
if (!manager->Run())
break; // Stop running when the manager is done.
}
cout << "Ending execution." << endl;
Sleep(1000);
#if defined(IOMTR_OS_LINUX)
CleanupIoctlInterface(kstatfd);
#if defined(IOMTR_CPU_XSCALE)
CleanupCCNTInterface(ccntfd);
#endif
#endif
//return (0);
CleanUp:
if (manager) delete manager;
if (error) exit(error);
return (0);
}
void
bsd_init(void)
{
struct uthread *ut;
unsigned int i;
struct vfs_context context;
kern_return_t ret;
struct ucred temp_cred;
struct posix_cred temp_pcred;
#if NFSCLIENT || CONFIG_IMAGEBOOT
boolean_t netboot = FALSE;
#endif
#define bsd_init_kprintf(x...) /* kprintf("bsd_init: " x) */
throttle_init();
printf(copyright);
bsd_init_kprintf("calling kmeminit\n");
kmeminit();
bsd_init_kprintf("calling parse_bsd_args\n");
parse_bsd_args();
#if CONFIG_DEV_KMEM
bsd_init_kprintf("calling dev_kmem_init\n");
dev_kmem_init();
#endif
/* Initialize kauth subsystem before instancing the first credential */
bsd_init_kprintf("calling kauth_init\n");
kauth_init();
/* Initialize process and pgrp structures. */
bsd_init_kprintf("calling procinit\n");
procinit();
/* Initialize the ttys (MUST be before kminit()/bsd_autoconf()!)*/
tty_init();
kernproc = &proc0; /* implicitly bzero'ed */
/* kernel_task->proc = kernproc; */
set_bsdtask_info(kernel_task,(void *)kernproc);
/* give kernproc a name */
bsd_init_kprintf("calling process_name\n");
process_name("kernel_task", kernproc);
/* allocate proc lock group attribute and group */
bsd_init_kprintf("calling lck_grp_attr_alloc_init\n");
proc_lck_grp_attr= lck_grp_attr_alloc_init();
proc_lck_grp = lck_grp_alloc_init("proc", proc_lck_grp_attr);
#if CONFIG_FINE_LOCK_GROUPS
proc_slock_grp = lck_grp_alloc_init("proc-slock", proc_lck_grp_attr);
proc_fdmlock_grp = lck_grp_alloc_init("proc-fdmlock", proc_lck_grp_attr);
proc_ucred_mlock_grp = lck_grp_alloc_init("proc-ucred-mlock", proc_lck_grp_attr);
proc_mlock_grp = lck_grp_alloc_init("proc-mlock", proc_lck_grp_attr);
#endif
/* Allocate proc lock attribute */
proc_lck_attr = lck_attr_alloc_init();
#if 0
#if __PROC_INTERNAL_DEBUG
lck_attr_setdebug(proc_lck_attr);
#endif
#endif
#if CONFIG_FINE_LOCK_GROUPS
proc_list_mlock = lck_mtx_alloc_init(proc_mlock_grp, proc_lck_attr);
proc_klist_mlock = lck_mtx_alloc_init(proc_mlock_grp, proc_lck_attr);
lck_mtx_init(&kernproc->p_mlock, proc_mlock_grp, proc_lck_attr);
lck_mtx_init(&kernproc->p_fdmlock, proc_fdmlock_grp, proc_lck_attr);
lck_mtx_init(&kernproc->p_ucred_mlock, proc_ucred_mlock_grp, proc_lck_attr);
lck_spin_init(&kernproc->p_slock, proc_slock_grp, proc_lck_attr);
#else
proc_list_mlock = lck_mtx_alloc_init(proc_lck_grp, proc_lck_attr);
proc_klist_mlock = lck_mtx_alloc_init(proc_lck_grp, proc_lck_attr);
lck_mtx_init(&kernproc->p_mlock, proc_lck_grp, proc_lck_attr);
lck_mtx_init(&kernproc->p_fdmlock, proc_lck_grp, proc_lck_attr);
lck_mtx_init(&kernproc->p_ucred_mlock, proc_lck_grp, proc_lck_attr);
lck_spin_init(&kernproc->p_slock, proc_lck_grp, proc_lck_attr);
#endif
assert(bsd_simul_execs != 0);
execargs_cache_lock = lck_mtx_alloc_init(proc_lck_grp, proc_lck_attr);
execargs_cache_size = bsd_simul_execs;
execargs_free_count = bsd_simul_execs;
execargs_cache = (vm_offset_t *)kalloc(bsd_simul_execs * sizeof(vm_offset_t));
bzero(execargs_cache, bsd_simul_execs * sizeof(vm_offset_t));
if (current_task() != kernel_task)
printf("bsd_init: We have a problem, "
"current task is not kernel task\n");
bsd_init_kprintf("calling get_bsdthread_info\n");
ut = (uthread_t)get_bsdthread_info(current_thread());
#if CONFIG_MACF
/*
* Initialize the MAC Framework
*/
mac_policy_initbsd();
kernproc->p_mac_enforce = 0;
#if defined (__i386__) || defined (__x86_64__)
/*
* We currently only support this on i386/x86_64, as that is the
* only lock code we have instrumented so far.
*/
check_policy_init(policy_check_flags);
#endif
#endif /* MAC */
/* Initialize System Override call */
init_system_override();
/*
* Create process 0.
*/
proc_list_lock();
LIST_INSERT_HEAD(&allproc, kernproc, p_list);
kernproc->p_pgrp = &pgrp0;
LIST_INSERT_HEAD(PGRPHASH(0), &pgrp0, pg_hash);
LIST_INIT(&pgrp0.pg_members);
#ifdef CONFIG_FINE_LOCK_GROUPS
lck_mtx_init(&pgrp0.pg_mlock, proc_mlock_grp, proc_lck_attr);
#else
lck_mtx_init(&pgrp0.pg_mlock, proc_lck_grp, proc_lck_attr);
#endif
/* There is no other bsd thread this point and is safe without pgrp lock */
LIST_INSERT_HEAD(&pgrp0.pg_members, kernproc, p_pglist);
kernproc->p_listflag |= P_LIST_INPGRP;
kernproc->p_pgrpid = 0;
kernproc->p_uniqueid = 0;
pgrp0.pg_session = &session0;
pgrp0.pg_membercnt = 1;
session0.s_count = 1;
session0.s_leader = kernproc;
session0.s_listflags = 0;
#ifdef CONFIG_FINE_LOCK_GROUPS
lck_mtx_init(&session0.s_mlock, proc_mlock_grp, proc_lck_attr);
#else
lck_mtx_init(&session0.s_mlock, proc_lck_grp, proc_lck_attr);
#endif
LIST_INSERT_HEAD(SESSHASH(0), &session0, s_hash);
proc_list_unlock();
kernproc->task = kernel_task;
kernproc->p_stat = SRUN;
kernproc->p_flag = P_SYSTEM;
kernproc->p_lflag = 0;
kernproc->p_ladvflag = 0;
#if DEVELOPMENT || DEBUG
if (bootarg_disable_aslr)
kernproc->p_flag |= P_DISABLE_ASLR;
#endif
kernproc->p_nice = NZERO;
kernproc->p_pptr = kernproc;
TAILQ_INIT(&kernproc->p_uthlist);
TAILQ_INSERT_TAIL(&kernproc->p_uthlist, ut, uu_list);
kernproc->sigwait = FALSE;
kernproc->sigwait_thread = THREAD_NULL;
kernproc->exit_thread = THREAD_NULL;
kernproc->p_csflags = CS_VALID;
/*
* Create credential. This also Initializes the audit information.
*/
bsd_init_kprintf("calling bzero\n");
bzero(&temp_cred, sizeof(temp_cred));
bzero(&temp_pcred, sizeof(temp_pcred));
temp_pcred.cr_ngroups = 1;
/* kern_proc, shouldn't call up to DS for group membership */
temp_pcred.cr_flags = CRF_NOMEMBERD;
temp_cred.cr_audit.as_aia_p = audit_default_aia_p;
bsd_init_kprintf("calling kauth_cred_create\n");
/*
* We have to label the temp cred before we create from it to
* properly set cr_ngroups, or the create will fail.
*/
posix_cred_label(&temp_cred, &temp_pcred);
kernproc->p_ucred = kauth_cred_create(&temp_cred);
/* update cred on proc */
PROC_UPDATE_CREDS_ONPROC(kernproc);
/* give the (already exisiting) initial thread a reference on it */
bsd_init_kprintf("calling kauth_cred_ref\n");
kauth_cred_ref(kernproc->p_ucred);
ut->uu_context.vc_ucred = kernproc->p_ucred;
ut->uu_context.vc_thread = current_thread();
TAILQ_INIT(&kernproc->p_aio_activeq);
TAILQ_INIT(&kernproc->p_aio_doneq);
kernproc->p_aio_total_count = 0;
kernproc->p_aio_active_count = 0;
bsd_init_kprintf("calling file_lock_init\n");
file_lock_init();
#if CONFIG_MACF
mac_cred_label_associate_kernel(kernproc->p_ucred);
#endif
/* Create the file descriptor table. */
kernproc->p_fd = &filedesc0;
filedesc0.fd_cmask = cmask;
filedesc0.fd_knlistsize = -1;
filedesc0.fd_knlist = NULL;
filedesc0.fd_knhash = NULL;
filedesc0.fd_knhashmask = 0;
/* Create the limits structures. */
kernproc->p_limit = &limit0;
for (i = 0; i < sizeof(kernproc->p_rlimit)/sizeof(kernproc->p_rlimit[0]); i++)
limit0.pl_rlimit[i].rlim_cur =
limit0.pl_rlimit[i].rlim_max = RLIM_INFINITY;
limit0.pl_rlimit[RLIMIT_NOFILE].rlim_cur = NOFILE;
limit0.pl_rlimit[RLIMIT_NPROC].rlim_cur = maxprocperuid;
limit0.pl_rlimit[RLIMIT_NPROC].rlim_max = maxproc;
limit0.pl_rlimit[RLIMIT_STACK] = vm_initial_limit_stack;
limit0.pl_rlimit[RLIMIT_DATA] = vm_initial_limit_data;
limit0.pl_rlimit[RLIMIT_CORE] = vm_initial_limit_core;
limit0.pl_refcnt = 1;
kernproc->p_stats = &pstats0;
kernproc->p_sigacts = &sigacts0;
/*
* Charge root for one process: launchd.
*/
bsd_init_kprintf("calling chgproccnt\n");
(void)chgproccnt(0, 1);
/*
* Allocate a kernel submap for pageable memory
* for temporary copying (execve()).
*/
{
vm_offset_t minimum;
bsd_init_kprintf("calling kmem_suballoc\n");
assert(bsd_pageable_map_size != 0);
ret = kmem_suballoc(kernel_map,
&minimum,
(vm_size_t)bsd_pageable_map_size,
TRUE,
VM_FLAGS_ANYWHERE | VM_MAKE_TAG(VM_KERN_MEMORY_BSD),
&bsd_pageable_map);
if (ret != KERN_SUCCESS)
panic("bsd_init: Failed to allocate bsd pageable map");
}
/*
* Initialize buffers and hash links for buffers
*
* SIDE EFFECT: Starts a thread for bcleanbuf_thread(), so must
* happen after a credential has been associated with
* the kernel task.
*/
bsd_init_kprintf("calling bsd_bufferinit\n");
bsd_bufferinit();
/* Initialize the execve() semaphore */
bsd_init_kprintf("calling semaphore_create\n");
if (ret != KERN_SUCCESS)
panic("bsd_init: Failed to create execve semaphore");
/*
* Initialize the calendar.
*/
bsd_init_kprintf("calling IOKitInitializeTime\n");
IOKitInitializeTime();
bsd_init_kprintf("calling ubc_init\n");
ubc_init();
/*
* Initialize device-switches.
*/
bsd_init_kprintf("calling devsw_init() \n");
devsw_init();
/* Initialize the file systems. */
bsd_init_kprintf("calling vfsinit\n");
vfsinit();
#if CONFIG_PROC_UUID_POLICY
/* Initial proc_uuid_policy subsystem */
bsd_init_kprintf("calling proc_uuid_policy_init()\n");
proc_uuid_policy_init();
#endif
#if SOCKETS
/* Initialize per-CPU cache allocator */
mcache_init();
/* Initialize mbuf's. */
bsd_init_kprintf("calling mbinit\n");
mbinit();
net_str_id_init(); /* for mbuf tags */
#endif /* SOCKETS */
/*
* Initializes security event auditing.
* XXX: Should/could this occur later?
*/
#if CONFIG_AUDIT
bsd_init_kprintf("calling audit_init\n");
audit_init();
#endif
/* Initialize kqueues */
bsd_init_kprintf("calling knote_init\n");
knote_init();
/* Initialize for async IO */
bsd_init_kprintf("calling aio_init\n");
aio_init();
/* Initialize pipes */
bsd_init_kprintf("calling pipeinit\n");
pipeinit();
/* Initialize SysV shm subsystem locks; the subsystem proper is
* initialized through a sysctl.
*/
#if SYSV_SHM
bsd_init_kprintf("calling sysv_shm_lock_init\n");
sysv_shm_lock_init();
#endif
#if SYSV_SEM
bsd_init_kprintf("calling sysv_sem_lock_init\n");
sysv_sem_lock_init();
#endif
#if SYSV_MSG
bsd_init_kprintf("sysv_msg_lock_init\n");
sysv_msg_lock_init();
#endif
bsd_init_kprintf("calling pshm_lock_init\n");
pshm_lock_init();
bsd_init_kprintf("calling psem_lock_init\n");
psem_lock_init();
pthread_init();
/* POSIX Shm and Sem */
bsd_init_kprintf("calling pshm_cache_init\n");
pshm_cache_init();
bsd_init_kprintf("calling psem_cache_init\n");
psem_cache_init();
bsd_init_kprintf("calling time_zone_slock_init\n");
time_zone_slock_init();
bsd_init_kprintf("calling select_waitq_init\n");
select_waitq_init();
/*
* Initialize protocols. Block reception of incoming packets
* until everything is ready.
*/
bsd_init_kprintf("calling sysctl_register_fixed\n");
sysctl_register_fixed();
bsd_init_kprintf("calling sysctl_mib_init\n");
sysctl_mib_init();
#if NETWORKING
bsd_init_kprintf("calling dlil_init\n");
dlil_init();
bsd_init_kprintf("calling proto_kpi_init\n");
proto_kpi_init();
#endif /* NETWORKING */
#if SOCKETS
bsd_init_kprintf("calling socketinit\n");
socketinit();
bsd_init_kprintf("calling domaininit\n");
domaininit();
iptap_init();
#if FLOW_DIVERT
flow_divert_init();
#endif /* FLOW_DIVERT */
#endif /* SOCKETS */
kernproc->p_fd->fd_cdir = NULL;
kernproc->p_fd->fd_rdir = NULL;
#if CONFIG_FREEZE
#ifndef CONFIG_MEMORYSTATUS
#error "CONFIG_FREEZE defined without matching CONFIG_MEMORYSTATUS"
#endif
/* Initialise background freezing */
bsd_init_kprintf("calling memorystatus_freeze_init\n");
memorystatus_freeze_init();
#endif
#if CONFIG_MEMORYSTATUS
/* Initialize kernel memory status notifications */
bsd_init_kprintf("calling memorystatus_init\n");
memorystatus_init();
#endif /* CONFIG_MEMORYSTATUS */
bsd_init_kprintf("calling macx_init\n");
macx_init();
bsd_init_kprintf("calling acct_init\n");
acct_init();
#ifdef GPROF
/* Initialize kernel profiling. */
kmstartup();
#endif
bsd_init_kprintf("calling bsd_autoconf\n");
bsd_autoconf();
#if CONFIG_DTRACE
dtrace_postinit();
#endif
/*
* We attach the loopback interface *way* down here to ensure
* it happens after autoconf(), otherwise it becomes the
* "primary" interface.
*/
#include <loop.h>
#if NLOOP > 0
bsd_init_kprintf("calling loopattach\n");
loopattach(); /* XXX */
#endif
#if NGIF
/* Initialize gif interface (after lo0) */
gif_init();
#endif
#if PFLOG
/* Initialize packet filter log interface */
pfloginit();
#endif /* PFLOG */
#if NETHER > 0
/* Register the built-in dlil ethernet interface family */
bsd_init_kprintf("calling ether_family_init\n");
ether_family_init();
#endif /* ETHER */
#if NETWORKING
/* Call any kext code that wants to run just after network init */
bsd_init_kprintf("calling net_init_run\n");
net_init_run();
#if CONTENT_FILTER
cfil_init();
#endif
#if PACKET_MANGLER
pkt_mnglr_init();
#endif
#if NECP
/* Initialize Network Extension Control Policies */
necp_init();
#endif
netagent_init();
/* register user tunnel kernel control handler */
utun_register_control();
#if IPSEC
ipsec_register_control();
#endif /* IPSEC */
netsrc_init();
nstat_init();
tcp_cc_init();
#if MPTCP
mptcp_control_register();
#endif /* MPTCP */
#endif /* NETWORKING */
bsd_init_kprintf("calling vnode_pager_bootstrap\n");
vnode_pager_bootstrap();
bsd_init_kprintf("calling inittodr\n");
inittodr(0);
/* Mount the root file system. */
while( TRUE) {
int err;
bsd_init_kprintf("calling setconf\n");
setconf();
#if NFSCLIENT
netboot = (mountroot == netboot_mountroot);
#endif
bsd_init_kprintf("vfs_mountroot\n");
if (0 == (err = vfs_mountroot()))
break;
rootdevice[0] = '\0';
#if NFSCLIENT
if (netboot) {
PE_display_icon( 0, "noroot"); /* XXX a netboot-specific icon would be nicer */
vc_progress_set(FALSE, 0);
for (i=1; 1; i*=2) {
printf("bsd_init: failed to mount network root, error %d, %s\n",
err, PE_boot_args());
printf("We are hanging here...\n");
IOSleep(i*60*1000);
}
/*NOTREACHED*/
}
#endif
printf("cannot mount root, errno = %d\n", err);
boothowto |= RB_ASKNAME;
}
IOSecureBSDRoot(rootdevice);
context.vc_thread = current_thread();
context.vc_ucred = kernproc->p_ucred;
mountlist.tqh_first->mnt_flag |= MNT_ROOTFS;
bsd_init_kprintf("calling VFS_ROOT\n");
/* Get the vnode for '/'. Set fdp->fd_fd.fd_cdir to reference it. */
if (VFS_ROOT(mountlist.tqh_first, &rootvnode, &context))
panic("bsd_init: cannot find root vnode: %s", PE_boot_args());
rootvnode->v_flag |= VROOT;
(void)vnode_ref(rootvnode);
(void)vnode_put(rootvnode);
filedesc0.fd_cdir = rootvnode;
#if NFSCLIENT
if (netboot) {
int err;
netboot = TRUE;
/* post mount setup */
if ((err = netboot_setup()) != 0) {
PE_display_icon( 0, "noroot"); /* XXX a netboot-specific icon would be nicer */
vc_progress_set(FALSE, 0);
for (i=1; 1; i*=2) {
printf("bsd_init: NetBoot could not find root, error %d: %s\n",
err, PE_boot_args());
printf("We are hanging here...\n");
IOSleep(i*60*1000);
}
/*NOTREACHED*/
}
}
#endif
#if CONFIG_IMAGEBOOT
/*
* See if a system disk image is present. If so, mount it and
* switch the root vnode to point to it
*/
if (netboot == FALSE && imageboot_needed()) {
/*
* An image was found. No turning back: we're booted
* with a kernel from the disk image.
*/
imageboot_setup();
}
#endif /* CONFIG_IMAGEBOOT */
/* set initial time; all other resource data is already zero'ed */
microtime_with_abstime(&kernproc->p_start, &kernproc->p_stats->ps_start);
#if DEVFS
{
char mounthere[] = "/dev"; /* !const because of internal casting */
bsd_init_kprintf("calling devfs_kernel_mount\n");
devfs_kernel_mount(mounthere);
}
#endif /* DEVFS */
/* Initialize signal state for process 0. */
bsd_init_kprintf("calling siginit\n");
siginit(kernproc);
bsd_init_kprintf("calling bsd_utaskbootstrap\n");
bsd_utaskbootstrap();
#if defined(__LP64__)
kernproc->p_flag |= P_LP64;
#endif
pal_kernel_announce();
bsd_init_kprintf("calling mountroot_post_hook\n");
/* invoke post-root-mount hook */
if (mountroot_post_hook != NULL)
mountroot_post_hook();
#if 0 /* not yet */
consider_zone_gc(FALSE);
#endif
bsd_init_kprintf("done\n");
}
static int
do_test (int argc, char *argv[])
{
char name[] = "/tmp/aio4.XXXXXX";
int fd;
struct aiocb *arr[1];
struct aiocb cb;
static const char buf[] = "Hello World\n";
struct aioinit init = {10, 20, 0};
struct sigaction sa;
struct sigevent ev;
if (SIGRTMIN == -1)
{
printf ("RT signals not supported.\n");
return 0;
}
/* Select a signal from the middle of the available choices... */
my_signo = (SIGRTMAX + SIGRTMIN) / 2;
fd = mkstemp (name);
if (fd == -1)
{
printf ("cannot open temp name: %m\n");
return 1;
}
unlink (name);
/* Test also aio_init. */
aio_init (&init);
arr[0] = &cb;
cb.aio_fildes = fd;
cb.aio_lio_opcode = LIO_WRITE;
cb.aio_reqprio = 0;
cb.aio_buf = (void *) buf;
cb.aio_nbytes = sizeof (buf) - 1;
cb.aio_offset = 0;
cb.aio_sigevent.sigev_notify = SIGEV_SIGNAL;
cb.aio_sigevent.sigev_notify_function = NULL;
cb.aio_sigevent.sigev_notify_attributes = NULL;
cb.aio_sigevent.sigev_signo = my_signo;
cb.aio_sigevent.sigev_value.sival_ptr = NULL;
ev.sigev_notify = SIGEV_SIGNAL;
ev.sigev_notify_function = NULL;
ev.sigev_notify_attributes = NULL;
ev.sigev_signo = my_signo;
sa.sa_handler = sighandler;
sigemptyset (&sa.sa_mask);
sa.sa_flags = SA_RESTART;
if (sigaction (my_signo, &sa, NULL) < 0)
{
printf ("sigaction failed: %m\n");
return 1;
}
flag = 0;
/* First use aio_write. */
if (aio_write (arr[0]) < 0)
{
if (errno == ENOSYS)
{
puts ("no aio support in this configuration");
return 0;
}
printf ("aio_write failed: %m\n");
return 1;
}
if (wait_flag ())
return 1;
puts ("aio_write OK");
flag = 0;
/* Again with lio_listio. */
if (lio_listio (LIO_NOWAIT, arr, 1, &ev) < 0)
{
printf ("lio_listio failed: %m\n");
return 1;
}
if (wait_flag ())
return 1;
puts ("all OK");
return 0;
}
int main(int argc, char **argv)
#endif
{
long cache_hits, cache_misses;
#if CHROMIUM
char *argv[] = { "vncreflector" };
(void) parse_args;
(void) report_usage;
/*opt_log_filename = "reflector.log";*/
opt_log_filename = NULL;
opt_no_banner = 1;
opt_foreground = 1;
opt_stderr_loglevel = 5;
#else
/* Parse command line, exit on error */
parse_args(argc, argv);
#endif
if (!opt_no_banner) {
fprintf(stderr,
"VNC Reflector %s. Copyright (C) 2001-2003 HorizonLive.com, Inc.\n\n"
"HorizonLive provides e-Learning and collaborative synchronous presentation\n"
"solutions in a totally Web-based environment. For more information about\n"
"HorizonLive, please see our website at http://www.horizonlive.com/\n\n",
VERSION);
}
if (!log_open(opt_log_filename, opt_file_loglevel,
(opt_foreground) ? opt_stderr_loglevel : -1)) {
fprintf(stderr, "%s: error opening log file (ignoring this error)\n",
argv[0]);
}
log_write(LL_MSG, "Starting VNC Reflector %s", VERSION);
/* Fork the process to the background if necessary */
if (!opt_foreground) {
if (!opt_no_banner) {
fprintf(stderr, "Starting in the background, "
"see the log file for errors and other messages.\n");
}
if (getpid() != 1) {
signal(SIGTTIN, SIG_IGN);
signal(SIGTTOU, SIG_IGN);
signal(SIGTSTP, SIG_IGN);
if (fork ())
return 0;
setsid();
}
close(0);
close(1);
close(2);
log_write(LL_INFO, "Switched to the background mode");
}
/* Initialization */
if (init_screen_info()) {
read_password_file();
set_host_encodings(opt_request_tight, opt_tight_level);
set_client_passwords(opt_client_password, opt_client_ro_password);
fbs_set_prefix(opt_fbs_prefix, opt_join_sessions);
set_active_file(opt_active_filename);
set_actions_file(opt_actions_filename);
aio_init();
if (opt_bind_ip != NULL) {
if (aio_set_bind_address(opt_bind_ip)) {
log_write(LL_INFO, "Would bind listening sockets to address %s",
opt_bind_ip);
} else {
log_write(LL_WARN, "Illegal address to bind listening sockets to: %s",
opt_bind_ip);
}
}
/* Main work */
if (vnc_spu.server_port == -1)
{
/* Try a series of port numbers until we find one that's free
* for us. Then, signal our parent thread that the port number
* is available.
*/
int i;
for (i = 0; i < NUM_SERVER_PORTS; i++) {
int p = FIRST_SERVER_PORT + i;
if (wait_for_client(p)) {
/* OK, we've got our port number now. So signal parent thread. */
crLockMutex(&vnc_spu.lock);
vnc_spu.server_port = p;
opt_cl_listen_port = vnc_spu.server_port;
crSignalCondition(&vnc_spu.cond);
crUnlockMutex(&vnc_spu.lock);
if (write_pid_file()) {
/*set_control_signals()*/
aio_mainloop();
remove_pid_file();
}
break;
}
}
if (i == NUM_SERVER_PORTS) {
log_write(LL_ERROR, "Unable to find a free port in the range"
" %d through %d",
FIRST_SERVER_PORT, FIRST_SERVER_PORT + NUM_SERVER_PORTS - 1);
exit(1);
}
}
else {
/* user-configured port number */
opt_cl_listen_port = vnc_spu.server_port;
if (wait_for_client(opt_cl_listen_port)) {
if (write_pid_file()) {
/*set_control_signals()*/
aio_mainloop();
remove_pid_file();
}
}
}
/* Cleanup */
if (g_framebuffer != NULL) {
log_write(LL_DETAIL, "Freeing framebuffer and associated structures");
free(g_framebuffer);
free_enc_cache();
}
if (g_screen_info.name != NULL)
free(g_screen_info.name);
get_hextile_caching_stats(&cache_hits, &cache_misses);
if (cache_hits + cache_misses != 0) {
log_write(LL_INFO, "Hextile BGR233 caching efficiency: %d%%",
(int)((cache_hits * 100 + (cache_hits + cache_misses) / 2)
/ (cache_hits + cache_misses)));
}
}
log_write(LL_MSG, "Terminating");
/* Close logs */
if (!log_close() && opt_foreground) {
fprintf(stderr, "%s: error closing log file (ignoring this error)\n",
argv[0]);
}
/* Done */
exit(1);
}
int CDECL main( int argc, char *argv[] )
{
Manager manager;
char iometer[MAX_NETWORK_NAME];
struct dynamo_param param;
#if defined(IOMTR_OS_LINUX)
struct aioinit aioDefaults;
memset(&aioDefaults, 0, sizeof(aioDefaults));
aioDefaults.aio_threads = 2;
aioDefaults.aio_threads = 2;
aio_init(&aioDefaults);
kstatfd = InitIoctlInterface();
procstatstyle = DetectProcStatStyle();
if (kstatfd < 0 && procstatstyle == -1) {
cerr << "IoMeter can not get correct status information" << endl;
exit(1);
}
#if defined(IOMTR_CPU_XSCALE)
if ((ccntfd = InitCCNTInterface()) < 0) {
exit(1);
}
#endif
#endif
iometer[0] = 0;
manager.manager_name[0] = 0;
manager.exclude_filesys[0] = 0;
//provide a temporary global ptr to the version string for Syntax() to use
g_pVersionStringWithDebug = manager.GetVersionString(TRUE);
param.iometer = iometer;
param.manager_name = manager.manager_name;
param.manager_computer_name = manager.prt->network_name;
param.manager_exclude_fs = manager.exclude_filesys;
param.blkdevlist = &manager.blkdevlist;
ParseParam(argc, argv, ¶m);
g_pVersionStringWithDebug = NULL; //should use manager object after this...
iomtr_set_cpu_affinity(param.cpu_affinity);
// If there were command line parameters, indicate that they were recognized.
if ( iometer[0] || manager.manager_name[0] )
{
cout << "\nCommand line parameter(s):" << endl;
if ( iometer[0] ) {
cout << " Looking for Iometer on \"" << iometer << "\"" << endl;
}
if ( manager.manager_name[0] ) {
cout << " New manager name is \"" << manager.manager_name << "\"" << endl;
}
}
if ( manager.exclude_filesys[0] )
{
cout << "\nExcluding the following filesystem types:" << endl;
cout << " \"" << manager.exclude_filesys << "\"" << endl;
}
else
{
strcpy(manager.exclude_filesys, DEFAULT_EXCLUDE_FILESYS);
}
cout << endl;
#if defined(IOMTR_OSFAMILY_UNIX)
#if defined(IOMTR_OS_LINUX)
signal(SIGALRM, SIG_IGN);
#elif defined(IOMTR_OS_SOLARIS)
sigignore(SIGALRM);
#else
#warning ===> WARNING: You have to do some coding here to get the port done!
#endif
// Initialize the lock on UNIX platforms.
if (pthread_mutex_init(&lock_mt, NULL))
{
cout <<"unable to init the lock" << endl;
exit(1);
}
// Block SIGPIPE signal. Needed to ensure that Network worker
// threads don't exit due to a broken pipe signal.
sigset_t sigset;
sigemptyset(&sigset);
sigaddset(&sigset, SIGPIPE);
if (sigprocmask(SIG_BLOCK, &sigset, NULL) < 0)
{
cout << "sigprocmask() call failed." << endl;
cout << "dynamo could be unstable" << endl;
}
//
// the number of file descriptors a process may create can be a small value like 64.
//
struct rlimit rlimitp;
if (getrlimit(RLIMIT_NOFILE, &rlimitp) < 0)
{
cout << "error " << errno << " trying to get rlimit (# file descriptors)" << endl;
}
else
{
// it succeeded. We leave out atleast 25 file descriptors for non-targets
// and compare with the hard limit.
unsigned int targets = MAX_TARGETS + 25;
if ( rlimitp.rlim_max < targets )
{
cout << "Only " << rlimitp.rlim_max << " file descriptors available" << endl;
rlimitp.rlim_cur = rlimitp.rlim_max;
}
else
{
// set the soft limit to the required value.
rlimitp.rlim_cur = targets;
}
if (setrlimit(RLIMIT_NOFILE, &rlimitp) < 0)
{
cout << "error " << errno << " trying to set rlimit (# file descriptors)" << endl;
}
}
// Check for super-user permissions. If not super-user, we
// cannot get many of the info from the kernel.
if (getuid() || geteuid())
{
cout << "Dynamo not running as super-user." << endl;
cout << " All available disks might not be reported " << endl;
cout << " Cannot get TCP statistics from the kernel " << endl;
}
#ifdef IOMTR_SETTING_OVERRIDE_FS
// No command line args specifies destructive testing. Check to see if there
// are any environment variables specifying the same. We need to warn the user.
if (getenv("IOMTR_SETTING_OVERRIDE_FS") != NULL)
{
cout << " ************ WARNING **************" << endl;
cout << " dynamo running in Destructive mode." << endl;
cout << " (overriding the not mounted fs)" << endl;
cout << " ************ WARNING **************" << endl;
}
#endif // IOMTR_SETTING_OVERRIDE_FS
#endif // IOMTR_OSFAMILY_UNIX
#if defined(IOMTR_OSFAMILY_NETWARE)
// Initialize the lock on NetWare platforms.
if (pthread_mutex_init(&lock_mt, NULL))
{
cout <<"unable to init the lock" << endl;
exit(1);
}
#endif
// Ensure, that the endian type of the CPU is detectable
if ( (IsBigEndian() != 0) && (IsBigEndian() != 1) )
{
cout << "===> ERROR: Endian type of the CPU couldn't be detected." << endl;
cout << " [main() in " << __FILE__ << " line " << __LINE__ << "]" << endl;
exit(1);
}
// Entering infinite loop to allow Dynamo to run multiple tests. Outer while loop allows
// Dynamo to be reset from Iometer. If everything works smoothly, resets should be rare.
while (TRUE)
{
// Initializing worker and logging into Iometer director.
if ( !manager.Login( iometer ) )
break;
// Manager will continue to run until an error, or stopped by Iometer.
if ( !manager.Run() )
break; // Stop running when the manager is done.
}
cout << "Ending execution." << endl;
Sleep( 1000 );
#if defined(IOMTR_OS_LINUX)
CleanupIoctlInterface(kstatfd);
#if defined(IOMTR_CPU_XSCALE)
CleanupCCNTInterface(ccntfd);
#endif
#endif
return(0);
}
/*
* This function is called very early on in the Mach startup, from the
* function start_kernel_threads() in osfmk/kern/startup.c. It's called
* in the context of the current (startup) task using a call to the
* function kernel_thread_create() to jump into start_kernel_threads().
* Internally, kernel_thread_create() calls thread_create_internal(),
* which calls uthread_alloc(). The function of uthread_alloc() is
* normally to allocate a uthread structure, and fill out the uu_sigmask,
* uu_context fields. It skips filling these out in the case of the "task"
* being "kernel_task", because the order of operation is inverted. To
* account for that, we need to manually fill in at least the contents
* of the uu_context.vc_ucred field so that the uthread structure can be
* used like any other.
*/
void
bsd_init(void)
{
struct uthread *ut;
unsigned int i;
#if __i386__ || __x86_64__
int error;
#endif
struct vfs_context context;
kern_return_t ret;
struct ucred temp_cred;
#define bsd_init_kprintf(x...) /* kprintf("bsd_init: " x) */
kernel_flock = funnel_alloc(KERNEL_FUNNEL);
if (kernel_flock == (funnel_t *)0 ) {
panic("bsd_init: Failed to allocate kernel funnel");
}
printf(copyright);
bsd_init_kprintf("calling kmeminit\n");
kmeminit();
bsd_init_kprintf("calling parse_bsd_args\n");
parse_bsd_args();
/* Initialize kauth subsystem before instancing the first credential */
bsd_init_kprintf("calling kauth_init\n");
kauth_init();
/* Initialize process and pgrp structures. */
bsd_init_kprintf("calling procinit\n");
procinit();
/* Initialize the ttys (MUST be before kminit()/bsd_autoconf()!)*/
tty_init();
kernproc = &proc0; /* implicitly bzero'ed */
/* kernel_task->proc = kernproc; */
set_bsdtask_info(kernel_task,(void *)kernproc);
/* give kernproc a name */
bsd_init_kprintf("calling process_name\n");
process_name("kernel_task", kernproc);
/* allocate proc lock group attribute and group */
bsd_init_kprintf("calling lck_grp_attr_alloc_init\n");
proc_lck_grp_attr= lck_grp_attr_alloc_init();
proc_lck_grp = lck_grp_alloc_init("proc", proc_lck_grp_attr);
#ifndef CONFIG_EMBEDDED
proc_slock_grp = lck_grp_alloc_init("proc-slock", proc_lck_grp_attr);
proc_fdmlock_grp = lck_grp_alloc_init("proc-fdmlock", proc_lck_grp_attr);
proc_mlock_grp = lck_grp_alloc_init("proc-mlock", proc_lck_grp_attr);
#endif
/* Allocate proc lock attribute */
proc_lck_attr = lck_attr_alloc_init();
#if 0
#if __PROC_INTERNAL_DEBUG
lck_attr_setdebug(proc_lck_attr);
#endif
#endif
#ifdef CONFIG_EMBEDDED
proc_list_mlock = lck_mtx_alloc_init(proc_lck_grp, proc_lck_attr);
proc_klist_mlock = lck_mtx_alloc_init(proc_lck_grp, proc_lck_attr);
lck_mtx_init(&kernproc->p_mlock, proc_lck_grp, proc_lck_attr);
lck_mtx_init(&kernproc->p_fdmlock, proc_lck_grp, proc_lck_attr);
lck_spin_init(&kernproc->p_slock, proc_lck_grp, proc_lck_attr);
#else
proc_list_mlock = lck_mtx_alloc_init(proc_mlock_grp, proc_lck_attr);
proc_klist_mlock = lck_mtx_alloc_init(proc_mlock_grp, proc_lck_attr);
lck_mtx_init(&kernproc->p_mlock, proc_mlock_grp, proc_lck_attr);
lck_mtx_init(&kernproc->p_fdmlock, proc_fdmlock_grp, proc_lck_attr);
lck_spin_init(&kernproc->p_slock, proc_slock_grp, proc_lck_attr);
#endif
execargs_cache_lock = lck_mtx_alloc_init(proc_lck_grp, proc_lck_attr);
execargs_cache_size = bsd_simul_execs;
execargs_free_count = bsd_simul_execs;
execargs_cache = (vm_offset_t *)kalloc(bsd_simul_execs * sizeof(vm_offset_t));
bzero(execargs_cache, bsd_simul_execs * sizeof(vm_offset_t));
if (current_task() != kernel_task)
printf("bsd_init: We have a problem, "
"current task is not kernel task\n");
bsd_init_kprintf("calling get_bsdthread_info\n");
ut = (uthread_t)get_bsdthread_info(current_thread());
#if CONFIG_MACF
/*
* Initialize the MAC Framework
*/
mac_policy_initbsd();
kernproc->p_mac_enforce = 0;
#endif /* MAC */
/*
* Create process 0.
*/
proc_list_lock();
LIST_INSERT_HEAD(&allproc, kernproc, p_list);
kernproc->p_pgrp = &pgrp0;
LIST_INSERT_HEAD(PGRPHASH(0), &pgrp0, pg_hash);
LIST_INIT(&pgrp0.pg_members);
#ifdef CONFIG_EMBEDDED
lck_mtx_init(&pgrp0.pg_mlock, proc_lck_grp, proc_lck_attr);
#else
lck_mtx_init(&pgrp0.pg_mlock, proc_mlock_grp, proc_lck_attr);
#endif
/* There is no other bsd thread this point and is safe without pgrp lock */
LIST_INSERT_HEAD(&pgrp0.pg_members, kernproc, p_pglist);
kernproc->p_listflag |= P_LIST_INPGRP;
kernproc->p_pgrpid = 0;
pgrp0.pg_session = &session0;
pgrp0.pg_membercnt = 1;
session0.s_count = 1;
session0.s_leader = kernproc;
session0.s_listflags = 0;
#ifdef CONFIG_EMBEDDED
lck_mtx_init(&session0.s_mlock, proc_lck_grp, proc_lck_attr);
#else
lck_mtx_init(&session0.s_mlock, proc_mlock_grp, proc_lck_attr);
#endif
LIST_INSERT_HEAD(SESSHASH(0), &session0, s_hash);
proc_list_unlock();
#if CONFIG_LCTX
kernproc->p_lctx = NULL;
#endif
kernproc->task = kernel_task;
kernproc->p_stat = SRUN;
kernproc->p_flag = P_SYSTEM;
kernproc->p_nice = NZERO;
kernproc->p_pptr = kernproc;
TAILQ_INIT(&kernproc->p_uthlist);
TAILQ_INSERT_TAIL(&kernproc->p_uthlist, ut, uu_list);
kernproc->sigwait = FALSE;
kernproc->sigwait_thread = THREAD_NULL;
kernproc->exit_thread = THREAD_NULL;
kernproc->p_csflags = CS_VALID;
/*
* Create credential. This also Initializes the audit information.
*/
bsd_init_kprintf("calling bzero\n");
bzero(&temp_cred, sizeof(temp_cred));
temp_cred.cr_ngroups = 1;
temp_cred.cr_audit.as_aia_p = &audit_default_aia;
/* XXX the following will go away with cr_au */
temp_cred.cr_au.ai_auid = AU_DEFAUDITID;
bsd_init_kprintf("calling kauth_cred_create\n");
kernproc->p_ucred = kauth_cred_create(&temp_cred);
/* give the (already exisiting) initial thread a reference on it */
bsd_init_kprintf("calling kauth_cred_ref\n");
kauth_cred_ref(kernproc->p_ucred);
ut->uu_context.vc_ucred = kernproc->p_ucred;
ut->uu_context.vc_thread = current_thread();
TAILQ_INIT(&kernproc->p_aio_activeq);
TAILQ_INIT(&kernproc->p_aio_doneq);
kernproc->p_aio_total_count = 0;
kernproc->p_aio_active_count = 0;
bsd_init_kprintf("calling file_lock_init\n");
file_lock_init();
#if CONFIG_MACF
mac_cred_label_associate_kernel(kernproc->p_ucred);
mac_task_label_update_cred (kernproc->p_ucred, (struct task *) kernproc->task);
#endif
/* Create the file descriptor table. */
filedesc0.fd_refcnt = 1+1; /* +1 so shutdown will not _FREE_ZONE */
kernproc->p_fd = &filedesc0;
filedesc0.fd_cmask = cmask;
filedesc0.fd_knlistsize = -1;
filedesc0.fd_knlist = NULL;
filedesc0.fd_knhash = NULL;
filedesc0.fd_knhashmask = 0;
/* Create the limits structures. */
kernproc->p_limit = &limit0;
for (i = 0; i < sizeof(kernproc->p_rlimit)/sizeof(kernproc->p_rlimit[0]); i++)
limit0.pl_rlimit[i].rlim_cur =
limit0.pl_rlimit[i].rlim_max = RLIM_INFINITY;
limit0.pl_rlimit[RLIMIT_NOFILE].rlim_cur = NOFILE;
limit0.pl_rlimit[RLIMIT_NPROC].rlim_cur = maxprocperuid;
limit0.pl_rlimit[RLIMIT_NPROC].rlim_max = maxproc;
limit0.pl_rlimit[RLIMIT_STACK] = vm_initial_limit_stack;
limit0.pl_rlimit[RLIMIT_DATA] = vm_initial_limit_data;
limit0.pl_rlimit[RLIMIT_CORE] = vm_initial_limit_core;
limit0.pl_refcnt = 1;
kernproc->p_stats = &pstats0;
kernproc->p_sigacts = &sigacts0;
/*
* Charge root for two processes: init and mach_init.
*/
bsd_init_kprintf("calling chgproccnt\n");
(void)chgproccnt(0, 1);
/*
* Allocate a kernel submap for pageable memory
* for temporary copying (execve()).
*/
{
vm_offset_t minimum;
bsd_init_kprintf("calling kmem_suballoc\n");
ret = kmem_suballoc(kernel_map,
&minimum,
(vm_size_t)bsd_pageable_map_size,
TRUE,
VM_FLAGS_ANYWHERE,
&bsd_pageable_map);
if (ret != KERN_SUCCESS)
panic("bsd_init: Failed to allocate bsd pageable map");
}
/*
* Initialize buffers and hash links for buffers
*
* SIDE EFFECT: Starts a thread for bcleanbuf_thread(), so must
* happen after a credential has been associated with
* the kernel task.
*/
bsd_init_kprintf("calling bsd_bufferinit\n");
bsd_bufferinit();
/* Initialize the execve() semaphore */
bsd_init_kprintf("calling semaphore_create\n");
if (ret != KERN_SUCCESS)
panic("bsd_init: Failed to create execve semaphore");
/*
* Initialize the calendar.
*/
bsd_init_kprintf("calling IOKitInitializeTime\n");
IOKitInitializeTime();
if (turn_on_log_leaks && !new_nkdbufs)
new_nkdbufs = 200000;
start_kern_tracing(new_nkdbufs);
if (turn_on_log_leaks)
log_leaks = 1;
bsd_init_kprintf("calling ubc_init\n");
ubc_init();
/* Initialize the file systems. */
bsd_init_kprintf("calling vfsinit\n");
vfsinit();
#if SOCKETS
/* Initialize per-CPU cache allocator */
mcache_init();
/* Initialize mbuf's. */
bsd_init_kprintf("calling mbinit\n");
mbinit();
net_str_id_init(); /* for mbuf tags */
#endif /* SOCKETS */
/*
* Initializes security event auditing.
* XXX: Should/could this occur later?
*/
#if CONFIG_AUDIT
bsd_init_kprintf("calling audit_init\n");
audit_init();
#endif
/* Initialize kqueues */
bsd_init_kprintf("calling knote_init\n");
knote_init();
/* Initialize for async IO */
bsd_init_kprintf("calling aio_init\n");
aio_init();
/* Initialize pipes */
bsd_init_kprintf("calling pipeinit\n");
pipeinit();
/* Initialize SysV shm subsystem locks; the subsystem proper is
* initialized through a sysctl.
*/
#if SYSV_SHM
bsd_init_kprintf("calling sysv_shm_lock_init\n");
sysv_shm_lock_init();
#endif
#if SYSV_SEM
bsd_init_kprintf("calling sysv_sem_lock_init\n");
sysv_sem_lock_init();
#endif
#if SYSV_MSG
bsd_init_kprintf("sysv_msg_lock_init\n");
sysv_msg_lock_init();
#endif
bsd_init_kprintf("calling pshm_lock_init\n");
pshm_lock_init();
bsd_init_kprintf("calling psem_lock_init\n");
psem_lock_init();
pthread_init();
/* POSIX Shm and Sem */
bsd_init_kprintf("calling pshm_cache_init\n");
pshm_cache_init();
bsd_init_kprintf("calling psem_cache_init\n");
psem_cache_init();
bsd_init_kprintf("calling time_zone_slock_init\n");
time_zone_slock_init();
/* Stack snapshot facility lock */
stackshot_lock_init();
/*
* Initialize protocols. Block reception of incoming packets
* until everything is ready.
*/
bsd_init_kprintf("calling sysctl_register_fixed\n");
sysctl_register_fixed();
bsd_init_kprintf("calling sysctl_mib_init\n");
sysctl_mib_init();
#if NETWORKING
bsd_init_kprintf("calling dlil_init\n");
dlil_init();
bsd_init_kprintf("calling proto_kpi_init\n");
proto_kpi_init();
#endif /* NETWORKING */
#if SOCKETS
bsd_init_kprintf("calling socketinit\n");
socketinit();
bsd_init_kprintf("calling domaininit\n");
domaininit();
#endif /* SOCKETS */
kernproc->p_fd->fd_cdir = NULL;
kernproc->p_fd->fd_rdir = NULL;
#if CONFIG_EMBEDDED
/* Initialize kernel memory status notifications */
bsd_init_kprintf("calling kern_memorystatus_init\n");
kern_memorystatus_init();
#endif
#ifdef GPROF
/* Initialize kernel profiling. */
kmstartup();
#endif
/* kick off timeout driven events by calling first time */
thread_wakeup(&lbolt);
timeout(lightning_bolt, 0, hz);
bsd_init_kprintf("calling bsd_autoconf\n");
bsd_autoconf();
#if CONFIG_DTRACE
dtrace_postinit();
#endif
/*
* We attach the loopback interface *way* down here to ensure
* it happens after autoconf(), otherwise it becomes the
* "primary" interface.
*/
#include <loop.h>
#if NLOOP > 0
bsd_init_kprintf("calling loopattach\n");
loopattach(); /* XXX */
#endif
#if PFLOG
/* Initialize packet filter log interface */
pfloginit();
#endif /* PFLOG */
#if NETHER > 0
/* Register the built-in dlil ethernet interface family */
bsd_init_kprintf("calling ether_family_init\n");
ether_family_init();
#endif /* ETHER */
#if NETWORKING
/* Call any kext code that wants to run just after network init */
bsd_init_kprintf("calling net_init_run\n");
net_init_run();
/* register user tunnel kernel control handler */
utun_register_control();
#endif /* NETWORKING */
bsd_init_kprintf("calling vnode_pager_bootstrap\n");
vnode_pager_bootstrap();
#if 0
/* XXX Hack for early debug stop */
printf("\nabout to sleep for 10 seconds\n");
IOSleep( 10 * 1000 );
/* Debugger("hello"); */
#endif
bsd_init_kprintf("calling inittodr\n");
inittodr(0);
#if CONFIG_EMBEDDED
{
/* print out early VM statistics */
kern_return_t kr1;
vm_statistics_data_t stat;
mach_msg_type_number_t count;
count = HOST_VM_INFO_COUNT;
kr1 = host_statistics(host_self(),
HOST_VM_INFO,
(host_info_t)&stat,
&count);
kprintf("Mach Virtual Memory Statistics (page size of 4096) bytes\n"
"Pages free:\t\t\t%u.\n"
"Pages active:\t\t\t%u.\n"
"Pages inactive:\t\t\t%u.\n"
"Pages wired down:\t\t%u.\n"
"\"Translation faults\":\t\t%u.\n"
"Pages copy-on-write:\t\t%u.\n"
"Pages zero filled:\t\t%u.\n"
"Pages reactivated:\t\t%u.\n"
"Pageins:\t\t\t%u.\n"
"Pageouts:\t\t\t%u.\n"
"Object cache: %u hits of %u lookups (%d%% hit rate)\n",
stat.free_count,
stat.active_count,
stat.inactive_count,
stat.wire_count,
stat.faults,
stat.cow_faults,
stat.zero_fill_count,
stat.reactivations,
stat.pageins,
stat.pageouts,
stat.hits,
stat.lookups,
(stat.hits == 0) ? 100 :
((stat.lookups * 100) / stat.hits));
}
#endif /* CONFIG_EMBEDDED */
/* Mount the root file system. */
while( TRUE) {
int err;
bsd_init_kprintf("calling setconf\n");
setconf();
bsd_init_kprintf("vfs_mountroot\n");
if (0 == (err = vfs_mountroot()))
break;
rootdevice[0] = '\0';
#if NFSCLIENT
if (mountroot == netboot_mountroot) {
PE_display_icon( 0, "noroot"); /* XXX a netboot-specific icon would be nicer */
vc_progress_set(FALSE, 0);
for (i=1; 1; i*=2) {
printf("bsd_init: failed to mount network root, error %d, %s\n",
err, PE_boot_args());
printf("We are hanging here...\n");
IOSleep(i*60*1000);
}
/*NOTREACHED*/
}
#endif
printf("cannot mount root, errno = %d\n", err);
boothowto |= RB_ASKNAME;
}
IOSecureBSDRoot(rootdevice);
context.vc_thread = current_thread();
context.vc_ucred = kernproc->p_ucred;
mountlist.tqh_first->mnt_flag |= MNT_ROOTFS;
bsd_init_kprintf("calling VFS_ROOT\n");
/* Get the vnode for '/'. Set fdp->fd_fd.fd_cdir to reference it. */
if (VFS_ROOT(mountlist.tqh_first, &rootvnode, &context))
panic("bsd_init: cannot find root vnode: %s", PE_boot_args());
rootvnode->v_flag |= VROOT;
(void)vnode_ref(rootvnode);
(void)vnode_put(rootvnode);
filedesc0.fd_cdir = rootvnode;
#if NFSCLIENT
if (mountroot == netboot_mountroot) {
int err;
/* post mount setup */
if ((err = netboot_setup()) != 0) {
PE_display_icon( 0, "noroot"); /* XXX a netboot-specific icon would be nicer */
vc_progress_set(FALSE, 0);
for (i=1; 1; i*=2) {
printf("bsd_init: NetBoot could not find root, error %d: %s\n",
err, PE_boot_args());
printf("We are hanging here...\n");
IOSleep(i*60*1000);
}
/*NOTREACHED*/
}
}
#endif
#if CONFIG_IMAGEBOOT
/*
* See if a system disk image is present. If so, mount it and
* switch the root vnode to point to it
*/
if(imageboot_needed()) {
int err;
/* An image was found */
if((err = imageboot_setup())) {
/*
* this is not fatal. Keep trying to root
* off the original media
*/
printf("%s: imageboot could not find root, %d\n",
__FUNCTION__, err);
}
}
#endif /* CONFIG_IMAGEBOOT */
/* set initial time; all other resource data is already zero'ed */
microtime(&kernproc->p_start);
kernproc->p_stats->p_start = kernproc->p_start; /* for compat */
#if DEVFS
{
char mounthere[] = "/dev"; /* !const because of internal casting */
bsd_init_kprintf("calling devfs_kernel_mount\n");
devfs_kernel_mount(mounthere);
}
#endif /* DEVFS */
/* Initialize signal state for process 0. */
bsd_init_kprintf("calling siginit\n");
siginit(kernproc);
bsd_init_kprintf("calling bsd_utaskbootstrap\n");
bsd_utaskbootstrap();
#if defined(__LP64__)
kernproc->p_flag |= P_LP64;
printf("Kernel is LP64\n");
#endif
#if __i386__ || __x86_64__
/* this should be done after the root filesystem is mounted */
error = set_archhandler(kernproc, CPU_TYPE_POWERPC);
// 10/30/08 - gab: <rdar://problem/6324501>
// if default 'translate' can't be found, see if the understudy is available
if (ENOENT == error) {
strlcpy(exec_archhandler_ppc.path, kRosettaStandIn_str, MAXPATHLEN);
error = set_archhandler(kernproc, CPU_TYPE_POWERPC);
}
if (error) /* XXX make more generic */
exec_archhandler_ppc.path[0] = 0;
#endif
bsd_init_kprintf("calling mountroot_post_hook\n");
/* invoke post-root-mount hook */
if (mountroot_post_hook != NULL)
mountroot_post_hook();
#if 0 /* not yet */
consider_zone_gc(FALSE);
#endif
bsd_init_kprintf("done\n");
}
int main(int argc, char **argv)
{
long cache_hits, cache_misses;
/* Parse command line, exit on error */
parse_args(argc, argv);
if (!opt_no_banner) {
fprintf(stderr,
"VNC Reflector %s. Copyright (C) 2001-2003 HorizonLive.com, Inc.\n\n"
"HorizonLive provides e-Learning and collaborative synchronous presentation\n"
"solutions in a totally Web-based environment. For more information about\n"
"HorizonLive, please see our website at http://www.horizonlive.com/\n\n",
VERSION);
}
log_write(LL_MSG, "log_open");
if (!log_open(opt_log_filename, opt_file_loglevel,
(opt_foreground) ? opt_stderr_loglevel : -1)) {
fprintf(stderr, "%s: error opening log file (ignoring this error)\n",
argv[0]);
}
log_write(LL_MSG, "Starting VNC Reflector %s", VERSION);
/* Fork the process to the background if necessary */
if (!opt_foreground) {
if (!opt_no_banner) {
fprintf(stderr, "Starting in the background, "
"see the log file for errors and other messages.\n");
}
if (getpid() != 1) {
signal(SIGTTIN, SIG_IGN);
signal(SIGTTOU, SIG_IGN);
signal(SIGTSTP, SIG_IGN);
if (fork ())
return 0;
setsid();
}
close(0);
close(1);
close(2);
log_write(LL_INFO, "Switched to the background mode");
}
log_write(LL_MSG, "init_screen_info()");
/* Initialization */
if (init_screen_info()) {
log_write(LL_MSG, "read_password_file()");
read_password_file();
set_host_encodings(opt_request_tight, opt_tight_level);
set_client_passwords(opt_client_password, opt_client_ro_password);
fbs_set_prefix(opt_fbs_prefix, opt_join_sessions);
set_active_file(opt_active_filename);
set_actions_file(opt_actions_filename);
log_write(LL_INFO, "---------- haciendo bind -----------");
aio_init();
if (opt_bind_ip != NULL) {
if (aio_set_bind_address(opt_bind_ip)) {
log_write(LL_INFO, "Would bind listening sockets to address %s",
opt_bind_ip);
} else {
log_write(LL_WARN, "Illegal address to bind listening sockets to: %s",
opt_bind_ip);
}
}
log_write(LL_INFO, "----------main.c-----------");
/* Main work */
if (connect_to_host(opt_host_info_file, opt_cl_listen_port)) {
if (write_pid_file()) {
set_control_signals();
aio_mainloop();
remove_pid_file();
}
}
/* Cleanup */
if (g_framebuffer != NULL) {
log_write(LL_DETAIL, "Freeing framebuffer and associated structures");
free(g_framebuffer);
free_enc_cache();
}
if (g_screen_info.name != NULL)
free(g_screen_info.name);
get_hextile_caching_stats(&cache_hits, &cache_misses);
if (cache_hits + cache_misses != 0) {
log_write(LL_INFO, "Hextile BGR233 caching efficiency: %d%%",
(int)((cache_hits * 100 + (cache_hits + cache_misses) / 2)
/ (cache_hits + cache_misses)));
}
}
log_write(LL_MSG, "Terminating");
/* Close logs */
if (!log_close() && opt_foreground) {
fprintf(stderr, "%s: error closing log file (ignoring this error)\n",
argv[0]);
}
/* Done */
exit(1);
}
int main(void)
{
int fd ;
aio_thread_t *aio_thread ;
aio_req_queue_t *aio_req_q ;
u_int8_t *msg ;
aio_msg_t *aio_msg ;
int i ;
size_t slen ;
status_t status ;
int signal_stat ;
void *tmp ;
void *tmp___0 ;
void *tmp___1 ;
{
#line 229
fd = open("/tmp/aio.out", 577, 448);
#line 230
if (fd < 0) {
#line 232
perror("file open failed");
#line 233
exit(1);
}
#line 235
aio_fd = fd;
#line 237
aio_init();
#line 239
i = 0;
#line 239
while (i < 10) {
#line 245
tmp = malloc((size_t )128);
#line 245
msg = (u_int8_t *)tmp;
#line 246
if ((unsigned long )msg == (unsigned long )((void *)0)) {
#line 248
perror("Malloc");
#line 249
exit(1);
}
#line 252
bzero((void *)msg, (size_t )128);
#line 254
sprintf((char * __restrict )msg, (char const * __restrict )"%s: AIO test iteration %d\n",
"main", i);
#line 256
tmp___0 = malloc(sizeof(aio_msg_t ));
#line 256
aio_msg = (aio_msg_t *)tmp___0;
#line 257
if ((unsigned long )aio_msg == (unsigned long )((void *)0)) {
#line 259
perror("Malloc2");
#line 260
exit(1);
}
#line 263
slen = strlen((char const *)msg);
#line 265
aio_msg->size = slen;
#line 266
aio_msg->msg = msg;
#line 268
tmp___1 = queue_peek(aio_thread_q, & status);
#line 268
aio_thread = (aio_thread_t *)tmp___1;
#line 269
if ((unsigned long )aio_thread == (unsigned long )((void *)0)) {
#line 271
perror("queue_peek");
#line 272
exit(1);
}
#line 275
aio_req_q = aio_thread->req_queue;
#line 277
status = queue_enqueue_ts(aio_req_q->queue, & aio_msg->link);
#line 278
if (status != 0U) {
#line 280
perror("enqueue");
#line 281
exit(1);
}
#line 284
signal_stat = pthread_cond_signal(& aio_req_q->cond);
#line 285
if (signal_stat < 0) {
#line 287
perror("cond_sig");
#line 288
exit(1);
}
#line 239
i ++;
}
#line 292
sleep(1U);
#line 294
exit(0);
}
}