move "totalstats" out of callmaster into global scope

Change-Id: Ia5b95e788c1d486a86b6f916dcff5b88022f5897

daemon/call.c

@@ -624,17 +624,6 @@ struct callmaster *callmaster_new() {
 
 	poller_add_timer(rtpe_poller, callmaster_timer, &c->obj);
 
-	mutex_init(&c->totalstats.total_average_lock);
-	mutex_init(&c->totalstats_interval.total_average_lock);
-	mutex_init(&c->totalstats_interval.managed_sess_lock);
-	mutex_init(&c->totalstats_interval.total_calls_duration_lock);
-
-	c->totalstats.started = rtpe_now.tv_sec;
-	//c->totalstats_interval.managed_sess_min = 0; // already zeroed
-	//c->totalstats_interval.managed_sess_max = 0;
-
-	mutex_init(&c->totalstats_lastinterval_lock);
-
 	return c;
 
 fail:
@@ -1733,11 +1722,11 @@ void add_total_calls_duration_in_interval(struct callmaster *cm,
 	struct timeval ongoing_calls_dur = add_ongoing_calls_dur_in_interval(cm,
 			&cm->latest_graphite_interval_start, interval_tv);
 
-	mutex_lock(&cm->totalstats_interval.total_calls_duration_lock);
-	timeval_add(&cm->totalstats_interval.total_calls_duration_interval,
-			&cm->totalstats_interval.total_calls_duration_interval,
+	mutex_lock(&rtpe_totalstats_interval.total_calls_duration_lock);
+	timeval_add(&rtpe_totalstats_interval.total_calls_duration_interval,
+			&rtpe_totalstats_interval.total_calls_duration_interval,
 			&ongoing_calls_dur);
-	mutex_unlock(&cm->totalstats_interval.total_calls_duration_lock);
+	mutex_unlock(&rtpe_totalstats_interval.total_calls_duration_lock);
 }
 
 static struct timeval add_ongoing_calls_dur_in_interval(struct callmaster *m,
@@ -1863,7 +1852,7 @@ void call_destroy(struct call *c) {
 						atomic64_get(&ps->stats.errors),
 						rtpe_now.tv_sec - atomic64_get(&ps->last_packet));
 
-				statistics_update_totals(m,ps);
+				statistics_update_totals(ps);
 
 			}
 
@@ -2056,7 +2045,7 @@ restart:
 		if (type == CT_FOREIGN_CALL)  /* foreign call*/
 					c->foreign_call = 1;
 
-		statistics_update_foreignown_inc(m,c);
+		statistics_update_foreignown_inc(c);
 
 		rwlock_lock_w(&c->master_lock);
 		rwlock_unlock_w(&rtpe_callhash_lock);

daemon/call.h

@@ -416,11 +416,6 @@ struct callmaster_config {
 struct callmaster {
 	struct obj		obj;
 
-	struct totalstats       totalstats;
-	struct totalstats       totalstats_interval;
-	mutex_t		        	totalstats_lastinterval_lock;
-	struct totalstats       totalstats_lastinterval;
-
 	struct callmaster_config conf;
 	struct timeval          latest_graphite_interval_start;
 };

daemon/call_interfaces.c

@@ -822,8 +822,8 @@ const char *call_offer_ng(bencode_item_t *input, struct callmaster *m, bencode_i
 			rwlock_unlock_r(&rtpe_callhash_lock);
 			/* foreign calls can't get rejected
 			 * total_rejected_sess applies only to "own" sessions */
-			atomic64_inc(&m->totalstats.total_rejected_sess);
-			atomic64_inc(&m->totalstats_interval.total_rejected_sess);
+			atomic64_inc(&rtpe_totalstats.total_rejected_sess);
+			atomic64_inc(&rtpe_totalstats_interval.total_rejected_sess);
 			ilog(LOG_ERROR, "Parallel session limit reached (%i)",m->conf.max_sessions);
 
 			rwlock_unlock_r(&m->conf.config_lock);

daemon/cli.c

@@ -22,6 +22,7 @@
 #include "streambuf.h"
 #include "tcp_listener.h"
 #include "str.h"
+#include "statistics.h"
 
 #include "rtpengine_config.h"
 
@@ -170,34 +171,34 @@ static void cli_incoming_list_totals(str *instr, struct callmaster* m, struct st
 	u_int64_t num_sessions, min_sess_iv, max_sess_iv;
 	struct request_time offer_iv, answer_iv, delete_iv;
 
-	mutex_lock(&m->totalstats.total_average_lock);
-	avg = m->totalstats.total_average_call_dur;
-	num_sessions = m->totalstats.total_managed_sess;
-	mutex_unlock(&m->totalstats.total_average_lock);
+	mutex_lock(&rtpe_totalstats.total_average_lock);
+	avg = rtpe_totalstats.total_average_call_dur;
+	num_sessions = rtpe_totalstats.total_managed_sess;
+	mutex_unlock(&rtpe_totalstats.total_average_lock);
 
 	streambuf_printf(replybuffer, "\nTotal statistics (does not include current running sessions):\n\n");
-	streambuf_printf(replybuffer, " Uptime of rtpengine                             :%llu seconds\n", (unsigned long long)time(NULL)-m->totalstats.started);
+	streambuf_printf(replybuffer, " Uptime of rtpengine                             :%llu seconds\n", (unsigned long long)time(NULL)-rtpe_totalstats.started);
 	streambuf_printf(replybuffer, " Total managed sessions                          :"UINT64F"\n", num_sessions);
-	streambuf_printf(replybuffer, " Total rejected sessions                         :"UINT64F"\n", atomic64_get(&m->totalstats.total_rejected_sess));
-	streambuf_printf(replybuffer, " Total timed-out sessions via TIMEOUT            :"UINT64F"\n",atomic64_get(&m->totalstats.total_timeout_sess));
-	streambuf_printf(replybuffer, " Total timed-out sessions via SILENT_TIMEOUT     :"UINT64F"\n",atomic64_get(&m->totalstats.total_silent_timeout_sess));
-	streambuf_printf(replybuffer, " Total timed-out sessions via FINAL_TIMEOUT      :"UINT64F"\n",atomic64_get(&m->totalstats.total_final_timeout_sess));
-	streambuf_printf(replybuffer, " Total regular terminated sessions               :"UINT64F"\n",atomic64_get(&m->totalstats.total_regular_term_sess));
-	streambuf_printf(replybuffer, " Total forced terminated sessions                :"UINT64F"\n",atomic64_get(&m->totalstats.total_forced_term_sess));
-	streambuf_printf(replybuffer, " Total relayed packets                           :"UINT64F"\n",atomic64_get(&m->totalstats.total_relayed_packets));
-	streambuf_printf(replybuffer, " Total relayed packet errors                     :"UINT64F"\n",atomic64_get(&m->totalstats.total_relayed_errors));
-	streambuf_printf(replybuffer, " Total number of streams with no relayed packets :"UINT64F"\n", atomic64_get(&m->totalstats.total_nopacket_relayed_sess));
-	streambuf_printf(replybuffer, " Total number of 1-way streams                   :"UINT64F"\n",atomic64_get(&m->totalstats.total_oneway_stream_sess));
+	streambuf_printf(replybuffer, " Total rejected sessions                         :"UINT64F"\n", atomic64_get(&rtpe_totalstats.total_rejected_sess));
+	streambuf_printf(replybuffer, " Total timed-out sessions via TIMEOUT            :"UINT64F"\n",atomic64_get(&rtpe_totalstats.total_timeout_sess));
+	streambuf_printf(replybuffer, " Total timed-out sessions via SILENT_TIMEOUT     :"UINT64F"\n",atomic64_get(&rtpe_totalstats.total_silent_timeout_sess));
+	streambuf_printf(replybuffer, " Total timed-out sessions via FINAL_TIMEOUT      :"UINT64F"\n",atomic64_get(&rtpe_totalstats.total_final_timeout_sess));
+	streambuf_printf(replybuffer, " Total regular terminated sessions               :"UINT64F"\n",atomic64_get(&rtpe_totalstats.total_regular_term_sess));
+	streambuf_printf(replybuffer, " Total forced terminated sessions                :"UINT64F"\n",atomic64_get(&rtpe_totalstats.total_forced_term_sess));
+	streambuf_printf(replybuffer, " Total relayed packets                           :"UINT64F"\n",atomic64_get(&rtpe_totalstats.total_relayed_packets));
+	streambuf_printf(replybuffer, " Total relayed packet errors                     :"UINT64F"\n",atomic64_get(&rtpe_totalstats.total_relayed_errors));
+	streambuf_printf(replybuffer, " Total number of streams with no relayed packets :"UINT64F"\n", atomic64_get(&rtpe_totalstats.total_nopacket_relayed_sess));
+	streambuf_printf(replybuffer, " Total number of 1-way streams                   :"UINT64F"\n",atomic64_get(&rtpe_totalstats.total_oneway_stream_sess));
 	streambuf_printf(replybuffer, " Average call duration                           :%ld.%06ld\n\n",avg.tv_sec,avg.tv_usec);
 
-	mutex_lock(&m->totalstats_lastinterval_lock);
-	calls_dur_iv = m->totalstats_lastinterval.total_calls_duration_interval;
-	min_sess_iv = m->totalstats_lastinterval.managed_sess_min;
-	max_sess_iv = m->totalstats_lastinterval.managed_sess_max;
-	offer_iv = m->totalstats_lastinterval.offer;
-	answer_iv = m->totalstats_lastinterval.answer;
-	delete_iv = m->totalstats_lastinterval.delete;
-	mutex_unlock(&m->totalstats_lastinterval_lock);
+	mutex_lock(&rtpe_totalstats_lastinterval_lock);
+	calls_dur_iv = rtpe_totalstats_lastinterval.total_calls_duration_interval;
+	min_sess_iv = rtpe_totalstats_lastinterval.managed_sess_min;
+	max_sess_iv = rtpe_totalstats_lastinterval.managed_sess_max;
+	offer_iv = rtpe_totalstats_lastinterval.offer;
+	answer_iv = rtpe_totalstats_lastinterval.answer;
+	delete_iv = rtpe_totalstats_lastinterval.delete;
+	mutex_unlock(&rtpe_totalstats_lastinterval_lock);
 
 	// compute average offer/answer/delete time
 	timeval_divide(&offer_iv.time_avg, &offer_iv.time_avg, offer_iv.count);

daemon/control_ng.c

@@ -247,11 +247,11 @@ static void control_ng_incoming(struct obj *obj, str *buf, const endpoint_t *sin
 
 	// update interval statistics
 	if (!str_cmp(&cmd, "offer")) {
-		timeval_update_request_time(&c->callmaster->totalstats_interval.offer, &offer_stop);
+		timeval_update_request_time(&rtpe_totalstats_interval.offer, &offer_stop);
 	} else if (!str_cmp(&cmd, "answer")) {
-		timeval_update_request_time(&c->callmaster->totalstats_interval.answer, &answer_stop);
+		timeval_update_request_time(&rtpe_totalstats_interval.answer, &answer_stop);
 	} else if (!str_cmp(&cmd, "delete")) {
-		timeval_update_request_time(&c->callmaster->totalstats_interval.delete, &delete_stop);
+		timeval_update_request_time(&rtpe_totalstats_interval.delete, &delete_stop);
 	}
 
 	goto send_resp;

daemon/graphite.c

@@ -20,6 +20,7 @@
 #include "call.h"
 #include "graphite.h"
 #include "socket.h"
+#include "statistics.h"
 
 static socket_t graphite_sock;
 static int connection_state = STATE_DISCONNECTED;
@@ -102,45 +103,45 @@ int send_graphite_data(struct callmaster *cm, struct totalstats *sent_data) {
 	struct totalstats *ts = sent_data;
 
 	/* atomically copy values to stack and reset to zero */
-	atomic64_local_copy_zero_struct(ts, &cm->totalstats_interval, total_timeout_sess);
-	atomic64_local_copy_zero_struct(ts, &cm->totalstats_interval, total_rejected_sess);
-	atomic64_local_copy_zero_struct(ts, &cm->totalstats_interval, total_silent_timeout_sess);
-	atomic64_local_copy_zero_struct(ts, &cm->totalstats_interval, total_final_timeout_sess);
-	atomic64_local_copy_zero_struct(ts, &cm->totalstats_interval, total_regular_term_sess);
-	atomic64_local_copy_zero_struct(ts, &cm->totalstats_interval, total_forced_term_sess);
-	atomic64_local_copy_zero_struct(ts, &cm->totalstats_interval, total_relayed_packets);
-	atomic64_local_copy_zero_struct(ts, &cm->totalstats_interval, total_relayed_errors);
-	atomic64_local_copy_zero_struct(ts, &cm->totalstats_interval, total_nopacket_relayed_sess);
-	atomic64_local_copy_zero_struct(ts, &cm->totalstats_interval, total_oneway_stream_sess);
-
-	mutex_lock(&cm->totalstats_interval.total_average_lock);
-	ts->total_average_call_dur = cm->totalstats_interval.total_average_call_dur;
-	ts->total_managed_sess = cm->totalstats_interval.total_managed_sess;
-	ZERO(cm->totalstats_interval.total_average_call_dur);
-	ZERO(cm->totalstats_interval.total_managed_sess);
-	mutex_unlock(&cm->totalstats_interval.total_average_lock);
-
-	mutex_lock(&cm->totalstats_interval.total_calls_duration_lock);
-	ts->total_calls_duration_interval = cm->totalstats_interval.total_calls_duration_interval;
-	cm->totalstats_interval.total_calls_duration_interval.tv_sec = 0;
-	cm->totalstats_interval.total_calls_duration_interval.tv_usec = 0;
-	//ZERO(cm->totalstats_interval.total_calls_duration_interval);
-	mutex_unlock(&cm->totalstats_interval.total_calls_duration_lock);
-
-	ts->offer = timeval_clear_request_time(&cm->totalstats_interval.offer);
-	ts->answer = timeval_clear_request_time(&cm->totalstats_interval.answer);
-	ts->delete = timeval_clear_request_time(&cm->totalstats_interval.delete);
+	atomic64_local_copy_zero_struct(ts, &rtpe_totalstats_interval, total_timeout_sess);
+	atomic64_local_copy_zero_struct(ts, &rtpe_totalstats_interval, total_rejected_sess);
+	atomic64_local_copy_zero_struct(ts, &rtpe_totalstats_interval, total_silent_timeout_sess);
+	atomic64_local_copy_zero_struct(ts, &rtpe_totalstats_interval, total_final_timeout_sess);
+	atomic64_local_copy_zero_struct(ts, &rtpe_totalstats_interval, total_regular_term_sess);
+	atomic64_local_copy_zero_struct(ts, &rtpe_totalstats_interval, total_forced_term_sess);
+	atomic64_local_copy_zero_struct(ts, &rtpe_totalstats_interval, total_relayed_packets);
+	atomic64_local_copy_zero_struct(ts, &rtpe_totalstats_interval, total_relayed_errors);
+	atomic64_local_copy_zero_struct(ts, &rtpe_totalstats_interval, total_nopacket_relayed_sess);
+	atomic64_local_copy_zero_struct(ts, &rtpe_totalstats_interval, total_oneway_stream_sess);
+
+	mutex_lock(&rtpe_totalstats_interval.total_average_lock);
+	ts->total_average_call_dur = rtpe_totalstats_interval.total_average_call_dur;
+	ts->total_managed_sess = rtpe_totalstats_interval.total_managed_sess;
+	ZERO(rtpe_totalstats_interval.total_average_call_dur);
+	ZERO(rtpe_totalstats_interval.total_managed_sess);
+	mutex_unlock(&rtpe_totalstats_interval.total_average_lock);
+
+	mutex_lock(&rtpe_totalstats_interval.total_calls_duration_lock);
+	ts->total_calls_duration_interval = rtpe_totalstats_interval.total_calls_duration_interval;
+	rtpe_totalstats_interval.total_calls_duration_interval.tv_sec = 0;
+	rtpe_totalstats_interval.total_calls_duration_interval.tv_usec = 0;
+	//ZERO(rtpe_totalstats_interval.total_calls_duration_interval);
+	mutex_unlock(&rtpe_totalstats_interval.total_calls_duration_lock);
+
+	ts->offer = timeval_clear_request_time(&rtpe_totalstats_interval.offer);
+	ts->answer = timeval_clear_request_time(&rtpe_totalstats_interval.answer);
+	ts->delete = timeval_clear_request_time(&rtpe_totalstats_interval.delete);
 
 	rwlock_lock_r(&rtpe_callhash_lock);
-	mutex_lock(&cm->totalstats_interval.managed_sess_lock);
-	ts->managed_sess_max = cm->totalstats_interval.managed_sess_max;
-	ts->managed_sess_min = cm->totalstats_interval.managed_sess_min;
+	mutex_lock(&rtpe_totalstats_interval.managed_sess_lock);
+	ts->managed_sess_max = rtpe_totalstats_interval.managed_sess_max;
+	ts->managed_sess_min = rtpe_totalstats_interval.managed_sess_min;
         ts->total_sessions = g_hash_table_size(rtpe_callhash);
         ts->foreign_sessions = atomic64_get(&rtpe_stats.foreign_sessions);
 	ts->own_sessions = ts->total_sessions - ts->foreign_sessions;
-	cm->totalstats_interval.managed_sess_max = ts->own_sessions;;
-	cm->totalstats_interval.managed_sess_min = ts->own_sessions;
-	mutex_unlock(&cm->totalstats_interval.managed_sess_lock);
+	rtpe_totalstats_interval.managed_sess_max = ts->own_sessions;;
+	rtpe_totalstats_interval.managed_sess_min = ts->own_sessions;
+	mutex_unlock(&rtpe_totalstats_interval.managed_sess_lock);
 	rwlock_unlock_r(&rtpe_callhash_lock);
 
 	// compute average offer/answer/delete time
@@ -317,7 +318,7 @@ void graphite_loop_run(struct callmaster *cm, endpoint_t *graphite_ep, int secon
 			connection_state = STATE_DISCONNECTED;
 		}
 
-		copy_with_lock(&cm->totalstats_lastinterval, &graphite_stats, &cm->totalstats_lastinterval.total_average_lock);
+		copy_with_lock(&rtpe_totalstats_lastinterval, &graphite_stats, &rtpe_totalstats_lastinterval.total_average_lock);
 	}
 
 }

daemon/main.c

@@ -36,6 +36,7 @@
 #include "auxlib.h"
 #include "rtcp.h"
 #include "iptables.h"
+#include "statistics.h"
 
 
 
@@ -498,6 +499,7 @@ static void init_everything() {
 	control_ng_init();
 	if (call_interfaces_init())
 		abort();
+	statistics_init();
 }
 
 

daemon/statistics.c

@@ -1,6 +1,12 @@
 #include "call.h"
 #include "statistics.h"
 
+struct totalstats       rtpe_totalstats;
+struct totalstats       rtpe_totalstats_interval;
+mutex_t		       	rtpe_totalstats_lastinterval_lock;
+struct totalstats       rtpe_totalstats_lastinterval;
+
+
 static void timeval_totalstats_average_add(struct totalstats *s, const struct timeval *add) {
 	struct timeval dp, oa;
 
@@ -59,47 +65,43 @@ static void timeval_totalstats_interval_call_duration_add(struct totalstats *s,
 }
 
 
-void statistics_update_totals(struct callmaster* m, struct packet_stream *ps) {
-	atomic64_add(&m->totalstats.total_relayed_packets,
+void statistics_update_totals(struct packet_stream *ps) {
+	atomic64_add(&rtpe_totalstats.total_relayed_packets,
 			atomic64_get(&ps->stats.packets));
-	atomic64_add(&m->totalstats_interval.total_relayed_packets,
+	atomic64_add(&rtpe_totalstats_interval.total_relayed_packets,
 		atomic64_get(&ps->stats.packets));
-	atomic64_add(&m->totalstats.total_relayed_errors,
+	atomic64_add(&rtpe_totalstats.total_relayed_errors,
 		atomic64_get(&ps->stats.errors));
-	atomic64_add(&m->totalstats_interval.total_relayed_errors,
+	atomic64_add(&rtpe_totalstats_interval.total_relayed_errors,
 		atomic64_get(&ps->stats.errors));
 }
 
 void statistics_update_foreignown_dec(struct call* c) {
-	struct callmaster *m;
-
-	m = c->callmaster;
-
 	if (IS_FOREIGN_CALL(c)) {
 		atomic64_dec(&rtpe_stats.foreign_sessions);
 	}
 
 	if(IS_OWN_CALL(c)) 	{
-		mutex_lock(&m->totalstats_interval.managed_sess_lock);
-		m->totalstats_interval.managed_sess_min = MIN(m->totalstats_interval.managed_sess_min,
+		mutex_lock(&rtpe_totalstats_interval.managed_sess_lock);
+		rtpe_totalstats_interval.managed_sess_min = MIN(rtpe_totalstats_interval.managed_sess_min,
 				g_hash_table_size(rtpe_callhash) - atomic64_get(&rtpe_stats.foreign_sessions));
-		mutex_unlock(&m->totalstats_interval.managed_sess_lock);
+		mutex_unlock(&rtpe_totalstats_interval.managed_sess_lock);
 	}
 
 }
 
-void statistics_update_foreignown_inc(struct callmaster *m, struct call* c) {
+void statistics_update_foreignown_inc(struct call* c) {
 	if (IS_OWN_CALL(c)) {
-		mutex_lock(&m->totalstats_interval.managed_sess_lock);
-		m->totalstats_interval.managed_sess_max = MAX(
-				m->totalstats_interval.managed_sess_max,
+		mutex_lock(&rtpe_totalstats_interval.managed_sess_lock);
+		rtpe_totalstats_interval.managed_sess_max = MAX(
+				rtpe_totalstats_interval.managed_sess_max,
 				g_hash_table_size(rtpe_callhash)
 						- atomic64_get(&rtpe_stats.foreign_sessions));
-		mutex_unlock(&m->totalstats_interval.managed_sess_lock);
+		mutex_unlock(&rtpe_totalstats_interval.managed_sess_lock);
 	}
 	else if (IS_FOREIGN_CALL(c)) { /* foreign call*/
 		atomic64_inc(&rtpe_stats.foreign_sessions);
-		atomic64_inc(&m->totalstats.total_foreign_sessions);
+		atomic64_inc(&rtpe_totalstats.total_foreign_sessions);
 	}
 
 }
@@ -162,8 +164,8 @@ void statistics_update_oneway(struct call* c) {
 		if (ps && ps2 && atomic64_get(&ps2->stats.packets)==0) {
 			if (atomic64_get(&ps->stats.packets)!=0 && IS_OWN_CALL(c)){
 				if (atomic64_get(&ps->stats.packets)!=0) {
-					atomic64_inc(&m->totalstats.total_oneway_stream_sess);
-					atomic64_inc(&m->totalstats_interval.total_oneway_stream_sess);
+					atomic64_inc(&rtpe_totalstats.total_oneway_stream_sess);
+					atomic64_inc(&rtpe_totalstats_interval.total_oneway_stream_sess);
 				}
 			}
 			else {
@@ -173,8 +175,8 @@ void statistics_update_oneway(struct call* c) {
 	}
 
 	if (IS_OWN_CALL(c)) {
-		atomic64_add(&m->totalstats.total_nopacket_relayed_sess, total_nopacket_relayed_sess / 2);
-		atomic64_add(&m->totalstats_interval.total_nopacket_relayed_sess, total_nopacket_relayed_sess / 2);
+		atomic64_add(&rtpe_totalstats.total_nopacket_relayed_sess, total_nopacket_relayed_sess / 2);
+		atomic64_add(&rtpe_totalstats_interval.total_nopacket_relayed_sess, total_nopacket_relayed_sess / 2);
 	}
 
 	if (c->monologues.head) {
@@ -184,31 +186,44 @@ void statistics_update_oneway(struct call* c) {
 
 		if (IS_OWN_CALL(c)) {
 			if (ml->term_reason==TIMEOUT) {
-				atomic64_inc(&m->totalstats.total_timeout_sess);
-				atomic64_inc(&m->totalstats_interval.total_timeout_sess);
+				atomic64_inc(&rtpe_totalstats.total_timeout_sess);
+				atomic64_inc(&rtpe_totalstats_interval.total_timeout_sess);
 			} else if (ml->term_reason==SILENT_TIMEOUT) {
-				atomic64_inc(&m->totalstats.total_silent_timeout_sess);
-				atomic64_inc(&m->totalstats_interval.total_silent_timeout_sess);
+				atomic64_inc(&rtpe_totalstats.total_silent_timeout_sess);
+				atomic64_inc(&rtpe_totalstats_interval.total_silent_timeout_sess);
 			} else if (ml->term_reason==REGULAR) {
-				atomic64_inc(&m->totalstats.total_regular_term_sess);
-				atomic64_inc(&m->totalstats_interval.total_regular_term_sess);
+				atomic64_inc(&rtpe_totalstats.total_regular_term_sess);
+				atomic64_inc(&rtpe_totalstats_interval.total_regular_term_sess);
 			} else if (ml->term_reason==FORCED) {
-				atomic64_inc(&m->totalstats.total_forced_term_sess);
-				atomic64_inc(&m->totalstats_interval.total_forced_term_sess);
+				atomic64_inc(&rtpe_totalstats.total_forced_term_sess);
+				atomic64_inc(&rtpe_totalstats_interval.total_forced_term_sess);
 			}
 
-			timeval_totalstats_average_add(&m->totalstats, &tim_result_duration);
-			timeval_totalstats_average_add(&m->totalstats_interval, &tim_result_duration);
+			timeval_totalstats_average_add(&rtpe_totalstats, &tim_result_duration);
+			timeval_totalstats_average_add(&rtpe_totalstats_interval, &tim_result_duration);
 			timeval_totalstats_interval_call_duration_add(
-					&m->totalstats_interval, &ml->started, &ml->terminated,
+					&rtpe_totalstats_interval, &ml->started, &ml->terminated,
 					&m->latest_graphite_interval_start,
 					m->conf.graphite_interval);
 		}
 
 		if (ml->term_reason==FINAL_TIMEOUT) {
-			atomic64_inc(&m->totalstats.total_final_timeout_sess);
-			atomic64_inc(&m->totalstats_interval.total_final_timeout_sess);
+			atomic64_inc(&rtpe_totalstats.total_final_timeout_sess);
+			atomic64_inc(&rtpe_totalstats_interval.total_final_timeout_sess);
 		}
 	}
 
 }
+
+void statistics_init() {
+	mutex_init(&rtpe_totalstats.total_average_lock);
+	mutex_init(&rtpe_totalstats_interval.total_average_lock);
+	mutex_init(&rtpe_totalstats_interval.managed_sess_lock);
+	mutex_init(&rtpe_totalstats_interval.total_calls_duration_lock);
+
+	rtpe_totalstats.started = rtpe_now.tv_sec;
+	//rtpe_totalstats_interval.managed_sess_min = 0; // already zeroed
+	//rtpe_totalstats_interval.managed_sess_max = 0;
+
+	mutex_init(&rtpe_totalstats_lastinterval_lock);
+}

daemon/statistics.h

@@ -69,12 +69,16 @@ struct call_stats {
 	struct stats	totals[4]; /* rtp in, rtcp in, rtp out, rtcp out */
 };
 
-
-struct callmaster;
+extern struct totalstats       rtpe_totalstats;
+extern struct totalstats       rtpe_totalstats_interval;
+extern mutex_t		       rtpe_totalstats_lastinterval_lock;
+extern struct totalstats       rtpe_totalstats_lastinterval;
 
 void statistics_update_oneway(struct call *);
 void statistics_update_foreignown_dec(struct call *);
-void statistics_update_foreignown_inc(struct callmaster *m, struct call* c);
-void statistics_update_totals(struct callmaster *, struct packet_stream *) ;
+void statistics_update_foreignown_inc(struct call* c);
+void statistics_update_totals(struct packet_stream *) ;
+
+void statistics_init(void);
 
 #endif /* STATISTICS_H_ */