MT#55283 obsolete /blist

The requirement to continuously update stats from the kernel has been
eliminates. Remove all relevant code.

Change-Id: Idc8093b64290b89ff3d015f3e61e4bbe25df6e23

daemon/call.c

@@ -216,6 +216,30 @@ static void call_timer_iterator(call_t *c, struct iterator_helper *hlp) {
 				hlp->user_streams++; // user activity
 		}
 
+		bool active_media = (rtpe_now.tv_sec - packet_stream_last_packet(ps) < 1);
+		if (active_media)
+			CALL_CLEAR(sfd->call, FOREIGN_MEDIA);
+
+		for (unsigned int u = 0; u < G_N_ELEMENTS(ps->ssrc_in); u++) {
+			struct ssrc_ctx *ctx = ps->ssrc_in[u];
+			if (!ctx)
+				break;
+
+			if (rtpe_now.tv_sec - atomic64_get_na(&ctx->stats->last_packet) < 2)
+				payload_tracker_add(&ctx->tracker,
+						atomic_get_na(&ctx->stats->last_pt));
+		}
+		for (unsigned int u = 0; u < G_N_ELEMENTS(ps->ssrc_out); u++) {
+			struct ssrc_ctx *ctx = ps->ssrc_out[u];
+			if (!ctx)
+				break;
+
+			if (rtpe_now.tv_sec - atomic64_get_na(&ctx->stats->last_packet) < 2)
+				payload_tracker_add(&ctx->tracker,
+						atomic_get_na(&ctx->stats->last_pt));
+		}
+
+
 no_sfd:
 		if (good)
 			goto next;
@@ -243,10 +267,8 @@ next:
 		if (media->protocol && media->protocol->srtp)
 			has_srtp = true;
 
-		if (rtpe_config.measure_rtp) {
+		if (rtpe_config.measure_rtp)
-			media_update_stats(media);
 			ssrc_collect_metrics(media);
-		}
 		if (MEDIA_ISSET(media, TRANSCODING))
 			hlp->transcoded_media++;
 	}

daemon/kernel.c

@@ -205,36 +205,6 @@ bool kernel_del_stream_stats(struct rtpengine_command_del_target_stats *cmd) {
 	return false;
 }
 
