static void *GCMain ( void *Ptr) {
int OrigCancelState;
int OrigCancelType;
int LastCancelState;
int i;
Slot_Mgr_Shr_t *MemPtr = (Slot_Mgr_Shr_t *) Ptr;
ASSERT ( MemPtr != NULL );
/* setup */
/* Block the signals that go to the main thread */
/* FIXME: We probably want to make it so that signals go only to the main thread by default */
GCBlockSignals();
/* Make it so that we can only be cancelled when we reach a cancellation point */
/* cancellation points are listed here: http://techlib.austin.ibm.com/techlib/manuals/adoclib/aixprggd/genprogc/termthre.htm#D3A4499176manu */
/* PTHREAD_CANCEL_DEFERRED should be the default */
pthread_setcancelstate ( PTHREAD_CANCEL_ENABLE, &OrigCancelState );
pthread_setcanceltype ( PTHREAD_CANCEL_DEFERRED, &OrigCancelType );
/* push cleanup routines */
pthread_cleanup_push ( GCCancel, MemPtr );
while ( 1 ) {
DbgLog(DL5, "Garbage collection running...");
/* Don't allow cancellations while mucking with shared memory or holding mutexes */
pthread_setcancelstate ( PTHREAD_CANCEL_DISABLE, &LastCancelState );
CheckForGarbage(MemPtr);
/* re-enable cancellations */
pthread_setcancelstate ( PTHREAD_CANCEL_ENABLE, &LastCancelState );
/* Test for cancellation by the main thread */
pthread_testcancel();
DbgLog(DL5, "Garbage collection finished.");
/* now we pause */
sleep(10);
} /* end while 1 */
/* Yeah, yeah. Has to be here because some implementations use macros that have to be balanced */
pthread_cleanup_pop ( 0 );
/* return implicitly calls pthread_cancel() */
/* but it'll never really get executed; pthread_testcancel() implicitly calls pthread_exit() if there's a cancellation pending */
return NULL;
}
int main ( int argc, char *argv[], char *envp[]) {
int ret;
/**********************************/
/* Read in command-line arguments */
/**********************************/
/* FIXME: Argument for daemonizing or not */
/* FIXME: Argument for debug level */
/* FIXME: Arguments affecting the log files, whether to use syslog, etc. (Read conf file?) */
/* Report our debug level */
if ( GetDebugLevel() > DEBUG_NONE) {
DbgLog(GetDebugLevel(), "Starting with debugging messages logged at level %d (%d = No messages; %d = few; %d = more, etc.)",
GetDebugLevel(), DEBUG_NONE, DEBUG_LEVEL0, DEBUG_LEVEL1);
}
/* Save our startup directory */
SaveStartupDirectory( argv[0] );
ret = load_and_parse(OCK_CONFIG);
if (ret != 0) {
ErrLog("Failed to read config file.\n");
return 1;
} else
DbgLog (DL0, "Parse config file succeeded.\n");
/* Allocate and Attach the shared memory region */
if ( ! CreateSharedMemory() ) {
/* CreateSharedMemory() does it's own error logging */
return 1;
}
DbgLog(DL0,"SHMID %d token %#X \n", shmid, tok);
/* Now that we've created the shared memory segment, we attach to it */
if ( ! AttachToSharedMemory() ) {
/* AttachToSharedMemory() does it's own error logging */
DestroySharedMemory();
return 2;
}
/* Initialize the global shared memory mutex (and the attribute used to create the per-process mutexes */
if ( ! InitializeMutexes() ) {
DetachFromSharedMemory();
DestroySharedMemory();
return 3;
}
/* Get the global shared memory mutex */
XProcLock();
/* Populate the Shared Memory Region */
if ( ! InitSharedMemory(shmp) ) {
XProcUnLock();
DetachFromSharedMemory();
DestroySharedMemory();
return 4;
}
/* Release the global shared memory mutex */
XProcUnLock();
if ((socketfd = CreateListenerSocket()) < 0) {
DestroyMutexes();
DetachFromSharedMemory();
DestroySharedMemory();
return 5;
}
if (!InitSocketData(&socketData)) {
DetachSocketListener(socketfd);
DestroyMutexes();
DetachFromSharedMemory();
DestroySharedMemory();
return 6;
}
/*
* Become a Daemon, if called for
*/
if ( Daemon ) {
pid_t pid;
if ( (pid = fork()) < 0 ){
DetachSocketListener(socketfd);
DestroyMutexes();
DetachFromSharedMemory();
DestroySharedMemory();
return 7;
} else {
if ( pid != 0) {
exit(0); // Terminate the parent
} else {
setsid(); // Session leader
#ifndef DEV
fclose(stderr);
fclose(stdout);
fclose(stdin);
#endif
}
}
} else {
#ifdef DEV
// Log only on development builds
LogLog("Not becoming a daemon...\n");
#endif
}
/*****************************************
*
* Register Signal Handlers
* Daemon probably should ignore ALL signals possible, since termination
* while active is a bad thing... however one could check for
* any processes active in the shared memory, and destroy the shm if
* the process wishes to terminate.
*
*****************************************/
/*
* We have to set up the signal handlers after we daemonize because
* the daemonization process redefines our handler for (at least) SIGTERM
*/
if ( ! SetupSignalHandlers() ) {
DetachSocketListener(socketfd);
DestroyMutexes();
DetachFromSharedMemory();
DestroySharedMemory();
return 8;
}
/* ultimatly we will create a couple of threads which monitor the slot db
and handle the insertion and removal of tokens from the slot.
*/
/* For Testing the Garbage collection routines */
/*
shmp->proc_table[3].inuse = TRUE;
shmp->proc_table[3].proc_id = 24328;
*/
#if !defined(NOGARBAGE)
printf("Start garbage \n");
/* start garbage collection thread */
if ( ! StartGCThread(shmp) ) {
DetachSocketListener(socketfd);
DestroyMutexes();
DetachFromSharedMemory();
DestroySharedMemory();
return 9;
}
#endif
// We've fully become a daemon. Now create the PID file
{
FILE *pidfile;
pidfile = fopen(PID_FILE_PATH,"w");
if (pidfile) {
fprintf(pidfile,"%d",getpid());
fclose(pidfile);
}
}
while (1) {
#if !(THREADED) && !(NOGARBAGE)
CheckForGarbage(shmp);
#endif
SocketConnectionHandler(socketfd, 10);
}
/*************************************************************
*
* Here we need to actualy go through the processes and verify that thye
* still exist. If not, then they terminated with out properly calling
* C_Finalize and therefore need to be removed from the system.
* Look for a system routine to determine if the shared memory is held by
* the process to further verify that the proper processes are in the
* table.
*
*************************************************************/
} /* end main */
