Replacing old sysV sem by new POSIX solves #25

Creating new files to handle IPC stuffs : include/ipc.h src/ipc.c

configure.ac

@@ -52,6 +52,7 @@ AC_C_INLINE
 # Checks for libraries.
 AC_CHECK_LIB([fcgi], [FCGI_Accept])
 AC_CHECK_LIB([rt], [timer_create])
+AC_CHECK_LIB([pthread], [sem_open shm_open])
 PKG_CHECK_MODULES([CHECK], [check >= 0.9.4])
 
 # Checks for header files.
@@ -65,7 +66,7 @@ AC_TYPE_SIZE_T
 AC_FUNC_FORK
 AC_FUNC_MALLOC
 AC_FUNC_REALLOC
-AC_CHECK_FUNCS([bzero getcwd gettimeofday memmove strdup strerror strndup semop clone get_current_dir_name timer_settime])
+AC_CHECK_FUNCS([bzero getcwd gettimeofday memmove strdup strerror strndup get_current_dir_name timer_settime])
 
 AM_INIT_AUTOMAKE
 AC_CONFIG_FILES([Makefile

include/conf.h

@@ -29,6 +29,7 @@
 #include <unistd.h>
 #include <getopt.h>
 #include <limits.h>
+#include <semaphore.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 
@@ -39,8 +40,22 @@
  * @see struct_pyfcgi_conf_s
  * @ingroup conf_internal */
 
+/**@brief Friendly name for @ref struct pyfcgi_conf_s
+ * @see struct pyfcgi_conf_s */
+typedef struct pyfcgi_conf_s pyfcgi_conf_t;
+typedef struct pyfcgi_conf_logger_s pyfcgi_conf_logger_t;
+typedef struct pyfcgi_context_s pyfcgi_context_t;
+typedef struct pyfcgi_semdata_s pyfcgi_semdata_t;
+
+/**@brief Configuration globals, inherited from parent to childs
+ * @ingroup conf_internal
+ */
+pyfcgi_conf_t PyFCGI_conf;
+
+/* Include other PyFCGI stuff */
 #include "logger.h"
 #include "pyutils.h"
+#include "ipc.h"
 
 /**@defgroup ret_status Function & process return status
  */
@@ -117,11 +132,14 @@ abbreviated to one character.\n"
 
 #define PYENTRY_DEFAULT_FUN "application"
 
-/**@brief Friendly name for @ref struct pyfcgi_conf_s
- * @see struct pyfcgi_conf_s */
-typedef struct pyfcgi_conf_s pyfcgi_conf_t;
-typedef struct pyfcgi_conf_logger_s pyfcgi_conf_logger_t;
-typedef struct pyfcgi_context_s pyfcgi_context_t;
+/**@brief Stores a semaphore name and pointer */
+struct pyfcgi_semdata_s {
+	/**@brief Semaphore names. Set by master process */
+	char name[NAME_MAX - 4];
+	/**@brief Semaphore pointer. */
+	sem_t *sem;
+};
+
 
 /**@brief Stores contextual informations about current process */
 struct pyfcgi_context_s {
@@ -147,8 +165,8 @@ struct pyfcgi_context_s {
 	/**@brief workers count */
 	unsigned int n_wrk;
 
-	/**@brief semid for worker<->pool semaphore */
-	int semid;
+	/**@brief Stores IPC flag used in init */
+	pyfcgi_ipc_flag_t ipc_flag;
 
 	/**@brief Stores python_path (not dupped by python) */
 	wchar_t python_path[PATH_MAX];
@@ -213,11 +231,18 @@ struct pyfcgi_conf_s
 
 	/**@brief Context informations */
 	pyfcgi_context_t context;
-};
 
+	/**@brief Semaphores informations
+	 *
+	 * - sems[0] is the worker state indicator : when a worker is idle the
+	 * sem is incremented
+	 * - sems[1] is the request counter sem : when a request is handled
+	 * this sem is incremented
+	 * - sems[2] is the stats/status SHM semaphore
+	 */
+	pyfcgi_semdata_t sems[PYFCGI_NSEM];
+};
 
-/**@brief Configuration globals, inherited from parent to childs */
-pyfcgi_conf_t PyFCGI_conf;
 
 /**@brief Print usage on FD 2 (stdout) */
 void usage();

include/ipc.h

@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2019 Weber Yann
+ * 
+ * This file is part of PyFCGI.
+ * 
+ * PyFCGI is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * any later version.
+ * 
+ * PyFCGI is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Affero General Public License
+ * along with PyFCGI.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/**@defgroup IPC Inter process communication mechanism
+ */
+/**@file ipc.h
+ * @ingroup IPC */
+#ifndef __IPC_H___
+#define __IPC_H___
+
+#include <fcgiapp.h>
+#include <fcgi_stdio.h> /* fcgi library; put it first*/
+
+#include <fcntl.h>
+#include <semaphore.h>
+#include <sys/stat.h>
+
+/**@brief Format for sem and shm */
+#define PYFCGI_IPCNAME_FMT "/PyFCGI-%d_%s"
+/**@brief Number of semaphores */
+#define PYFCGI_NSEM 3
+
+#define SEM_WSTATE 0
+#define SEM_WREQS 1
+#define SEM_STATS 2
+/**@brief Semaphore uniq name */
+#define PYFCGI_SEMNAMES {"WState", "WReqs", "SHMStats"}
+
+#define PyFCGI_SEM(i) (PyFCGI_conf.sems[i])
+
+/**@defgroup IPC_flags IPC component flags
+ * @ingroup IPC
+ * @brief For IPC component selection */
+/**@brief Worker state semaphore
+ * @ingroup IPC_flags */
+#define IPC_WSTATE 2
+/**@brief Worker state semaphore
+ * @ingroup IPC_flags */
+#define IPC_WREQS 4
+/**@brief Worker state semaphore
+ * @ingroup IPC_flags */
+#define IPC_SEMST 8
+/**@brief Worker state semaphore
+ * @ingroup IPC_flags */
+#define IPC_SHMST 16
+
+typedef unsigned short pyfcgi_ipc_flag_t;
+
+#include "conf.h"
+
+/**@brief Set semaphore names using master process PID as uniq key
+ * @param pid_t master process PID
+ */
+void pyfcgi_name_sems(pid_t master_pid);
+
+/**@brief Do shm_open & sem_open given component indicated by flag
+ * @param pyfcgi_ipc_flah_t flag a binary or combination of component flags
+ * @return 0 if no error else -1
+ * @note Stores the flag in configuration context 
+ * @see IPC_flags
+ */
+int pyfcgi_IPC_init(pyfcgi_ipc_flag_t flag);
+/**@brief Same than @ref pyfchi_IPC_init but with O_CREAT flag set */
+int pyfcgi_IPC_create(pyfcgi_ipc_flag_t flag);
+
+/**@brief Close previously opened IPC component (from conf context stored flag)
+ * @return 0 if no error else -1
+ */
+int pyfcgi_IPC_close();
+/**@brief IPC ressources cleanup */
+int pyfcgi_IPC_destroy(pyfcgi_ipc_flag_t flag);
+
+#endif

include/pyutils.h

@@ -40,7 +40,7 @@ extern PyObject* libpyfcgi_self;
 void pyinit();
 
 /**@brief Add . to the embed pythonpath
- * @deprecated Py_SetPath breaks Py_GetPrefix()...
+ * @deprecated Py_SetPath breaks Py_GetPrefix()... now 
  */
 void update_python_path();
 

include/responder.h

@@ -83,12 +83,15 @@ int responder_loop();
  */
 pid_t spawn(int);
 
-/**@brief Generate a new semaphore from given key
- * @ingroup work_master_proc
- * @note set pyfcgi_semid
- * @return int semid
+
+/**@deprecated Not used */
+int pyfcgi_pool_state();
+/**@brief Check if the pool is idle : if not able to timedwait the pool is busy
+ * @param const struct timespec timeout
+ * @return 1 if busy else 0
+ * @note exit on error
  */
-int new_semaphore();
+int pyfcgi_pool_idle(const struct timespec *timeout);
 
 /**@brief Exit after closing all stuff like semaphores
  * @ingroup work_master_proc

src/Makefile.am

@@ -6,13 +6,13 @@ pyfcgi_LDADD = $(PYTHON_LDFLAGS)
 
 # libpyfcgi python module
 lib_LTLIBRARIES = libpyfcgi.la
-libpyfcgi_la_SOURCES = python_pyfcgi.c python_ioin.c
+libpyfcgi_la_SOURCES = python_pyfcgi.c python_ioin.c ipc.c
 libpyfcgi_la_CFLAGS = $(PYTHON_SO_CFLAGS)
 libpyfcgi_la_LDFLAGS = $(PYTHON_SO_LDFLAGS)
 
 # static librarie for check
 noinst_LIBRARIES = libpyfcgi.a
-libpyfcgi_a_SOURCES = logger.c pyworker.c responder.c conf.c pyutils.c python_pyfcgi.c python_ioin.c
+libpyfcgi_a_SOURCES = logger.c pyworker.c responder.c conf.c pyutils.c python_pyfcgi.c python_ioin.c ipc.c
 libpyfcgi_a_CFLAGS = $(PYTHON_CFLAGS)
 
 

src/ipc.c

@@ -0,0 +1,162 @@
+#include "ipc.h"
+
+static const char *semnames[] = PYFCGI_SEMNAMES;
+static const pyfcgi_ipc_flag_t semflg[PYFCGI_NSEM] = {
+	IPC_WSTATE, IPC_WREQS, IPC_SEMST};
+
+void pyfcgi_name_sems(pid_t master_pid)
+{
+	short i;
+	for(i=0; i<PYFCGI_NSEM; i++)
+	{
+		if(snprintf(PyFCGI_conf.sems[i].name, NAME_MAX - 4,
+			PYFCGI_IPCNAME_FMT, master_pid, semnames[i]) < 0)
+		{
+			perror("Error allocating semaphore names");
+			exit(PYFCGI_FATAL);
+		}
+	}
+}
+
+int pyfcgi_IPC_create(pyfcgi_ipc_flag_t flag)
+{
+	short i;
+	int res, err;
+	
+	res = 0;
+	for(i=0; i<PYFCGI_NSEM; i++)
+	{
+		if(flag & semflg[i])
+		{
+			flag ^= semflg[i];
+			PyFCGI_SEM(i).sem = sem_open(PyFCGI_SEM(i).name, O_CREAT | O_EXCL,
+				0770, 0);
+			if(PyFCGI_SEM(i).sem == SEM_FAILED)
+			{
+				err = errno;
+				pyfcgi_log(LOG_ALERT,
+					"Unable to open semaphore %s(named '%s') : %s",
+					semnames[i], PyFCGI_SEM(i).name,
+					strerror(err));
+				PyFCGI_SEM(i).sem = NULL;
+				res = -1;
+			}
+			else
+			{
+				PyFCGI_conf.context.ipc_flag |= semflg[i];
+			}
+		}
+	}
+	if(flag & IPC_SHMST)
+	{
+		flag ^= IPC_SHMST;
+dprintf(2, "SHM not yet implemented...\n");
+res = -1;
+		//PyFCGI_conf.context.ipc_flag |= IPC_SHMST;
+	}
+	return res;
+}
+
+int pyfcgi_IPC_init(pyfcgi_ipc_flag_t flag)
+{
+	short i;
+	int res, err;
+	
+	res = 0;
+	for(i=0; i<PYFCGI_NSEM; i++)
+	{
+		if(flag & semflg[i])
+		{
+			flag ^= semflg[i];
+			PyFCGI_SEM(i).sem = sem_open(PyFCGI_SEM(i).name, 0);
+			if(PyFCGI_SEM(i).sem == SEM_FAILED)
+			{
+				err = errno;
+				pyfcgi_log(LOG_ALERT,
+					"Unable to open semaphore %s(named '%s') : %s",
+					semnames[i], PyFCGI_SEM(i).name,
+					strerror(err));
+				PyFCGI_SEM(i).sem = NULL;
+				res = -1;
+			}
+			else
+			{
+				PyFCGI_conf.context.ipc_flag |= semflg[i];
+			}
+		}
+	}
+	if(flag & IPC_SHMST)
+	{
+		flag ^= IPC_SHMST;
+dprintf(2, "SHM not yet implemented...\n");
+res = -1;
+		//PyFCGI_conf.context.ipc_flag |= IPC_SHMST;
+	}
+	return res;
+}
+
+int pyfcgi_IPC_close()
+{
+	short i;
+	int res, err;
+	pyfcgi_ipc_flag_t flag;
+
+	flag = PyFCGI_conf.context.ipc_flag;
+	res = 0;
+	for(i=0; i<PYFCGI_NSEM; i++)
+	{
+		if(flag & semflg[i])
+		{
+			continue;
+			PyFCGI_conf.context.ipc_flag ^= semflg[i];
+			if(sem_close(PyFCGI_SEM(i).sem) < 0)
+			{
+				err = errno;
+				pyfcgi_log(LOG_ALERT,
+					"Unable to close semaphore %s('%s') : %s",
+					semnames[i], PyFCGI_SEM(i).name,
+					strerror(err));
+				PyFCGI_SEM(i).sem = NULL;
+			}
+		}
+	}
+	if(flag & IPC_SHMST)
+	{
+dprintf(2, "SHM not yet implemented...\n");
+res = -1;
+		//PyFCGI_conf.context.ipc_flag ^= IPC_SHMST;
+	}
+
+	return res;
+}
+
+int pyfcgi_IPC_destroy(pyfcgi_ipc_flag_t flag)
+{
+	short i;
+	int err, res;
+	
+	res = 0;
+	for(i=0; i<PYFCGI_NSEM; i++)
+	{
+		if(flag & semflg[i])
+		{
+			if(sem_unlink(PyFCGI_SEM(i).name) < 0)
+			{
+				err = errno;
+				pyfcgi_log(LOG_ALERT,
+					"Unable to destroy %s semaphore (%s) : %s",
+					semnames[i], PyFCGI_SEM(i).name,
+					strerror(err));
+				res = -1;
+			}
+		}
+	}
+	if(flag & IPC_SHMST)
+	{
+dprintf(2, "SHM not yet implemented...\n");
+res = -1;
+		//PyFCGI_conf.context.ipc_flag ^= IPC_SHMST;
+	}
+	return res;
+}
+

src/main.c

@@ -43,6 +43,7 @@
 #include "conf.h"
 #include "logger.h"
 #include "responder.h"
+#include "ipc.h"
 
 #define IDENT_FMT "pyfcgi[%d]"
 #define MAX_REQS 1024
@@ -119,6 +120,8 @@ int main(int argc, char **argv)
 
 	pool_handler_pid = 0;
 	default_conf();
+	pyfcgi_name_sems(getpid()); //name semaphore using master proc PID
+
 	pyfcgi_logger_init();
 	pyfcgi_logger_set_ident("MainProc");
 	if(parse_args(argc, argv))

src/pyworker.c

@@ -595,18 +595,11 @@ int ctl_get_rep_sz(int ctl_pipe, size_t* rep_sz)
 static void worker_set_idle()
 {
 	int err;
-	struct sembuf sop;
-
 	if(_worker_idle) { return; }
-
-	sop.sem_num = 0;
-	sop.sem_flg = 0;
-	sop.sem_op = 1;
-
-	if(semop(PyFCGI_conf.context.semid, &sop, 1) < 0)
+	if(sem_post(PyFCGI_SEM(SEM_WSTATE).sem) < 0)
 	{
 		err = errno;
-		pyfcgi_log(LOG_ERR, "error incrementing the semaphore : %s",
+		pyfcgi_log(LOG_ERR, "error incrementing the WSTATE semaphore : %s",
 			strerror(err));
 		return;
 	}
@@ -616,18 +609,17 @@ static void worker_set_idle()
 static void worker_set_busy()
 {
 	int err;
-	struct sembuf sop;
-
 	if(!_worker_idle) { return; }
-	
-	sop.sem_num = 0;
-	sop.sem_flg = 0;
-	sop.sem_op = -1;
-
-	if(semop(PyFCGI_conf.context.semid, &sop, 1) < 0)
+	if(sem_trywait(PyFCGI_SEM(SEM_WSTATE).sem) < 0)
 	{
 		err = errno;
-		pyfcgi_log(LOG_ERR, "error incrementing the semaphore : %s",
+		if(err == EAGAIN)
+		{//panic
+			pyfcgi_log(LOG_ALERT, "Unable to set busy ! WSTATE sem is allready 0 !!!");
+			_worker_idle = 0;
+			return;
+		}
+		pyfcgi_log(LOG_ERR, "error decrementing the WSTATE semaphore : %s",
 			strerror(err));
 		return;
 	}
@@ -638,6 +630,7 @@ void worker_sighandler(int signum)
 {
 	pyfcgi_log(LOG_INFO, "%s signal received, exiting...", strsignal(signum));
 	worker_set_busy();
+	pyfcgi_IPC_close(IPC_WSTATE | IPC_WREQS);
 	exit(0);
 }
 
@@ -650,5 +643,6 @@ void worker_sigalrmhandler(int signum)
 		PyErr_SetInterrupt();
 	}
 	worker_set_busy();
+	pyfcgi_IPC_close(IPC_WSTATE | IPC_WREQS);
 	return;
 }

src/responder.c

@@ -20,19 +20,38 @@
 
 void init_context()
 {
-	PyFCGI_conf.context.semid = 0;
 	PyFCGI_conf.context.pid = getpid();
 	PyFCGI_conf.context.ppid = getppid();
+
+	if(pyfcgi_IPC_create(IPC_WSTATE | IPC_WREQS | IPC_SEMST) < 0)
+	{
+		pyfcgi_log(LOG_ALERT, "Pool handler process is unable to create WSTATE SEM");
+		sleep(1);
+		clean_exit(PYFCGI_FATAL);
+	}
+	/*
+	if(pyfcgi_IPC_create(IPC_WSTATE) < 0)
+	{
+		pyfcgi_log(LOG_ALERT, "Pool handler process is unable to create WSTATE SEM");
+		sleep(1);
+		clean_exit(PYFCGI_FATAL);
+	}
+	if(pyfcgi_IPC_init(IPC_WREQS | IPC_SEMST) < 0)
+	{
+		pyfcgi_log(LOG_ALERT, "Pool handler process is unable to init IPC components");
+		sleep(1);
+		clean_exit(PYFCGI_FATAL);
+	}
+	*/
 }
 
 int responder_loop()
 {
 	unsigned int n_wrk, wanted_n, n;
 	pid_t *wrk_pids;
-	int semid, err;
+	int err;
 	int status;
 	pid_t ret;
-	struct sembuf sop;
 	/**@brief poll timeout */
 	struct timespec timeout;
 	/**@brief watchdog timeout */
@@ -54,9 +73,6 @@ int responder_loop()
 		exit(PYFCGI_FATAL);
 	}
 
-	sop.sem_num = 0;
-	sop.sem_op = 0;
-	sop.sem_flg = 0;
 	timeout.tv_sec = 0;
 	timeout.tv_nsec = 100000000;
 	idle = busy = 0;
@@ -89,8 +105,6 @@ int responder_loop()
 	}
 	bzero(wrk_pids, sizeof(int) * PyFCGI_conf.max_wrk);
 
