Begin SHM support implementation for stats server process

include/conf.h

 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;
+typedef struct pyfcgi_shmdata_s pyfcgi_shmdata_t;
 
 /**@brief Configuration globals, inherited from parent to childs
  * @ingroup conf_internal
 #define PYENTRY_DEFAULT_FUN "application"
 
 /**@brief Stores a semaphore name and pointer */
-struct pyfcgi_semdata_s {
+struct pyfcgi_semdata_s
+{
 	/**@brief Semaphore names. Set by master process */
 	char name[NAME_MAX - 4];
 	/**@brief Semaphore pointer. */
 	sem_t *sem;
 };
 
+/**@brief Stores an SHM name and pointer */
+struct pyfcgi_shmdata_s
+{
+	/**@brief SHM name. Set by master process */
+	char name[NAME_MAX];
+	/**@brief SHM file descriptor */
+	int fd;
+	/**@brief SHM size */
+	size_t len;
+
+	/**@brief SHM pointer */
+	void *ptr;
+};
+
 
 /**@brief Stores contextual informations about current process */
 struct pyfcgi_context_s {
 	 * - sems[2] is the stats/status SHM semaphore
 	 */
 	pyfcgi_semdata_t sems[PYFCGI_NSEM];
+	/**@brief Shared memory informations */
+	pyfcgi_shmdata_t shm;
 
 	/**@brief Stores a copy of the specified socket URL to listen to. */
 	char *mon_socket;

include/ipc.h

 
 #include <fcntl.h>
 #include <semaphore.h>
+#include <sys/mman.h>
 #include <sys/stat.h>
 
 /**@brief Format for sem and shm */
 typedef unsigned short pyfcgi_ipc_flag_t;
 
 #include "conf.h"
+#include "stats.h" //to get SHM size
 
 /**@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);
+void pyfcgi_name_IPC(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

include/stats.h

 #define PYFCGI_STATS_SZ (900)
 
 typedef struct pyfcgi_stats_s pyfcgi_stats_t;
+typedef struct pyfcgi_stats_shm_s pyfcgi_stats_shm_t;
 
 #include "conf.h"
 #include "logger.h"
 	size_t buff_len;
 };
 
+struct pyfcgi_stats_shm_s
+{
+	int nworker;
+	int pool_load;
+};
+
 /**@brief Starts collecting statistics
  *
  * Set an handler for SIGALRM and set a repeating alarm each seconds

src/ipc.c

 static const pyfcgi_ipc_flag_t semflg[PYFCGI_NSEM] = {
 	IPC_WSTATE, IPC_WREQS, IPC_SEMST};
 
-void pyfcgi_name_sems(pid_t master_pid)
+void pyfcgi_name_IPC(pid_t master_pid)
 {
 	short i;
 	for(i=0; i<PYFCGI_NSEM; i++)
 			exit(PYFCGI_FATAL);
 		}
 	}
+	if(snprintf(PyFCGI_conf.shm.name, NAME_MAX, PYFCGI_IPCNAME_FMT,
+		master_pid, "SHMstats") < 0)
+	{
+		perror("Error setting shm name");
+		exit(PYFCGI_FATAL);
+	}
+	PyFCGI_conf.shm.len = sizeof(pyfcgi_stats_shm_t);
 }
 
 int pyfcgi_IPC_create(pyfcgi_ipc_flag_t flag)
 		if(flag & semflg[i])
 		{
 			flag ^= semflg[i];
-			PyFCGI_SEM(i).sem = sem_open(PyFCGI_SEM(i).name, O_CREAT | O_EXCL,
-				0770, 0);
+			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",
+					"Unable to create semaphore %s(named '%s') : %s",
 					semnames[i], PyFCGI_SEM(i).name,
 					strerror(err));
 				PyFCGI_SEM(i).sem = NULL;
 	if(flag & IPC_SHMST)
 	{
 		flag ^= IPC_SHMST;
-dprintf(2, "SHM not yet implemented...\n");
-res = -1;
-		//PyFCGI_conf.context.ipc_flag |= IPC_SHMST;
+		PyFCGI_conf.shm.fd = shm_open(PyFCGI_conf.shm.name,
+			O_RDWR | O_CREAT | O_EXCL, 0770);
+		if(PyFCGI_conf.shm.fd == -1)
+		{
+			err = errno;
+			pyfcgi_log(LOG_ALERT,
+				"Unable to create SHM '%s' : %s",
+				PyFCGI_conf.shm.name, strerror(errno));
+			PyFCGI_conf.shm.fd = 0;
+			return -1;
+		}
+		PyFCGI_conf.context.ipc_flag |= IPC_SHMST;
+		if(ftruncate(PyFCGI_conf.shm.fd,
+			sizeof(pyfcgi_stats_shm_t)) < 0)
+		{
+			pyfcgi_log(LOG_ALERT,
+				"Unable to truncate SHM to wanted size %ld : %s",
+				sizeof(pyfcgi_stats_shm_t),
+				strerror(errno));
+			pyfcgi_IPC_destroy(IPC_SHMST);
+			return -1;
+		}
+pyfcgi_log(LOG_INFO, "MMAP LENGHt : %ld", PyFCGI_conf.shm.len);
+		PyFCGI_conf.shm.ptr = mmap(NULL, PyFCGI_conf.shm.len,
+			PROT_READ | PROT_WRITE, MAP_SHARED, PyFCGI_conf.shm.fd,
+			0);
+		if(PyFCGI_conf.shm.ptr == (void*)-1)
+		{
+			pyfcgi_log(LOG_ALERT,
+				"Unable to mmap SHM : %s", strerror(errno));
+			pyfcgi_IPC_destroy(IPC_SHMST);
+			return -1;
+		}
 	}
 	return res;
 }
 	if(flag & IPC_SHMST)
 	{
 		flag ^= IPC_SHMST;
-dprintf(2, "SHM not yet implemented...\n");
-res = -1;
-		//PyFCGI_conf.context.ipc_flag |= IPC_SHMST;
+		PyFCGI_conf.shm.fd = shm_open(PyFCGI_conf.shm.name, O_RDONLY, 0);
+		if(PyFCGI_conf.shm.fd == -1)
+		{
+			err = errno;
+			pyfcgi_log(LOG_ALERT,
+				"Unable to open SHM '%s' : %s",
+				PyFCGI_conf.shm.name, strerror(errno));
+			PyFCGI_conf.shm.fd = 0;
+			return -1;
+		}
+
+		PyFCGI_conf.context.ipc_flag |= IPC_SHMST;
+		PyFCGI_conf.shm.ptr = mmap(NULL, PyFCGI_conf.shm.len,
+			PROT_READ, MAP_SHARED, PyFCGI_conf.shm.fd, 0);
+		if(PyFCGI_conf.shm.ptr == (void*)-1)
+		{
+			pyfcgi_log(LOG_ALERT,
+				"Unable to mmap SHM : %s", strerror(errno));
+			pyfcgi_IPC_destroy(IPC_SHMST);
+			return -1;
+		}
 	}
 	return res;
 }
 	}
 	if(flag & IPC_SHMST)
 	{
-dprintf(2, "SHM not yet implemented...\n");
-res = -1;
-		//PyFCGI_conf.context.ipc_flag ^= IPC_SHMST;
+		if(PyFCGI_conf.shm.ptr &&
+			munmap(PyFCGI_conf.shm.ptr, PyFCGI_conf.shm.len) < 0)
+		{
+			pyfcgi_log(LOG_WARNING, "Unable to unmap SHM : %s",
+				strerror(errno));
+		}
+		if(close(PyFCGI_conf.shm.fd) < 0)
+		{
+			pyfcgi_log(LOG_WARNING, "Unable to close SHM : %s",
+				strerror(errno));
+		}
+		PyFCGI_conf.shm.fd = 0;
+		PyFCGI_conf.shm.ptr = NULL;
+		PyFCGI_conf.context.ipc_flag ^= IPC_SHMST;
 	}
 
 	return res;
 	}
 	if(flag & IPC_SHMST)
 	{
-dprintf(2, "SHM not yet implemented...\n");
-res = -1;
-		//PyFCGI_conf.context.ipc_flag ^= IPC_SHMST;
+
+		if(PyFCGI_conf.shm.ptr &&
+			munmap(PyFCGI_conf.shm.ptr, PyFCGI_conf.shm.len) < 0)
+		{
+			pyfcgi_log(LOG_WARNING, "Unable to unmap SHM : %s",
+				strerror(errno));
+		}
+		if(close(PyFCGI_conf.shm.fd) < 0)
+		{
+			pyfcgi_log(LOG_WARNING, "Unable to close SHM : %s",
+				strerror(errno));
+		}
+		if(shm_unlink(PyFCGI_conf.shm.name) < 0)
+		{
+			pyfcgi_log(LOG_WARNING, "Unabe to unlink SHM : %s",
+				strerror(errno));
+		}
+		PyFCGI_conf.shm.fd = 0;
+		PyFCGI_conf.shm.ptr = NULL;
+		PyFCGI_conf.context.ipc_flag ^= IPC_SHMST;
 	}
 	return res;
 }

src/main.c

 	pool_handler_pid = 0;
 	monitor_serv_pid = 0;
 	default_conf();
-	pyfcgi_name_sems(getpid()); //name semaphore using master proc PID
+	pyfcgi_name_IPC(getpid()); //name semaphore using master proc PID
 
 	pyfcgi_logger_init();
 	pyfcgi_logger_set_ident("MainProc");
 		if(child_ret)
 		{
 
-			pyfcgi_log(LOG_ERR, "%s exits with error code '%d'",
-				child_name, WEXITSTATUS(child_ret));
+			pyfcgi_log(LOG_ERR, "%s exits with error code : %s",
+				child_name, status2str(WEXITSTATUS(child_ret)));
 			if(WIFSIGNALED(child_ret))
 			{
 				pyfcgi_log(LOG_ERR, "%s terminated by sig %s(%d)",

src/monitor.c

 	ret = 0;
 	if(!PyFCGI_SEM_OPEN(SEM_WREQS))
 	{
-		pyfcgi_IPC_init(IPC_WREQS);
-		ret = -1;
+		if(pyfcgi_IPC_init(IPC_WREQS)) { ret = -1; }
 	}
 	if(!PyFCGI_SEM_OPEN(SEM_STATS))
 	{
-		pyfcgi_IPC_init(IPC_SEMST);
-		ret = -1;
+		if(pyfcgi_IPC_init(IPC_SEMST)) { ret = -1; }
+	}
+	if(!PyFCGI_conf.shm.ptr)
+	{
+		if(pyfcgi_IPC_init(IPC_SHMST)) { ret = -1; }
 	}
-	//pyfcgi_IPC_init(IPC_SHMST);
 	return ret;
 }
 
 	pyfcgi_log(LOG_INFO, "Listening on %s", PyFCGI_conf.mon_socket);
 
 	//bind successfull, sending to appropriate response loop
-	pyfcgi_monitor_IPC_init(); //check returned value !
+	if(pyfcgi_monitor_IPC_init() < 0)
+	{
+		pyfcgi_log(LOG_ERR, "Unable to initialize IPC");
+		sleep(1);
+		exit(PYFCGI_ERR);
+	}
 	pyfcgi_stats_init();
 
 	if(pyfcgi_mon.sockargs[1] == SOCK_DGRAM)

src/responder.c

 	PyFCGI_conf.context.pid = getpid();
 	PyFCGI_conf.context.ppid = getppid();
 
-	if(pyfcgi_IPC_create(IPC_WSTATE | IPC_WREQS | IPC_SEMST) < 0)
+	if(pyfcgi_IPC_create(IPC_WSTATE | IPC_WREQS | IPC_SEMST | IPC_SHMST) < 0)
 	{
 		pyfcgi_log(LOG_ALERT, "Pool handler process is unable to init IPC components");
 		sleep(1);