-kernel_slist *kernel_get_list(void) {
-	char s[64];
-	int fd;
-	struct rtpengine_list_entry *buf;
-	kernel_slist *li = NULL;
-	ssize_t ret;
-
-	if (!kernel.is_open)
-		return NULL;
-
-	sprintf(s, PREFIX "/%u/blist", kernel.table);
-	fd = open(s, O_RDONLY);
-	if (fd == -1)
-		return NULL;
-
-
-	for (;;) {
-		buf = g_slice_alloc(sizeof(*buf));
-		ret = read(fd, buf, sizeof(*buf));
-		if (ret != sizeof(*buf))
-			break;
-		li = t_slist_prepend(li, buf);
-	}
-
-	g_slice_free1(sizeof(*buf), buf);
-	close(fd);
-
-	return li;
-}
-
 unsigned int kernel_add_call(const char *id) {
 	struct rtpengine_command_add_call cmd;
 	ssize_t ret;

daemon/main.c

@@ -1486,10 +1486,6 @@ int main(int argc, char **argv) {
 	thread_create_looper(call_rate_stats_updater, rtpe_config.idle_scheduling,
 			rtpe_config.idle_priority, "call stats", 1000000);
 
-	/* separate thread for ports iterations (stats update from the kernel) functionality */
-	thread_create_looper(kernel_stats_updater, rtpe_config.idle_scheduling,
-			rtpe_config.idle_priority, "kernel stats", 1000000);
-
 	/* separate thread for ice slow timer functionality */
 	thread_create_looper(ice_slow_timer, rtpe_config.idle_scheduling,
 			rtpe_config.idle_priority, "ICE slow", 1000000);

daemon/media_socket.c

@@ -1752,54 +1752,6 @@ struct ssrc_ctx *__hunt_ssrc_ctx(uint32_t ssrc, struct ssrc_ctx *list[RTPE_NUM_S
 }
 
 
-static void __stream_consume_stats(struct packet_stream *ps, const struct rtpengine_stats_info *stats_info) {
-	for (unsigned int u = 0; u < G_N_ELEMENTS(stats_info->ssrc); u++) {
-		// check for the right SSRC association
-		if (!stats_info->ssrc[u]) // end of list
-			break;
-		uint32_t ssrc = ntohl(stats_info->ssrc[u]);
-		struct ssrc_ctx *ssrc_ctx = __hunt_ssrc_ctx(ssrc, ps->ssrc_in, u);
-		if (!ssrc_ctx)
-			continue;
-
-		uint32_t ssrc_map_out = ssrc_ctx->ssrc_map_out;
-
-		for (__auto_type l = ps->rtcp_sinks.head; l; l = l->next) {
-			struct sink_handler *sh = l->data;
-			struct packet_stream *sink = sh->sink;
-
-			if (mutex_trylock(&sink->out_lock))
-				continue; // will have to skip this
-
-			ssrc_ctx = __hunt_ssrc_ctx(ssrc, sink->ssrc_out, u);
-			if (!ssrc_ctx)
-				ssrc_ctx = __hunt_ssrc_ctx(ssrc_map_out, sink->ssrc_out, u);
-
-			// XXX
-
-			mutex_unlock(&sink->out_lock);
-		}
-	}
-}
-
-
-// must be called with appropriate locks (master lock and/or in_lock)
-static void __stream_update_stats(struct packet_stream *ps) {
-	mutex_lock(&ps->in_lock);
-
-	struct rtpengine_command_stats stats_info;
-	__re_address_translate_ep(&stats_info.local, &ps->selected_sfd->socket.local);
-	if (!kernel_update_stats(&stats_info)) {
-		mutex_unlock(&ps->in_lock);
-		return;
-	}
-
-	__stream_consume_stats(ps, &stats_info.stats);
-
-	mutex_unlock(&ps->in_lock);
-}
-
-
 /* must be called with in_lock held or call->master_lock held in W */
 void __unkernelize(struct packet_stream *p, const char *reason) {
 	if (!p->selected_sfd)
@@ -1814,8 +1766,7 @@ void __unkernelize(struct packet_stream *p, const char *reason) {
 				reason);
 		struct rtpengine_command_del_target_stats cmd;
 		__re_address_translate_ep(&cmd.local, &p->selected_sfd->socket.local);
-		if (kernel_del_stream_stats(&cmd))
+		kernel_del_stream_stats(&cmd);
-			__stream_consume_stats(p, &cmd.stats);
 	}
 
 	PS_CLEAR(p, KERNELIZED);
@@ -1865,29 +1816,6 @@ void unkernelize(struct packet_stream *ps, const char *reason) {
 	mutex_unlock(&ps->in_lock);
 }
 
-// master lock held in R
-void media_update_stats(struct call_media *m) {
-	if (!proto_is_rtp(m->protocol))
-		return;
-	if (!kernel.is_open)
-		return;
-
-	for (__auto_type l = m->streams.head; l; l = l->next) {
-		struct packet_stream *ps = l->data;
-		if (!PS_ISSET(ps, RTP))
-			continue;
-		if (!PS_ISSET(ps, KERNELIZED))
-			continue;
-		if (PS_ISSET(ps, NO_KERNEL_SUPPORT))
-			continue;
-		if (!ps->selected_sfd)
-			continue;
-
-		__stream_update_stats(ps);
-	}
-}
-
-
 
 // `out_media` can be NULL
 const struct streamhandler *determine_handler(const struct transport_protocol *in_proto,
@@ -3356,96 +3284,3 @@ struct interface_stats_block *interface_sampled_rate_stats_get(struct interface_
 	ret->last_run = rtpe_now;
 	return &ret->stats;
 }
-
-
-/**
- * Ports iterations (stats update from the kernel) functionality.
- */
-enum thread_looper_action kernel_stats_updater(void) {
-	struct rtpengine_list_entry *ke;
-	struct packet_stream *ps;
-	endpoint_t ep;
-
-	/* TODO: should we realy check the count of call timers? `call_timer_iterator()` */
-	__auto_type kl = kernel_get_list();
-	while (kl) {
-		ke = kl->data;
-		kernel2endpoint(&ep, &ke->target.local);
-		g_autoptr(stream_fd) sfd = stream_fd_lookup(&ep);
-
-		if (!sfd)
-			goto next;
-
-		log_info_stream_fd(sfd);
-
-		rwlock_lock_r(&sfd->call->master_lock);
-		ps = sfd->stream;
-		if (!ps || ps->selected_sfd != sfd) {
-			rwlock_unlock_r(&sfd->call->master_lock);
-			goto next;
-		}
-
-		bool active_media = (rtpe_now.tv_sec - packet_stream_last_packet(ps) < 1);
-		if (active_media)
-			CALL_CLEAR(sfd->call, FOREIGN_MEDIA);
-
-		if (!ke->target.non_forwarding && active_media) {
-			for (__auto_type l = ps->rtp_sinks.head; l; l = l->next) {
-				struct sink_handler *sh = l->data;
-				struct packet_stream *sink = sh->sink;
-
-				if (sh->kernel_output_idx < 0
-						|| sh->kernel_output_idx >= ke->target.num_destinations)
-					continue;
-
-				struct rtpengine_output_info *o = &ke->outputs[sh->kernel_output_idx];
-
-				mutex_lock(&sink->out_lock);
-				for (unsigned int u = 0; u < G_N_ELEMENTS(ke->target.ssrc); u++) {
-					if (!ke->target.ssrc[u]) // end of list
-						break;
-					struct ssrc_ctx *in_ctx = __hunt_ssrc_ctx(ntohl(ke->target.ssrc[u]),
-							ps->ssrc_in, 0);
-					if (!in_ctx)
-						continue;
-					uint32_t out_ssrc = o->ssrc_out[u];
-					if (!out_ssrc)
-						out_ssrc = ke->target.ssrc[u];
-					struct ssrc_ctx *ctx = __hunt_ssrc_ctx(ntohl(out_ssrc),
-							sink->ssrc_out, 0);
-					if (!ctx)
-						continue;
-					if (rtpe_now.tv_sec - atomic64_get_na(&in_ctx->stats->last_packet) < 2)
-						payload_tracker_add(&ctx->tracker,
-								atomic_get_na(&in_ctx->stats->last_pt));
-				}
-				mutex_unlock(&sink->out_lock);
-			}
-
-			mutex_lock(&ps->in_lock);
-
-			for (unsigned int u = 0; u < G_N_ELEMENTS(ke->target.ssrc); u++) {
-				if (!ke->target.ssrc[u]) // end of list
-					break;
-				struct ssrc_ctx *ctx = __hunt_ssrc_ctx(ntohl(ke->target.ssrc[u]),
-						ps->ssrc_in, 0);
-				if (!ctx)
-					continue;
-
-				if (rtpe_now.tv_sec - atomic64_get_na(&ctx->stats->last_packet) < 2)
-					payload_tracker_add(&ctx->tracker,
-							atomic_get_na(&ctx->stats->last_pt));
-			}
-			mutex_unlock(&ps->in_lock);
-		}
-
-		rwlock_unlock_r(&sfd->call->master_lock);
-
-next:
-		g_slice_free1(sizeof(*ke), ke);
-		kl = t_slist_delete_link(kl, kl);
-		log_info_pop();
-	}
-
-	return TLA_CONTINUE;
-}

daemon/mqtt.c

@@ -392,8 +392,6 @@ static void mqtt_stream_stats(struct packet_stream *ps, JsonBuilder *json) {
 
 
 static void mqtt_media_stats(struct call_media *media, JsonBuilder *json) {
-	media_update_stats(media);
-
 	json_builder_set_member_name(json, "media_index");
 	json_builder_add_int_value(json, media->index);
 

daemon/rtcp.c

@@ -1576,8 +1576,6 @@ void rtcp_send_report(struct call_media *media, struct ssrc_ctx *ssrc_out) {
 	if (ps->selected_sfd->socket.fd == -1 || ps->endpoint.address.family == NULL)
 		return;
 
-	media_update_stats(media);
-
 	log_info_stream_fd(ps->selected_sfd);
 
 	GQueue rrs = G_QUEUE_INIT;
@@ -1618,8 +1616,6 @@ void rtcp_send_report(struct call_media *media, struct ssrc_ctx *ssrc_out) {
 		struct packet_stream *sink = sh->sink;
 		struct call_media *other_media = sink->media;
 
-		media_update_stats(other_media);
-
 		ssrc_sender_report(other_media, &ssr, &rtpe_now);
 		for (GList *k = srrs.head; k; k = k->next) {
 			struct ssrc_receiver_report *srr = k->data;

include/kernel.h

@@ -26,8 +26,6 @@ struct kernel_interface {
 };
 extern struct kernel_interface kernel;
 
-TYPED_GQUEUE(kernel, struct rtpengine_list_entry)
-
 
 
 bool kernel_setup_table(unsigned int);
@@ -37,7 +35,6 @@ void kernel_shutdown_table(void);
 void kernel_add_stream(struct rtpengine_target_info *);
 void kernel_add_destination(struct rtpengine_destination_info *);
 bool kernel_del_stream_stats(struct rtpengine_command_del_target_stats *);
-kernel_slist *kernel_get_list(void);
 bool kernel_update_stats(struct rtpengine_command_stats *);
 
 unsigned int kernel_add_call(const char *id);

include/media_socket.h

@@ -296,7 +296,6 @@ void unkernelize(struct packet_stream *, const char *);
 void __stream_unconfirm(struct packet_stream *, const char *);
 void __reset_sink_handlers(struct packet_stream *);
 
-void media_update_stats(struct call_media *m);
 int __hunt_ssrc_ctx_idx(uint32_t ssrc, struct ssrc_ctx *list[RTPE_NUM_SSRC_TRACKING],
 		unsigned int start_idx);
 struct ssrc_ctx *__hunt_ssrc_ctx(uint32_t ssrc, struct ssrc_ctx *list[RTPE_NUM_SSRC_TRACKING],
@@ -312,8 +311,6 @@ const struct transport_protocol *transport_protocol(const str *s);
 //void play_buffered(struct packet_stream *sink, struct codec_packet *cp, int buffered);
 void play_buffered(struct jb_packet *cp);
 
-enum thread_looper_action kernel_stats_updater(void);
-
 INLINE int proto_is_rtp(const struct transport_protocol *protocol) {
 	// known to be RTP? therefore unknown is not RTP
 	if (!protocol)

kernel-module/xt_RTPENGINE.c

@@ -234,10 +234,6 @@ static void proc_list_stop(struct seq_file *, void *);
 static void *proc_list_next(struct seq_file *, void *, loff_t *);
 static int proc_list_show(struct seq_file *, void *);
 
-static int proc_blist_open(struct inode *, struct file *);
-static int proc_blist_close(struct inode *, struct file *);
-static ssize_t proc_blist_read(struct file *, char __user *, size_t, loff_t *);
-
 static int proc_main_list_open(struct inode *, struct file *);
 
 static void *proc_main_list_start(struct seq_file *, loff_t *);
@@ -416,7 +412,6 @@ struct rtpengine_table {
 	struct proc_dir_entry		*proc_status;
 	struct proc_dir_entry		*proc_control;
 	struct proc_dir_entry		*proc_list;
-	struct proc_dir_entry		*proc_blist;
 	struct proc_dir_entry		*proc_calls;
 
 	struct re_dest_addr_hash	dest_addr_hash;
@@ -570,13 +565,6 @@ static const struct PROC_OP_STRUCT proc_list_ops = {
 	.PROC_RELEASE		= proc_generic_seqrelease_modref,
 };
 
-static const struct PROC_OP_STRUCT proc_blist_ops = {
-	PROC_OWNER
-	.PROC_OPEN		= proc_blist_open,
-	.PROC_READ		= proc_blist_read,
-	.PROC_RELEASE		= proc_blist_close,
-};
-
 static const struct seq_operations proc_list_seq_ops = {
 	.start			= proc_list_start,
 	.next			= proc_list_next,
@@ -848,11 +836,6 @@ static int table_create_proc(struct rtpengine_table *t, uint32_t id) {
 	if (!t->proc_list)
 		return -1;
 
-	t->proc_blist = proc_create_user("blist", S_IFREG | 0444, t->proc_root,
-			&proc_blist_ops, (void *) (unsigned long) id);
-	if (!t->proc_blist)
-		return -1;
-
 	t->proc_calls = proc_mkdir_user("calls", 0555, t->proc_root);
 	if (!t->proc_calls)
 		return -1;
@@ -969,7 +952,6 @@ static void clear_table_proc_files(struct rtpengine_table *t) {
 	clear_proc(&t->proc_status);
 	clear_proc(&t->proc_control);
 	clear_proc(&t->proc_list);
-	clear_proc(&t->proc_blist);
 	clear_proc(&t->proc_calls);
 	clear_proc(&t->proc_root);
 }
@@ -1399,107 +1381,6 @@ next_rda:
 
 
 
-static int proc_blist_open(struct inode *i, struct file *f) {
-	uint32_t id;
-	struct rtpengine_table *t;
-	int err;
-
-	if ((err = proc_generic_open_modref(i, f)))
-		return err;
-
-	id = (uint32_t) (unsigned long) PDE_DATA(i);
-	t = get_table(id);
-	if (!t)
-		return -ENOENT;
-
-	table_put(t);
-
-	return 0;
-}
-
-static int proc_blist_close(struct inode *i, struct file *f) {
-	uint32_t id;
-	struct rtpengine_table *t;
-
-	id = (uint32_t) (unsigned long) PDE_DATA(i);
-	t = get_table(id);
-	if (!t)
-		return 0;
-
-	table_put(t);
-
-	proc_generic_close_modref(i, f);
-
-	return 0;
-}
-
-static ssize_t proc_blist_read(struct file *f, char __user *b, size_t l, loff_t *o) {
-	struct inode *inode;
-	uint32_t id;
-	struct rtpengine_table *t;
-	struct rtpengine_list_entry *opp;
-	int err, port, addr_bucket;
-	unsigned int i;
-	struct rtpengine_target *g;
-	unsigned long flags;
-
-	if (l != sizeof(*opp))
-		return -EINVAL;
-	if (*o < 0)
-		return -EINVAL;
-
-	inode = f->f_path.dentry->d_inode;
-	id = (uint32_t) (unsigned long) PDE_DATA(inode);
-	t = get_table(id);
-	if (!t)
-		return -ENOENT;
-
-	addr_bucket = ((int) *o) >> 17;
-	port = ((int) *o) & 0x1ffff;
-	g = find_next_target(t, &addr_bucket, &port);
-	port++;
-	*o = (addr_bucket << 17) | port;
-	err = 0;
-	if (!g)
-		goto err;
-
-	err = -ENOMEM;
-	opp = kzalloc(sizeof(*opp), GFP_KERNEL);
-	if (!opp)
-		goto err;
-
-	memcpy(&opp->target, &g->target, sizeof(opp->target));
-
-	_r_lock(&g->outputs_lock, flags);
-	if (!g->outputs_unfilled) {
-		_r_unlock(&g->outputs_lock, flags);
-		for (i = 0; i < g->target.num_destinations; i++) {
-			struct rtpengine_output *o = &g->outputs[i];
-			spin_lock_irqsave(&o->encrypt_rtp.lock, flags);
-			opp->outputs[i] = o->output;
-			spin_unlock_irqrestore(&o->encrypt_rtp.lock, flags);
-		}
-	}
-	else
-		_r_unlock(&g->outputs_lock, flags);
-
-	target_put(g);
-
-	err = -EFAULT;
-	if (copy_to_user(b, opp, sizeof(*opp)))
-		goto err2;
-
-	table_put(t);
-	kfree(opp);
-	return l;
-
-err2:
-	kfree(opp);
-err:
-	table_put(t);
-	return err;
-}
-
 static int proc_list_open(struct inode *i, struct file *f) {
 	int err;
 	struct seq_file *p;

kernel-module/xt_RTPENGINE.h

@@ -251,10 +251,5 @@ struct rtpengine_command_send_packet {
 	struct rtpengine_send_packet_info send_packet;
 };
 
-struct rtpengine_list_entry {
-	struct rtpengine_target_info	target;
-	struct rtpengine_output_info	outputs[RTPE_MAX_FORWARD_DESTINATIONS];
-};
-
 
 #endif