-	PyFCGI_conf.context.semid = semid = new_semaphore();
-	
 	wanted_n = PyFCGI_conf.min_wrk;
 	n_wrk = 0;
 	// prespawning minimum worker count
@@ -100,7 +114,7 @@ int responder_loop()
 		PyFCGI_conf.context.n_wrk = n_wrk;
 	}
 	//Wait at least for a process to be ready
-	while(!semtimedop(semid, &sop, 1, &timeout));
+	while(!pyfcgi_pool_idle(&timeout));
 
 	// main loop, taking care to restart terminated workers, 
 	// spawn new one if needed, etc.
@@ -168,16 +182,8 @@ int responder_loop()
 		}
 
 		// Check if the pool is idle or busy
-		ret = semtimedop(semid, &sop, 1, &timeout);
-		if(ret < 0)
+		if(pyfcgi_pool_idle(&timeout))
 		{
-			err = errno;
-			if(err != EAGAIN)
-			{
-				pyfcgi_log(LOG_ERR, "Unable to read semaphore : %s",
-				       strerror(err));
-				exit(PYFCGI_FATAL);
-			}
 			// workers idle
 			busy = 0;
 			if(!idle)
@@ -193,7 +199,7 @@ int responder_loop()
 				idle = 0;
 			}
 		}
