/* virtual */ SysStatusUval
StreamServer::_getAvailability(__out GenState &avail, __XHANDLE xhandle)
{
lock();
calcAvailable(avail, clnt(xhandle));
clnt(xhandle)->setAvail(avail);
unlock();
return avail.state;
}
/* virtual */ SysStatus
StreamServer::locked_signalDataAvailable()
{
XHandle xhandle;
uval retries = 0;
retry:
// now traverse list of clients and tell them
if (_FAILURE(lockIfNotClosingExportedXObjectList())) return 0;
xhandle = getHeadExportedXObjectList();
while (xhandle != XHANDLE_NONE) {
GenState available;
calcAvailable(available, clnt(xhandle));
TraceOSIOSendAsync(xhandle, available.fullVal);
SysStatus rc = clnt(xhandle)->signalDataAvailable(available);
//tassert(_SUCCESS(rc), err_printf("woops\n"));
if (!_SUCCESS(rc) && _SGENCD(rc) == EBUSY) {
// FIXME: wrong solution since we are dlaying in kernel waiting
// for user resources; must have retry that doesn't use
// kernel resources while waiting
unlockExportedXObjectList();
//err_printf("FIXME: StreamServerPipe: client busy; retry: %ld\n",
// retries);
tassertWrn(((retries%100)!=5),
"stalled on notification to %ld, retries %ld\n",
XHandleTrans::GetOwnerProcessID(xhandle), retries);
unlock();
Scheduler::DelayMicrosecs(1000);
lock();
retries++;
goto retry;
} else if (!_SUCCESS(rc)) {
if (_FAILURE(DREFGOBJ(TheXHandleTransRef)->
xhandleValidate(xhandle)) ||
!clnt(xhandle)->isValidOH()) {
xhandle = getNextExportedXObjectList(xhandle);
continue;
}
err_printf("%s Unexpected error code ", __func__);
_SERROR_EPRINT(rc);
}
xhandle = getNextExportedXObjectList(xhandle);
}
unlockExportedXObjectList();
return 0;
}
HWND ClockWindow::Create(HWND hwndParent)
{
static BtnWindowClass wcClock(CLASSNAME_CLOCKWINDOW, CS_DBLCLKS);
ClientRect clnt(hwndParent);
WindowCanvas canvas(hwndParent);
FontSelection font(canvas, GetStockFont(ANSI_VAR_FONT));
RECT rect = {0, 0, 0, 0};
TCHAR buffer[16];
// Arbitrary high time so that the created clock window is big enough
SYSTEMTIME st = { 1601, 1, 0, 1, 23, 59, 59, 999 };
if (!GetTimeFormat(LOCALE_USER_DEFAULT, TIME_NOSECONDS, &st, NULL, buffer, sizeof(buffer)/sizeof(TCHAR)))
_tcscpy(buffer, TEXT("00:00"));
// Calculate the rectangle needed to draw the time (without actually drawing it)
DrawText(canvas, buffer, -1, &rect, DT_SINGLELINE|DT_NOPREFIX|DT_CALCRECT);
int clockwindowWidth = rect.right-rect.left + 4;
return Window::Create(WINDOW_CREATOR(ClockWindow), 0,
wcClock, NULL, WS_CHILD|WS_VISIBLE,
clnt.right-(clockwindowWidth), 1, clockwindowWidth, clnt.bottom-2, hwndParent);
}
/* virtual */ SysStatus
MemTrans::_swapHandle(ObjectHandle callerMT, //Caller's MT
ObjectHandle callerFR, //Caller's FR
uval callerSize, //Size of region
uval& sizeRemote,
ObjectHandle &remoteFR,
__XHANDLE xhandle,
__CALLER_PID pid)
{
ClientData *cd = clnt(xhandle);
tassertMsg(cd,"No clientData defined\n");
uval addr=0;
SysStatus rc = 0;
rc = StubRegionDefault::_CreateFixedLenExt(
addr, callerSize, 0, callerFR, 0, AccessMode::writeUserWriteSup, 0,
RegionType::K42Region);
ObjectHandle frOH;
if (_SUCCESS(rc)) {
cd->init(callerFR, callerMT, addr, callerSize);
rc = localFR._giveAccess(frOH, pid);
} else {
return rc;
}
remoteFR = frOH;
sizeRemote = callerSize;
return rc;
}
/* virtual */ SysStatus
StreamServer::_registerCallback(__in ObjectHandle callback,
__XHANDLE xhandle)
{
clnt(xhandle)->setOH(callback);
return 0;
}
/* virtual */ BlockDevBase::StubFRHolder*
BlockDevBase::getFRStubHolder(__XHANDLE xhandle)
{
ClientData *cd = clnt(xhandle);
if (!cd->stubFR) {
return stubFR;
}
return cd->stubFR;
}
HWND NotifyArea::Create(HWND hwndParent)
{
static BtnWindowClass wcTrayNotify(CLASSNAME_TRAYNOTIFY, CS_DBLCLKS);
ClientRect clnt(hwndParent);
return Window::Create(WINDOW_CREATOR(NotifyArea), WS_EX_STATICEDGE,
wcTrayNotify, TITLE_TRAYNOTIFY, WS_CHILD|WS_VISIBLE|WS_CLIPCHILDREN,
clnt.right-(NOTIFYAREA_WIDTH_DEF+1), 1, NOTIFYAREA_WIDTH_DEF, clnt.bottom-2, hwndParent);
}
/* This interface is part of the ServerFile interface, uses FR OHs */
/* virtual */ SysStatus
BlockDevBase::_registerCallback(__in ObjectHandle oh, __XHANDLE xhandle)
{
ClientData *cd = clnt(xhandle);
if (!cd->stubFR) {
cd->stubFR = new StubFRHolder;
}
cd->stubFR->stubFR.setOH(oh);
return 0;
}
HWND TaskBar::Create(HWND hwndParent)
{
ClientRect clnt(hwndParent);
int taskbar_pos = 80; // This start position will be adjusted in DesktopBar::Resize().
return Window::Create(WINDOW_CREATOR(TaskBar), 0,
BtnWindowClass(CLASSNAME_TASKBAR), TITLE_TASKBAR,
WS_CHILD|WS_VISIBLE | CCS_TOP|CCS_NODIVIDER|CCS_NORESIZE,
taskbar_pos, 0, clnt.right-taskbar_pos-(NOTIFYAREA_WIDTH_DEF+1), clnt.bottom, hwndParent);
}
ResizeManager::ResizeManager(HWND hwnd)
: _hwnd(hwnd)
{
ClientRect clnt(hwnd);
_last_size.cx = clnt.right;
_last_size.cy = clnt.bottom;
WindowRect rect(hwnd);
_min_wnd_size.cx = rect.right - rect.left;
_min_wnd_size.cy = rect.bottom - rect.top;
}
/* virtual */ SysStatus
StreamServerConsole::kosherxlist()
{
XHandle xhandle;
if (_FAILURE(lockIfNotClosingExportedXObjectList())) return 0;
err_printf("<");
xhandle = getHeadExportedXObjectList();
while (xhandle != XHANDLE_NONE) {
err_printf("X");
GenState available;
calcAvailable(available, clnt(xhandle));
clnt(xhandle)->signalDataAvailable(available);
xhandle = getNextExportedXObjectList(xhandle);
}
err_printf(">");
unlockExportedXObjectList();
return 0;
}
void CPartialAttributeUpdateTest::runTest(int mode)
{
DSI::CCommEngine engine;
CPartialAttributeUpdateTestServer serv(mode);
engine.add(serv);
CPartialAttributeUpdateTestClient clnt(mode);
engine.add(clnt);
CPPUNIT_ASSERT(engine.run() == 0);
}
/* virtual */ SysStatus
BlockDevBase::_registerComplete(SysStatus rc, ObjectHandle oh,
__XHANDLE xhandle)
{
ClientData *cd = clnt(xhandle);
ThreadID t = cd->waitingThread;
cd->rc = rc;
cd->replyOH = oh;
cd->waitingThread = Scheduler::NullThreadID;
Scheduler::Unblock(t);
return 0;
}
/* virtual */ SysStatus
StreamServer::handleXObjFree(XHandle xhandle)
{
ClientData* cd = clnt(xhandle);
if (cd->mtr) {
DREF(cd->mtr)->detach();
cd->mtr = NULL;
}
XHandleTrans::SetBeingFreed(xhandle, BeingFreed);
return 0;
}
int main(int argc, char* argv[])
{
//Server loops
int port = 30000;
//Worker threads
for(int i = 0; i < workerThreadsNum; i++)
{
for(int j = 0; j < queueSizeNum; j++)
{
HTTP_Server srv(++port + 1000, queueSize[j]);
srv.setupThreadPool(workerThreads[i]);
srv.beginAcceptLoop();
sleep(1);
HTTP_Proxy prx(port, queueSize[j], port + 1000);
prx.setupThreadPool(workerThreads[i]);
prx.beginAcceptLoop();
//wait for the startup
sleep(1);
//Worker loop
for(int k = 0; k < clientThreadsNum; k++)
{
for(int l = 0; l < fileSizeNum; l++)
{
for(int m = 0; m < loopSizeNum; m++)
{
sleep(1);
printf("# %d %d %d %d %d\n", i, j, k, l, m);
//Convert the decimal digit to ascii
char num = rand() % 9 + 48;
client clnt(port);
char randName[128];
sprintf(randName, "%s%d", fileSize[l], rand() % 10);
clnt.runWorkerThreads(randName, clientThreads[k], loopSize[m]);
}
}
}
srv.shutdownServer();
//Wait 5 before starting a new server with a new port
sleep(5);
}
}
}
HWND QuickLaunchBar::Create(HWND hwndParent)
{
CONTEXT("QuickLaunchBar::Create()");
ClientRect clnt(hwndParent);
HWND hwnd = CreateToolbarEx(hwndParent,
WS_CHILD|WS_VISIBLE|WS_CLIPSIBLINGS|WS_CLIPCHILDREN|
CCS_TOP|CCS_NODIVIDER|CCS_NOPARENTALIGN|CCS_NORESIZE|
TBSTYLE_TOOLTIPS|TBSTYLE_WRAPABLE|TBSTYLE_FLAT,
IDW_QUICKLAUNCHBAR, 0, 0, 0, NULL, 0, 0, 0, 16, 16, sizeof(TBBUTTON));
if (hwnd)
new QuickLaunchBar(hwnd);
return hwnd;
}
/* virtual */ SysStatusUval
StreamServerConsole::recvfrom(struct iovec *vec, uval veclen, uval flags,
char *addr, uval &addrLen, GenState &moreAvail,
void *controlData, uval &controlDataLen,
__XHANDLE xhandle)
{
addrLen = 0;
uval copied = 0;
controlDataLen = 0; /* setting to zero, since no control data */
lock();
if (buffer.bytesAvail()) {
char data[buffer.bufSize()];
copied = buffer.getData(data, buffer.bufSize());
memcpy_toiovec(vec, data, veclen, copied);
}
calcAvailable(moreAvail);
unlock();
clnt(xhandle)->setAvail(moreAvail);
return copied;
}
/* virtual */ SysStatusUval
StreamServerConsole::sendto(struct iovec* vec, uval veclen, uval flags,
const char *addr, uval addrLen,
GenState &moreAvail,
void *controlData, uval controlDataLen,
__XHANDLE xhandle)
{
uval len = vecLength(vec, veclen);
char* buf = (char*)allocLocalStrict(len);
tassertMsg((controlDataLen == 0), "oops\n");
memcpy_fromiovec(buf, vec, veclen, len);
SysConsole->write(buf, len);
freeLocalStrict(buf, len);
calcAvailable(moreAvail);
if (XHANDLE_IDX(xhandle) != CObjGlobalsKern::ConsoleIndex) {
clnt(xhandle)->setAvail(moreAvail);
}
return len;
}
/* static */ void
StreamServer::BeingFreed(XHandle xhandle) {
StreamServer::ClientData *clientData = clnt(xhandle);
delete clientData;
}
cd->replyOH = oh;
cd->waitingThread = Scheduler::NullThreadID;
Scheduler::Unblock(t);
return 0;
}
/* virtual */ SysStatus
BlockDevBase::_getRegistration(__outbuf(*:buflen) char* name,
__in uval buflen,
__out uval &devID,
__out uval &mode,
__out ObjectHandle &parent,
__out uval &token,
__XHANDLE xhandle)
{
ClientData *cd = clnt(xhandle);
strncpy(name,cd->name, buflen-1);
devID = cd->devID;
mode = cd->mode;
parent = cd->parent;
token = cd->token;
return 0;
}
SysStatus
BlockDevBase::init(const char* name, int deviceID,
int mode, ObjectHandle dir, ObjectHandle &deviceNode)
{
devID = deviceID;
devSize = blkSize = 0;
/* 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();
}
return 0;
}
