Fixed autodetection of the reactor size (open files)

If we auto-detect the size of the reactor(via rulimit), be sure we have enough pkg memory (and do the necessary correction).
If the open files limit is given, warn if the reactor will use too much memory.
Thanks to MAxim Sobolev for reporting it via mailing list and to @cepehutu
Closes OpenSIPS#778

(cherry picked from commit 6dd88ab)

Author: bogdan-iancu

daemonize.c

@@ -449,8 +449,9 @@ int do_suid(const int uid, const int gid)
 
 
 /*!
- * \brief try to increase the open file limit
- * \param target target that should be reached
+ * \brief try to increase the open file limit to the value given by the global
+ *        option "open_files_limit" ; the value is updated back in case of a
+ *        partial increase of the limit
  * \return return 0 on success, -1 on error
  */
 int set_open_fds_limit(void)
@@ -465,11 +466,6 @@ int set_open_fds_limit(void)
 	orig=lim;
 	LM_DBG("current open file limits: %lu/%lu\n",
 			(unsigned long)lim.rlim_cur, (unsigned long)lim.rlim_max);
-	if (open_files_limit<=0) {
-		/* if not set from cfg, we just read the existing value */
-		open_files_limit = lim.rlim_cur;
-		goto done;
-	}
 	if ((lim.rlim_cur==RLIM_INFINITY) || (open_files_limit<=lim.rlim_cur))
 		/* nothing to do (we do no reduce the limit) */
 		goto done;

main.c

@@ -67,7 +67,7 @@
  * the TCP, UDP, timer and fifo children.
  */
 
-
+#include "reactor_defs.h" /*keep this first*/
 #include <stdio.h>
 #include <stdlib.h>
 #include <errno.h>
@@ -81,7 +81,6 @@
 #include <netinet/ip.h>
 #include <arpa/inet.h>
 #include <sys/utsname.h>
-#include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/mman.h>
 #include <fcntl.h>
@@ -1154,9 +1153,11 @@ int main(int argc, char** argv)
 
 	if (disable_core_dump) set_core_dump(0, 0);
 	else set_core_dump(1, shm_mem_size+pkg_mem_size+4*1024*1024);