-		else if(!ret)
+		else
 		{
 			idle = 0;
 			if(!busy)
@@ -287,6 +293,12 @@ pid_t spawn(int wrk_id)
 		PyFCGI_conf.context.pid = getpid();
 		snprintf(ident, 128, "Worker%2d", wrk_id);
 		pyfcgi_logger_set_ident(ident);
+		// Init IPC components
+		if(pyfcgi_IPC_init(IPC_WSTATE | IPC_WREQS) < 0)
+		{
+			pyfcgi_log(LOG_ALERT, "Unable to initialize semaphore when spawning process...");
+			exit(PYFCGI_FATAL);
+		}
 		// Set handler for SIGINT & SIGTERM
 		if(sigaction(SIGINT, &act, NULL))
 		{
@@ -315,6 +327,7 @@ pid_t spawn(int wrk_id)
 			exit(work(wrk_id));
 		}
 	}
+	pyfcgi_IPC_init(IPC_WSTATE | IPC_WREQS | IPC_SEMST);
 	// Sleep to avoid spawning like hell thinking all workers are
 	// busy. Let some time to this one to go up...
 	// TODO: find a better way to avoid spawning to max_wrk
@@ -324,42 +337,68 @@ pid_t spawn(int wrk_id)
 	return res;
 }
 
