/* static */ void
TypeMgrServer::ClassInit(VPNum vp)
{
if (vp!=0) return; // nothing to do on second proc
TypeMgrServer *typeMgrPtr;
typeMgrPtr = new TypeMgrServer();
// initialize the TypeMgr structure
typeMgrPtr->lock.init();
typeMgrPtr->freeEntries = NULL;
for (uval i= 0; i<TYPE_MGR_HASHNUM; i++) {
typeMgrPtr->hashtab[i] = NULL;
}
typeMgrPtr->backupServer = 0;
// now register ourselves in the global object table
CObjRootSingleRepPinned::Create(typeMgrPtr, GOBJ(TheTypeMgrRef));
// kernel initialization path
// now register the default types immediately by accessing their
// typeid
(void)StubObj::typeID();
(void)MetaObj::typeID();
XHandle xhandle =
MetaTypeMgrServer::createXHandle(typeMgrPtr->getRef(),
GOBJ(TheProcessRef), 0, 0);
typeMgrPtr->oh.initWithMyPID(xhandle);
}
G_obj *gtk__vscrollbar()
{
G_obj *adj = GTK().gtk_adjustment_new(250, 0, 1000, 1, 1, 500);
G_obj *w = GTK().gtk_vscrollbar_new(adj);
GOBJ().g_object_unref(adj);
return w;
}
/*static*/ SysStatus
ResMgrWrapper::Create(ObjectHandle serverOH)
{
ResMgrWrapper *wrapper = new ResMgrWrapper;
tassertMsg(wrapper != NULL, "failed to create res mgr wrapper\n");
wrapper->stub.setOH(serverOH);
new CObjRootSingleRep(wrapper, (RepRef)GOBJ(TheResourceManagerRef));
//;;cprintf("successfully created res manager wrapper\n");
return 0;
}
VirtFileImp(uval rsize) {
read_counter = 0;
write_counter = 0;
read_size = rsize;
data = '.';
CObjRootSingleRep::Create(this);
XHandle xHandle;
// initialize xhandle, use the same for everyone
xHandle = MetaVirtFile::createXHandle(getRef(), GOBJ(TheProcessRef),
MetaVirtFile::none,
MetaVirtFile::none);
oh.initWithMyPID(xHandle);
}
/*static*/ void
MemTrans::ClassInit(VPNum vp)
{
if (vp!=0) return;
MetaProcessClient::
createXHandle((ObjRef)GOBJ(TheProcessRef),
_KERNEL_PID,
MetaObj::controlAccess|MetaProcessClient::destroy
|MetaProcessClient::search |MetaObj::globalHandle,
MetaProcessClient::search);
createLock.init();
}
/*static*/ void
DispatcherMgr::ClassInit(DispatcherID dspid)
{
SysStatus rc;
if (dspid == SysTypes::DSPID(0,0)) {
DispatcherMgr *const rep = new DispatcherMgr;
tassert(rep != NULL, err_printf("new DispatcherMgr failed\n"));
rep->init();
CObjRootSingleRep *const root =
new CObjRootSingleRep(rep, RepRef(GOBJ(TheDispatcherMgrRef)));
tassert(root != NULL, err_printf("new CObjRootSingleRep failed\n"));
}
rc = DREFGOBJ(TheDispatcherMgrRef)->enter(dspid, extRegsLocal.dispatcher);
tassert(_SUCCESS(rc), err_printf("enter failed.\n"));
}
/*static*/ SysStatus
ResMgrWrapper::CreateAndRegisterFirstDispatcher()
{
ObjectHandle oh;
SysStatus rc;
ResMgrWrapper *wrapper = new ResMgrWrapper;
tassert(wrapper != NULL, err_printf("failed to create res mgr wrapper\n"));
rc = StubResMgr::_CreateAndRegisterFirstDispatcher(oh);
passertMsg(_SUCCESS(rc), "failed to create resource manager wrapper.\n");
wrapper->stub.setOH(oh);
new CObjRootSingleRep(wrapper, (RepRef)GOBJ(TheResourceManagerRef));
//;;cprintf("successfully created res manager wrapper\n");
return 0;
}
/* static */ SysStatus
LinuxPTYServer::ClassInit(VPNum vp)
{
if (vp==0) {
CharDevOpener::charDevs = new CharDevOpener::DeviceHash;
MetaStreamServer::init();
MetaDevOpener::init();
}
ConfigureLinuxEnv(vp, GOBJ(ThePageAllocatorRef));
ConfigureLinuxGeneric(vp);
if (vp==0) {
LinuxEnv le(SysCall);
vfs_caches_init(0x1<<8);
driver_init();
console_init();
ptyDir = k42devfs_mk_dir("pty");
ptsDir = k42devfs_mk_dir("pts");
RegisterInitCall(new InitCall(&__initcall_tty_init));
RegisterInitCall(new InitCall(&__initcall_pty_init));
RegisterInitCall(new InitCall(&__initcall_tty_class_init));
LinuxEnvSuspend();
VPNum vpCnt = _SGETUVAL(DREFGOBJ(TheProcessRef)->vpCount());
for (VPNum i = 1; i < vpCnt; i++) {
LinuxStartVP(i, LinuxPTYServer::ClassInit);
}
LinuxEnvResume();
ConfigureLinuxFinal(0);
}
return 0;
}
/* static */ void
NameTreeLinuxUnion::Create(char *cPathToMount, ObjectHandle primOH,
ObjectHandle secOH,
char *desc, uval descLen,
uval isCoverable /* = 1 */)
{
ObjRef objRef;
XHandle xHandle;
PathNameDynamic<AllocGlobal> *pathToMount;
uval pathLenToMount;
SysStatus rc;
NameTreeLinuxUnion *obj;
obj = new NameTreeLinuxUnion;
objRef = (Obj **)CObjRootSingleRep::Create(obj);
// initialize xhandle, use the same for everyone
xHandle = MetaNameTreeLinux::createXHandle(objRef, GOBJ(TheProcessRef),
MetaNameTreeLinux::none,
MetaNameTreeLinux::lookup);
obj->oh.initWithMyPID(xHandle);
obj->primNT.setOH(primOH);
obj->secNT.setOH(secOH);
pathLenToMount = PathNameDynamic<AllocGlobal>::Create(
cPathToMount, strlen(cPathToMount), 0, 0, pathToMount, PATH_MAX+1);
// register with mount point server
rc = DREFGOBJ(TheMountPointMgrRef)->registerMountPoint(
pathToMount, pathLenToMount, obj->oh, NULL, 0, desc, descLen,
isCoverable);
tassert(_SUCCESS(rc), err_printf("register mount point failed\n"));
// emptyPath doesn't need to be freed, but pathToMount needs to
pathToMount->destroy(PATH_MAX+1);
}
/* static */ SysStatus
XHandleTrans::ClassInit(VPNum vp)
{
SysStatus rc;
uval ptr;
XHandleTrans *theXHandleTransPtr;
if (vp != 0) {
// tassertWrn(0, "processor %d sharing xhandle table\n", vp);
return 0;
}
/*
* We allocate virtual memory for the entire quasi-infinite xhandle table,
* but we initialize just the first chunk of the table. Subsequent chunks
* are initialized as needed.
*/
rc = DREFGOBJ(ThePageAllocatorRef)->
allocPagesAligned(ptr, XHANDLE_TABLE_MAX*sizeof(XBaseObj),
sizeof(XBaseObj));
tassert(_SUCCESS(rc), err_printf("xhandle table allocation failed.\n"));
/*
* We initialize the first chunk from 1 rather than 0 to avoid putting
* XHANDLE_NONE on the free list.
*/
tassert(XHANDLE_NONE_IDX == 0, err_printf("XHANDLE_NONE_IDX not 0?\n"));
XBaseObj *free, *dummy;
// We reserve a bunch of XHandle slots for global clustered objects
// This provides free xhandles for global clustered objects
InitXHandleRange((XBaseObj *) ptr, CObjGlobals::numReservedEntries,
XHANDLE_TABLE_INCREMENT,
free, dummy);
// Must manually zero the reserved entries for global objects
// since they are not part of the regular initialzation
memset((void *)ptr, 0, CObjGlobals::numReservedEntries * sizeof(XBaseObj));
theXHandleTransPtr = new XHandleTrans;
theXHandleTransPtr->xhandleTable = (XBaseObj *) ptr;
theXHandleTransPtr->xhandleTableLimit = XHANDLE_TABLE_INCREMENT;
theXHandleTransPtr->freeEntries = free;
theXHandleTransPtr->oldEntries.init(0);
theXHandleTransPtr->removedEntries = 0;
theXHandleTransPtr->numberRemoved = 0;
new CObjRootSingleRep(theXHandleTransPtr,
RepRef(GOBJ(TheXHandleTransRef)));
/*
* Facts about the xhandle table are shadowed in the static XHandleTable
* and in all the dispatchers.
*/
XHandleTable = theXHandleTransPtr->xhandleTable;
rc = DREFGOBJ(TheDispatcherMgrRef)->
publishXHandleTable(theXHandleTransPtr->xhandleTable,
theXHandleTransPtr->xhandleTableLimit);
tassert(_SUCCESS(rc), err_printf("publishXHandleTable failed.\n"));
return 0;
}