-	if(set_open_fds_limit()<0){
-		LM_ERR("ERROR: error could not increase file limits\n");
-		goto error;
+	if (open_files_limit>0) {
+		if(set_open_fds_limit()<0){
+			LM_ERR("ERROR: error could not increase file limits\n");
+			goto error;
+		}
 	}
 
 	/* print OpenSIPS version to log for history tracking */
@@ -1167,6 +1168,12 @@ int main(int argc, char** argv)
 	LM_INFO("using %ld Mb private memory per process\n",
 		((pkg_mem_size/1024)/1024));
 
+	/* init async reactor */
+	if (init_reactor_size()<0) {
+		LM_CRIT("failed to init internal reactor, exiting...\n");
+		goto error;
+	}
+
 	/* init timer */
 	if (init_timer()<0){
 		LM_CRIT("could not initialize timer, exiting...\n");

net/net_tcp.c

@@ -1453,7 +1453,7 @@ static void tcp_main_server(void)
 
 	/* we run in a separate, dedicated process, with its own reactor
 	 * (reactors are per process) */
-	if (init_worker_reactor("TCP_main", open_files_limit, RCT_PRIO_MAX)<0)
+	if (init_worker_reactor("TCP_main", RCT_PRIO_MAX)<0)
 		goto error;
 
 	/* now start watching all the fds*/

net/net_tcp_proc.c

@@ -288,7 +288,7 @@ void tcp_worker_proc( int unix_sock)
 {
 	/* init reactor for TCP worker */
 	tcpmain_sock=unix_sock; /* init com. socket */
-	if ( init_worker_reactor("TCP_worker",open_files_limit,RCT_PRIO_MAX)<0 ) {
+	if ( init_worker_reactor( "TCP_worker", RCT_PRIO_MAX)<0 ) {
 		goto error;
 	}
 

net/net_udp.c

@@ -287,7 +287,7 @@ inline static int handle_io(struct fd_map* fm, int idx,int event_type)
 int udp_rcv_loop( struct socket_info *si )
 {
 	/* create the reactor for UDP proc */
-	if ( init_worker_reactor("UDP_worker",open_files_limit,RCT_PRIO_MAX)<0 ) {
+	if ( init_worker_reactor( "UDP_worker", RCT_PRIO_MAX)<0 ) {
 		LM_ERR("failed to init reactor\n");
 		goto error;
 	}

reactor.c

@@ -23,8 +23,74 @@
  *  2014-08-23  created (bogdan)
  */
 
+#include <sys/time.h>
+#include <sys/resource.h>
+
 #include "io_wait.h"
+#include "globals.h"
 
 /* one reactor per process variable */
 io_wait_h _worker_io;
+/* max number of fds per reactor */
+unsigned int reactor_size = 0;
+
+#define FD_MEM_PERCENT  10
+
+int init_reactor_size(void)
+{
+	struct rlimit lim;
+	int n, pc;
+
+	n = sizeof(struct fd_map) + sizeof(struct pollfd);
+
+	if (open_files_limit>0) {
+
+		/* the fd limit was explicitly set, so just follow but only warn 
+		 * if too much memory is to consumed by reactor */
+		pc = 100*n*open_files_limit / pkg_mem_size;
+		if (pc>=80) {
+			LM_ERR("required memory for a %d files reactor is over 80%% of"
+				" the configured pkg mem (%luMb)\n",
+				open_files_limit, pkg_mem_size);
+			LM_ERR("Please consider increasing the pkg memory or reduce the"
+				" limit of open files...Exiting\n");
+			return -1;
+		} else if (pc>=50) {
+			LM_WARN("required memory for a %d files reactor is over 50%% of"
+				" the configured pkg mem (%luMb)\n",
+				open_files_limit, pkg_mem_size);
+			LM_WARN("PKG memory may not be enough at runtime (consider "
+				"increasing it), still continuing\n");
+		}
+		/* seems to have enough mem -> size the reactor based on open files */
+		reactor_size = open_files_limit;
+
+	} else {
+
+		/* auto detect the limit of open files */
+		if (getrlimit(RLIMIT_NOFILE, &lim)<0){
+			LM_ERR("cannot get the maximum number of file descriptors: %s\n",
+				strerror(errno));
+			return -1;
+		}
+
+		/* calculate the size to fit into 10% PKG mem */
+		reactor_size = pkg_mem_size * FD_MEM_PERCENT / (100*n);
+
+		if (reactor_size<lim.rlim_cur) {
+			LM_WARN("shrinking reactor size from %lu (autodetected via rlimit)"
+				" to %d (limited by memory of %d%% from %luMb)\n",
+				lim.rlim_cur,reactor_size,FD_MEM_PERCENT,pkg_mem_size);
+			LM_WARN("use 'open_files_limit' to enforce other limit or "
+				"increase PKG memory\n");
+		} else {
+			/* enouhg memory, use as limit the fd limit */
+			reactor_size = lim.rlim_cur;
+		}
+	}
+
+	LM_DBG("using reactor size %d\n",reactor_size);
+
+	return 0;
+}
 

reactor_defs.h

@@ -68,9 +68,12 @@ enum fd_types { F_NONE=0,
 		};
 
 extern io_wait_h _worker_io;
+extern unsigned int reactor_size;
 
-#define init_worker_reactor( _name, _max_fd, _prio_max) \
-	init_io_wait(&_worker_io, _name, _max_fd, io_poll_method, _prio_max)
+int init_reactor_size(void);
+
+#define init_worker_reactor( _name, _prio_max) \
+	init_io_wait(&_worker_io, _name, reactor_size, io_poll_method, _prio_max)
 
 #define reactor_add_reader( _fd, _type, _prio, _data) \
 	io_watch_add(&_worker_io, _fd, _type, _data, _prio, IO_WATCH_READ)