-int new_semaphore(key_t semkey)
+int pyfcgi_pool_state()
 {
-	int semid, err;
-
-	semid = semget(IPC_PRIVATE, 2, 0770);
-
-	if(semid == -1)
+	int err, res;
+	if(sem_getvalue(PyFCGI_SEM(SEM_WSTATE).sem, &res) < 0)
 	{
 		err = errno;
-		pyfcgi_log(	LOG_ALERT,
-			"Unable to create semaphore : %s",
+		pyfcgi_log(LOG_ALERT, "Unable to read WSTATE semaphore value : %s",
 			strerror(err));
-		clean_exit(err);
+		clean_exit(PYFCGI_FATAL);
 	}
-	if(PyFCGI_conf.context.semid)
+	return res;
+}
+
+int pyfcgi_pool_idle(const struct timespec *timeout)
+{
+	int err;
+	struct timespec abs_timeout;
+
+	if(clock_gettime(CLOCK_REALTIME_COARSE, &abs_timeout) < 0)
+	{
+		//clock error
+		pyfcgi_log(LOG_WARNING, "Unable to fetch asbtime for WSTATE sem_timedwait : %s",
+			strerror(errno));
+	}
+	abs_timeout.tv_sec += timeout->tv_sec;
+	if(abs_timeout.tv_nsec + timeout->tv_nsec > 999999999)
+	{
+		abs_timeout.tv_nsec = abs_timeout.tv_nsec + timeout->tv_nsec - 999999999;
+		abs_timeout.tv_sec +=1;
+	}
+	else
 	{
-		pyfcgi_log(	LOG_WARNING,
-			"The semid context was not zero when calling new_semaphore, attempt to closeing it.");
-		semctl(PyFCGI_conf.context.semid, 0, IPC_RMID);
+		abs_timeout.tv_nsec = timeout->tv_nsec;
+	}
 
+	if(sem_timedwait(PyFCGI_SEM(SEM_WSTATE).sem, &abs_timeout) < 0)
+	{
+		err = errno;
+		switch(err)
+		{
+			case ETIMEDOUT:
+			case EAGAIN:
+				return 0; //busy
+			case EINVAL:
+				sleep(1);
+				return 1;
+			default:
+				pyfcgi_log(LOG_ALERT, "Unable to wait WSTATE sem : %s",
+					strerror(err));
+				clean_exit(PYFCGI_FATAL);
+		}
 	}
-	PyFCGI_conf.context.semid = semid;
-	return semid;
+	sem_post(PyFCGI_SEM(SEM_WSTATE).sem); //Hope no worker fails to set busy...
+	return 1; //idle
 }
 
 void clean_exit(int status)
 {
-	if(PyFCGI_conf.context.semid &&
-		semctl(PyFCGI_conf.context.semid, 0, IPC_RMID) == -1)
-	{
-		/*silentely fails (when exiting from sighandler)
-		pyfcgi_log(	LOG_CRIT,
-			"Unable to delete semaphore before exiting : %s",
-			strerror(errno));
-		*/
-	}
+	pyfcgi_IPC_close(IPC_WSTATE | IPC_WREQS | IPC_SEMST | IPC_SHMST);
+	//temporarly destroy everything....
+	pyfcgi_IPC_destroy(IPC_WSTATE | IPC_WREQS | IPC_SEMST | IPC_SHMST);
+	//pyfcgi_IPC_destroy(IPC_WSTATE);
 	exit(status);
 }