C++ ObjectHandle::xhandle方法代码示例

/* static */ SysStatus
RegionReplicated::_CreateFixedLenExtDyn(uval& regionVaddr, uval regionSize,
					uval alignmentreq, ObjectHandle frOH,
					uval fileOffset, uval accessreq,
					XHandle target, ObjectHandle tsOH,
					RegionType::Type regionType,
					__CALLER_PID callerPID)
{
    RegionRef ref;
    ProcessRef pref=0;
    SysStatus rc;
    FCMRef fcmRef;
    TypeID type;
    ObjRef objRef;
    FRRef frRef;

    rc = RegionDefault::PrefFromTarget(target, callerPID, pref);
    _IF_FAILURE_RET(rc);

    rc = XHandleTrans::XHToInternal(frOH.xhandle(), callerPID,
				    MetaObj::attach, objRef, type);
    tassertWrn(_SUCCESS(rc), "RegionReplicated failed XHToInternal\n");
    _IF_FAILURE_RET(rc);

    // verify that type is of FRComp - we'd really like just FR
// FIXMEXX talk to Orran, the brilliant, charming, ..
    if (!MetaFR::isBaseOf(type)) {
	tassertWrn(0, "object handle <%lx,%lx> not of correct type\n",
		   frOH.commID(), frOH.xhandle());
	return _SERROR(1542, 0, EINVAL);
    }

    //FIXME check xobj to make sure it matches our processID

    frRef = (FRRef)objRef;

    rc = RegionReplicated::CreateFixedLen(
	ref, pref, regionVaddr,
	regionSize, alignmentreq, frRef, fileOffset,
	(AccessMode::mode)accessreq);

    // FIXME: Kludge for enabling dyn-switch
#if 0
    CObjRoot *partitionedFCMRoot = 0;
    rc = FCMPartitionedTrivial::Create(partitionedFCMRoot, fcmRef, regionSize,
				       /* number of cache lines per rep */ 256,
				       /* associativity of each line */    4);
    tassert(_SUCCESS(rc), err_printf("Replicated Trivial fcm create\n"));

    PMRef pmRef;
    rc = DREF(pref)->getPM(pmRef);
    tassert(_SUCCESS(rc), ;);

int
main()
{
    NativeProcess();

    SysStatus rc;
    ObjectHandle oh;

    UsrTstRef ref = UsrTst::Create();

    rc = DREF(ref)->giveAccessByServer(oh, _KERNEL_PID);
    tassert(_SUCCESS(rc), err_printf("woops\n"));
    printf("testDisabledIPC: calling kernel with oh %lx %lx\n",
	   oh.commID(), oh.xhandle());
    Scheduler::Disable();
    ALLOW_PRIMITIVE_PPC();
    DREFGOBJ(TheProcessRef)->testUserIPC(oh);
    UN_ALLOW_PRIMITIVE_PPC();
    Scheduler::Enable();
    printf("testDisabledIPC: done calling kernel\n");
    for (uval i = 0; i < 20; i++) {
	printf("testDisabledIPC: sleeping (%ld)\n", i);
	Scheduler::DelayMicrosecs(5000);
    }
    printf("testDisabledIPC: terminating\n");
    return 0;
}

/* static */ SysStatus
LinuxPTYServer::Create(ObjectHandle &oh, TypeID &type,
		       dev_t num, ProcessID pid, uval oflag)
{

    SysStatus rc;
    int ret;
    LinuxPTYServer *pty = new LinuxPTYServer();
    LinuxPTYServerRef ref;

    pty->devNum = num;
    pty->availMask = FileLinux::INVALID;
    CObjRootSingleRep::Create(pty);
    ref = (LinuxPTYServerRef)pty->getRef();
    pty->readCB.obj = ref;
    pty->writeCB.obj = ref;

    rc = DREF(ref)->giveAccessByServer(oh, pid);
    if (_FAILURE(rc)) {
	DREF(ref)->destroy();
	return rc;
    }

    ProcessLinux::LinuxInfo info;
    rc = DREFGOBJ(TheProcessLinuxRef)->getInfoNativePid(pid, info);
    tassertMsg(_SUCCESS(rc),
	       "Couldn't get info about k42 process 0x%lx\n", pid);

    PTYTaskInfo ptyTI(info.pid, info.pgrp, info.session, info.tty,
		      info.pid == info.session);
    LinuxEnv sc(SysCall, ptyTI.t);
    ret = ttydev_open(&pty->oli, num, &pty->readQ, &pty->writeQ,
		      oflag|O_NONBLOCK);

    if (ret<0) {
	rc = _SERROR(2365, 0, -ret);
	// releaseAccess will trigger destroy
	DREF(ref)->releaseAccess(oh.xhandle());
    } else {
	pty->devNum = ret;

	//Put ourselves on wait queue with TTYEvents object that will
	// generate callbacks instead of waking threads
	if (pty->readQ && list_empty(&pty->readCB.task_list)) {
	    add_wait_queue(pty->readQ, &pty->readCB);
	}

	if (pty->writeQ && list_empty(&pty->writeCB.task_list)) {
	    add_wait_queue(pty->writeQ, &pty->writeCB);
	}

	type = (TypeID)new_encode_dev(pty->devNum);
    }
    return rc;
}

/* static */ SysStatus
FileLinuxVirtFile::LazyReOpen(FileLinuxRef &flRef, ObjectHandle oh, char *buf,
			      uval bufLen)
{
    SysStatus rc;
    LazyReOpenData *d = (LazyReOpenData *)buf;
    tassertMsg((bufLen == sizeof(LazyReOpenData)), "got back bad len\n");
    err_printf("FLVF: lazy re open: %lx\n",oh.xhandle());
    rc = Create(flRef, oh, d->openFlags);
    return rc;
}

/* virtual */ SysStatus
MemTrans::giveAccessSetClientData(ObjectHandle &oh,
				  ProcessID toProcID,
				  AccessRights match,
				  AccessRights nomatch,
				  TypeID type)
{
    SysStatus rc;
    ClientData *clientData = new ClientData(toProcID);
    rc =  giveAccessInternal(oh, toProcID, match, nomatch,
			     type, (uval)clientData);
    if (_FAILURE(rc)) {
	delete clientData;
    }

    // Remember the process binding
    BaseProcessRef pref;

    rc = DREFGOBJ(TheProcessSetRef)->getRefFromPID(toProcID,pref);

    _IF_FAILURE_RET_VERBOSE(rc);

    XHandle remote = oh.xhandle();

    //Add ref count for xhandle
    incRefCount();

    rc = DREF(pref)->addSMT(getRef(), remote, key);

    _IF_FAILURE_RET(rc);

    clientData->givenOH = oh;
    cdHash.add(toProcID, clientData);
    dprintf("%s: add xh: %lx -> %ld\n",__func__,oh.xhandle(),toProcID);
    return rc;
}

/* virtual */ void
StreamServerConsole::startLoginShell(ObjectHandle &oh, ProcessID initPID)
{
    SysStatus rc;
    lock();
    rc = giveAccessByClient(oh, initPID);
    tassertMsg(_SUCCESS(rc), "woops %lx\n", rc);

    // Mark login handle
    login = oh.xhandle();

    // now start the polling read
    Scheduler::ScheduleFunction(StreamServerConsole::ReadFromConsole,
				(uval)this);
    unlock();
}

/* virtual */ SysStatus
MemTrans::init(ProcessID partner, XHandle &remoteX,
	       uval size, MTEvents *handler)
{
    debug = 0;
    SysStatus rc = 0;
    CObjRootSingleRep::Create(this);
    uval addr = 0;
    ObjectHandle myFRInt;
    ObjectHandle localOH;
    ObjectHandle remoteOH;
    localSize = size;

    //Ref count is 1 --- for whoever created this object
    refCount = 1;

    allocLock.init();

    cbs = handler;

    // Lock out allocations until we're done initialization
    AutoLock<LockType> al(&allocLock);

    // Give other process access to this MT
    rc = giveAccessByServer(localOH, partner);

    _IF_FAILURE_RET(rc);

    remoteX = localOH.xhandle();


    usedPages.append(new PageUse(localSize/PAGE_SIZE, 0));

    // Create FR for local-side memory area (that will be exported)
    rc = StubFRComputation::_Create(myFRInt);

    _IF_FAILURE_RET_VERBOSE(rc);

    localFR.setOH(myFRInt);

    rc = StubRegionDefault::_CreateFixedLenExt(
	localBase, localSize, 0, myFRInt, 0, AccessMode::writeUserWriteSup, 0,
	RegionType::K42Region);

    _IF_FAILURE_RET_VERBOSE(rc);

    // Create an OH to a global object in the other process and
    // look for a matching MemTrans there

    // But, if this is the kernel, we never attempt this ---
    // Can't trust the other process to not block us on this
    // So we always wait for the other process to call _swapHandle

    if (DREFGOBJ(TheProcessRef)->getPID() == _KERNEL_PID) {
	return 0;
    }

    ObjectHandle SMTDB;
    SMTDB.initWithPID(partner,XHANDLE_MAKE_NOSEQNO(CObjGlobals::ProcessIndex));

    StubProcessClient stubPC(StubObj::UNINITIALIZED);

    stubPC.setOH(SMTDB);

    rc = stubPC._getMemTrans(remoteOH, key);

    if (_SUCCESS(rc)) {
	StubMemTrans remote(StubObj::UNINITIALIZED);
	remote.setOH(remoteOH);


	uval remoteSize;
	ObjectHandle frOH;

	// Give access to this area to the other process
	// FIXME: give access for read only
	ObjectHandle myFRExt;
	rc = localFR._giveAccess(myFRExt, partner);

	_IF_FAILURE_RET_VERBOSE(rc);


	// Give remote process OH's to our FR and MT

	rc = remote._swapHandle(localOH, myFRExt, localSize,
				remoteSize, frOH);

	_IF_FAILURE_RET_VERBOSE(rc);

	rc = StubRegionDefault::_CreateFixedLenExt(
	    addr, remoteSize, 0, frOH, 0, AccessMode::writeUserWriteSup, 0,
	    RegionType::K42Region);

	_IF_FAILURE_RET_VERBOSE(rc);

	ClientData *cd = clnt(remoteX);
	cd->init(frOH, remoteOH, addr, remoteSize);
	remote._completeInit();

    }
//.........这里部分代码省略.........