void InterruptHandler::Run()
{
StartTrace(InterruptHandler.Run);
// the just wait for the signal to happen
Trace("Thread: " << Thread::MyId());
Trace("Pid: " << (long)coast::system::getpid());
Trace("Server [" << (fServer ? (const char *)(fServer->fName) : "no-name") << "]");
if ( fServer ) {
fServer->WritePIDFile(coast::system::getpid());
}
sigset_t set;
int isignal;
// setup the signal set that catches control-c
sigemptyset(&set);
sigaddset(&set, SIGINT);
sigaddset(&set, SIGTERM);
sigaddset(&set, SIGHUP);
handlesignal:
SetWorking();
Trace("calling sigwait");
sigwait(&set, &isignal);
SetReady();
Trace("got signal: " << (long)isignal);
if (fServer) {
String sigName;
sigName << (long)isignal;
if ( isignal == SIGHUP ) {
SYSINFO("caught SIGHUP, resetting server");
int retVal = fServer->GlobalReinit();
if ( retVal == 0 ) {
// everything ok, wait on next signal
goto handlesignal;
}
sigName = "SIGHUP";
// shutdown if any mishap happens
SYSERROR("GlobalReinit failed, shutting down...");
} else if ( isignal == SIGINT ) {
sigName = "SIGINT";
} else if ( isignal == SIGTERM ) {
sigName = "SIGTERM";
} else {
SYSINFO("caught unknown signal " << sigName << " ...ignoring!");
goto handlesignal;
}
SYSINFO("caught " << sigName << " shutting down server");
// prepare the server for shutdown
// by causing him to leave the accept-loop
fServer->PrepareShutdown();
}
// the job is done, just die...
}
void LeaderFollowerPool::RequestTermination() {
SYSINFO("requesting Termination");
StartTrace(LeaderFollowerPool.RequestTermination);
{
LockUnlockEntry me(fLFMutex);
fPoolState = Thread::eTerminationRequested;
fCurrentLeader = cBlockPromotion;
fFollowersCondition.BroadCast();
}
SYSINFO("Termination request done");
}
void InputInit(void)
{
int i;
ZEROMEMORY(gInput, sizeof(sInput) * INPUT_WORK_NUM);
gInput[INP_SYS].exec = TRUE;
for(i = 0; i < INPUT_WORK_NUM; ++i)
{
gInput[i].m_x = MOUSE_MIN_POSITION;
gInput[i].m_y = MOUSE_MIN_POSITION;
gInput[i].x = MOUSE_MIN_POSITION;
gInput[i].y = MOUSE_MIN_POSITION;
}
record = NULL;
glutMouseFunc(mouseBtnCallback);
glutMotionFunc(mousePosCallback);
glutPassiveMotionFunc(mousePosCallback);
glutKeyboardFunc(keyPushCallback);
glutKeyboardUpFunc(keyPullCallback);
glutSpecialFunc(keyExPushCallback);
glutSpecialUpFunc(keyExPullCallback);
SYSINFO(".... input initialize");
}
void _exit(int status) {
kprintf("%s",std::string(LINEWIDTH, '=').c_str());
kprint("\n");
SYSINFO("service exited with status %i", status);
default_exit();
__builtin_unreachable();
}
//==============================================================
void MemInit(void)
//--------------------------------------------------------------
// メモリ管理の初期化
//--------------------------------------------------------------
// in: なし
//--------------------------------------------------------------
// out: なし
//==============================================================
{
void *ptr;
size_t size;
int i;
ZEROMEMORY(&gMem, sizeof(sMemInfo)); // 管理領域を初期化
//----------------------------
// ヒープ領域を作成して初期化
//----------------------------
ptr = OsCreateMemory(MEM_SIZE);
// 空きエリアを全てグローバル領域として確保
//------------------------------------------
bsMemoryInit(&gMem.global_mem_hdr, ptr, MEM_SIZE, TRUE);
//--------------------
// MEM_APP 以外を確保
//--------------------
for(i = MEM_SYS; i < MEM_APP; ++i)
{
ptr = bsMalloc(&gMem.global_mem_hdr, memSizeTbl[i], NULL);
ASSERT(ptr);
bsMemoryInit(&gMem.mem_hdr[i], ptr, memSizeTbl[i], FALSE);
gMem.mem_hdr[i].area = i;
}
//------------------------------------------------------
// グローバル領域の残りをアプリケーション領域として確保
//------------------------------------------------------
size = bsMemoryGetFree(&gMem.global_mem_hdr);
ptr = bsMalloc(&gMem.global_mem_hdr, size, NULL);
ASSERT(ptr);
bsMemoryInit(&gMem.mem_hdr[MEM_APP], ptr, size, FALSE);
gMem.mem_hdr[MEM_APP].area = MEM_APP;
#ifdef DEBUG
//--------------------
// 開発時の領域の確保
//--------------------
ptr = OsCreateMemory(MEM_DEV_SIZE);
bsMemoryInit(&gMem.mem_hdr[MEM_DEV], ptr, MEM_DEV_SIZE, TRUE);
gMem.mem_hdr[MEM_DEV].area = MEM_DEV;
#endif
SYSINFO(".... memory initialize");
}
// GlobalInit: installs ressources shared among all instances
int Application::GlobalInit(int argc, const char *argv[], const ROAnything config)
{
StartTrace(Application.GlobalInit);
int ret = DoGlobalInit(argc, argv, config);
if ( ret == 0 ) {
SYSINFO("Global init: succeeded");
} else {
SYSERROR("Global init: failed");
}
return (ret);
}
// DllMain() is the entry-point function for this DLL.
BOOL WINAPI DllMain(HANDLE hinstDLL, // DLL module handle
DWORD fdwReason, // reason called
LPVOID lpvReserved) // reserved
{
switch (fdwReason) {
// The DLL is loading due to process
// initialization or a call to LoadLibrary.
case DLL_PROCESS_ATTACH:
Init();
if (THRKEYCREATE(fgThreadPtrKey, 0)) {
SystemLog::Error("TlsAlloc of fgThreadPtrKey failed");
}
break;
// The attached process creates a new thread.
case DLL_THREAD_ATTACH:
SystemLog::Info(String("mtfoundation: DLL_THREAD_ATTACH for [") << Thread::MyId() << "]");
break;
// The thread of the attached process terminates.
case DLL_THREAD_DETACH: {
Thread *pThr = (Thread *)TlsGetValue(fgThreadPtrKey);
SystemLog::Info(String("DLL_THREAD_DETACH for [") << Thread::MyId() << "] &Thread:" << (long)pThr );
if ( pThr ) {
// there seems to be a valid ThreadPtr, eg. it is a mtfoundation Thread
RemoveThreadDetach(pThr);
pThr->SetState(Thread::eTerminated);
} else {
SYSINFO("Thread* was NULL for [" << Thread::MyId() << "] ErrorMessage: [" << SystemLog::LastSysError() << "]");
}
break;
}
// The DLL unloading due to process termination or call to FreeLibrary.
case DLL_PROCESS_DETACH:
TerminateKilledThreads();
THRKEYDELETE(fgThreadPtrKey);
Finis();
break;
default:
break;
}
return true;
UNREFERENCED_PARAMETER(hinstDLL);
UNREFERENCED_PARAMETER(lpvReserved);
}
void InputFin(void)
{
glutMouseFunc(NULL);
glutMotionFunc(NULL);
glutPassiveMotionFunc(NULL);
glutKeyboardFunc(NULL);
glutKeyboardUpFunc(NULL);
glutSpecialFunc(NULL);
glutSpecialUpFunc(NULL);
FreeWork(record);
SYSINFO(".... input finish");
}
//==============================================================
void MemFin(void)
//--------------------------------------------------------------
// メモリ管理の終了
//--------------------------------------------------------------
// in: なし
//--------------------------------------------------------------
// out: なし
//==============================================================
{
OsDestroyMemory(gMem.global_mem_hdr.top);
#ifdef DEBUG
OsDestroyMemory(gMem.mem_hdr[MEM_DEV].top);
#endif
SYSINFO(".... memory finish");
}
static int lxc_monitord_fifo_create(struct lxc_monitor *mon)
{
struct flock lk;
char fifo_path[PATH_MAX];
int ret;
ret = lxc_monitor_fifo_name(mon->lxcpath, fifo_path, sizeof(fifo_path), 1);
if (ret < 0)
return ret;
ret = mknod(fifo_path, S_IFIFO | S_IRUSR | S_IWUSR, 0);
if (ret < 0 && errno != EEXIST) {
SYSINFO("Failed to mknod monitor fifo %s", fifo_path);
return -1;
}
mon->fifofd = open(fifo_path, O_RDWR);
if (mon->fifofd < 0) {
SYSERROR("Failed to open monitor fifo %s", fifo_path);
unlink(fifo_path);
return -1;
}
lk.l_type = F_WRLCK;
lk.l_whence = SEEK_SET;
lk.l_start = 0;
lk.l_len = 0;
if (fcntl(mon->fifofd, F_SETLK, &lk) != 0) {
/* another lxc-monitord is already running, don't start up */
SYSDEBUG("lxc-monitord already running on lxcpath %s", mon->lxcpath);
close(mon->fifofd);
return -1;
}
return 0;
}
//==============================================================
static int objTask(sTaskBody *body, int msg, int lParam, int rParam)
//--------------------------------------------------------------
// タスク処理
//--------------------------------------------------------------
// in: body = ハンドル
// msg = メッセージ
// lParam, rParam = 汎用パラメータ
//--------------------------------------------------------------
// out: 実行結果
//==============================================================
{
int res = 0;
switch(msg)
{
case MSG_CREATE:
{
param_hash = HashCreate("obj");
obj_link = ObjLinkCreate(sizeof(sOBJ), OBJ_NUM, MEM_SYS, FALSE);
SYSINFO(".... object initialize");
}
break;
case MSG_KILL:
{
ObjDeleteParamAll();
HashKill(param_hash);
ObjLinkDestroy(obj_link);
SYSINFO(".... object finish");
}
break;
case MSG_PREPROC:
{
{
sOBJ *obj;
obj = ObjGetNext(NULL, OBJ_TYPE_ALL, NULL);
while(obj)
{
obj->create = FALSE;
obj = ObjGetNext(obj, OBJ_TYPE_ALL, NULL);
}
}
ObjPostMsgAll(OBJ_TYPE_ALL, msg, FALSE, 0, 0);
}
break;
case MSG_STEP:
{
ObjPostMsgAll(OBJ_TYPE_ALL, msg, FALSE, 0, 0);
{
sOBJ *obj;
obj = ObjGetNext(NULL, OBJ_TYPE_ALL, NULL);
while(obj)
{
sOBJ *next;
next = ObjGetNext(obj, OBJ_TYPE_ALL, NULL);
if(obj->kill_req) objDelete(obj);
obj = next;
}
}
}
break;
case MSG_UPDATE:
{
ObjPostMsgAll(OBJ_TYPE_ALL, msg, FALSE, 0, 0);
}
break;
case MSG_DRAW:
{
ObjPostMsgAll(OBJ_TYPE_ALL, msg, FALSE, 0, 0);
}
break;
default:
{
ObjPostMsgAll(OBJ_TYPE_ALL, msg, FALSE, lParam, rParam);
}
break;
}
return res;
}
