Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 6a82b2aa authored by JP Abgrall's avatar JP Abgrall Committed by Alistair Strachan
Browse files

ANDROID: netfilter: xt_IDLETIMER: Add new netlink msg type 



Send notifications when the label becomes active after an idle period.
Send netlink message notifications in addition to sysfs notifications.
Using a uevent with
  subsystem=xt_idletimer
  INTERFACE=...
  STATE={active,inactive}

This is backport from common android-3.0
commit: beb914e987cbbd368988d2b94a6661cb907c4d5a
with uevent support instead of a new netlink message type.

Bug: 120445672
Change-Id: I31677ef00c94b5f82c8457e5bf9e5e584c23c523
Signed-off-by: default avatarAshish Sharma <ashishsharma@google.com>
Signed-off-by: default avatarJP Abgrall <jpa@google.com>
[astrachan: Folded the following changes into this patch:
            ee0b238fada5 ("netfilter: xt_IDLETIMER: time-stamp and suspend/resume handling.")
            728c058a495e ("netfilter: xt_IDLETIMER: Adds the uid field in the msg")
            5ebea489d44c ("netfilter: xt_IDLETIMER: Fix use after free condition during work")
            5ab69d7ba2c5 ("netfilter: xt_IDLETIMER: Use fullsock when querying uid")]
Signed-off-by: default avatarAlistair Strachan <astrachan@google.com>
parent bb7ff5ca

include/uapi/linux/netfilter/xt_IDLETIMER.h

+8 −0
Original line number Diff line number Diff line
@@ -5,6 +5,7 @@ 
 * Header file for Xtables timer target module.

 *

 * Copyright (C) 2004, 2010 Nokia Corporation

 *

 * Written by Timo Teras <ext-timo.teras@nokia.com>

 *

 * Converted to x_tables and forward-ported to 2.6.34
@@ -33,12 +34,19 @@ 
#include <linux/types.h>



#define MAX_IDLETIMER_LABEL_SIZE 28

#define NLMSG_MAX_SIZE 64



#define NL_EVENT_TYPE_INACTIVE 0

#define NL_EVENT_TYPE_ACTIVE 1



struct idletimer_tg_info {

	__u32 timeout;



	char label[MAX_IDLETIMER_LABEL_SIZE];



	/* Use netlink messages for notification in addition to sysfs */

	__u8 send_nl_msg;



	/* for kernel module internal use only */

	struct idletimer_tg *timer __attribute__((aligned(8)));

};

net/netfilter/xt_IDLETIMER.c

+234 −12
Original line number Diff line number Diff line
@@ -5,6 +5,7 @@ 
 * After timer expires a kevent will be sent.

 *

 * Copyright (C) 2004, 2010 Nokia Corporation

 *

 * Written by Timo Teras <ext-timo.teras@nokia.com>

 *

 * Converted to x_tables and reworked for upstream inclusion
@@ -38,8 +39,17 @@ 
#include <linux/netfilter/xt_IDLETIMER.h>

#include <linux/kdev_t.h>

#include <linux/kobject.h>

#include <linux/skbuff.h>

#include <linux/workqueue.h>

#include <linux/sysfs.h>

#include <linux/rtc.h>

#include <linux/time.h>

#include <linux/math64.h>

#include <linux/suspend.h>

#include <linux/notifier.h>

#include <net/net_namespace.h>

#include <net/sock.h>

#include <net/inet_sock.h>



struct idletimer_tg_attr {

	struct attribute attr;
@@ -55,14 +65,110 @@ struct idletimer_tg { 
	struct kobject *kobj;

	struct idletimer_tg_attr attr;



	struct timespec delayed_timer_trigger;

	struct timespec last_modified_timer;

	struct timespec last_suspend_time;

	struct notifier_block pm_nb;



	int timeout;

	unsigned int refcnt;

	bool work_pending;

	bool send_nl_msg;

	bool active;

	uid_t uid;

};



static LIST_HEAD(idletimer_tg_list);

static DEFINE_MUTEX(list_mutex);

static DEFINE_SPINLOCK(timestamp_lock);



static struct kobject *idletimer_tg_kobj;



static bool check_for_delayed_trigger(struct idletimer_tg *timer,

		struct timespec *ts)

{

	bool state;

	struct timespec temp;

	spin_lock_bh(&timestamp_lock);

	timer->work_pending = false;

	if ((ts->tv_sec - timer->last_modified_timer.tv_sec) > timer->timeout ||

			timer->delayed_timer_trigger.tv_sec != 0) {

		state = false;

		temp.tv_sec = timer->timeout;

		temp.tv_nsec = 0;

		if (timer->delayed_timer_trigger.tv_sec != 0) {

			temp = timespec_add(timer->delayed_timer_trigger, temp);

			ts->tv_sec = temp.tv_sec;

			ts->tv_nsec = temp.tv_nsec;

			timer->delayed_timer_trigger.tv_sec = 0;

			timer->work_pending = true;

			schedule_work(&timer->work);

		} else {

			temp = timespec_add(timer->last_modified_timer, temp);

			ts->tv_sec = temp.tv_sec;

			ts->tv_nsec = temp.tv_nsec;

		}

	} else {

		state = timer->active;

	}

	spin_unlock_bh(&timestamp_lock);

	return state;

}



static void notify_netlink_uevent(const char *iface, struct idletimer_tg *timer)

{

	char iface_msg[NLMSG_MAX_SIZE];

	char state_msg[NLMSG_MAX_SIZE];

	char timestamp_msg[NLMSG_MAX_SIZE];

	char uid_msg[NLMSG_MAX_SIZE];

	char *envp[] = { iface_msg, state_msg, timestamp_msg, uid_msg, NULL };

	int res;

	struct timespec ts;

	uint64_t time_ns;

	bool state;



	res = snprintf(iface_msg, NLMSG_MAX_SIZE, "INTERFACE=%s",

		       iface);

	if (NLMSG_MAX_SIZE <= res) {

		pr_err("message too long (%d)", res);

		return;

	}



	get_monotonic_boottime(&ts);

	state = check_for_delayed_trigger(timer, &ts);

	res = snprintf(state_msg, NLMSG_MAX_SIZE, "STATE=%s",

			state ? "active" : "inactive");



	if (NLMSG_MAX_SIZE <= res) {

		pr_err("message too long (%d)", res);

		return;

	}



	if (state) {

		res = snprintf(uid_msg, NLMSG_MAX_SIZE, "UID=%u", timer->uid);

		if (NLMSG_MAX_SIZE <= res)

			pr_err("message too long (%d)", res);

	} else {

		res = snprintf(uid_msg, NLMSG_MAX_SIZE, "UID=");

		if (NLMSG_MAX_SIZE <= res)

			pr_err("message too long (%d)", res);

	}



	time_ns = timespec_to_ns(&ts);

	res = snprintf(timestamp_msg, NLMSG_MAX_SIZE, "TIME_NS=%llu", time_ns);

	if (NLMSG_MAX_SIZE <= res) {

		timestamp_msg[0] = '\0';

		pr_err("message too long (%d)", res);

	}



	pr_debug("putting nlmsg: <%s> <%s> <%s> <%s>\n", iface_msg, state_msg,

		 timestamp_msg, uid_msg);

	kobject_uevent_env(idletimer_tg_kobj, KOBJ_CHANGE, envp);

	return;





}



static

struct idletimer_tg *__idletimer_tg_find_by_label(const char *label)

{
@@ -83,6 +189,7 @@ static ssize_t idletimer_tg_show(struct kobject *kobj, struct attribute *attr, 
{

	struct idletimer_tg *timer;

	unsigned long expires = 0;

	unsigned long now = jiffies;



	mutex_lock(&list_mutex);
@@ -92,10 +199,14 @@ static ssize_t idletimer_tg_show(struct kobject *kobj, struct attribute *attr, 


	mutex_unlock(&list_mutex);



	if (time_after(expires, jiffies))

	if (time_after(expires, now))

		return sprintf(buf, "%u\n",

			       jiffies_to_msecs(expires - jiffies) / 1000);

			       jiffies_to_msecs(expires - now) / 1000);



	if (timer->send_nl_msg)

		return sprintf(buf, "0 %d\n",

			jiffies_to_msecs(now - expires) / 1000);

	else

		return sprintf(buf, "0\n");

}
@@ -105,6 +216,9 @@ static void idletimer_tg_work(struct work_struct *work) 
						  work);



	sysfs_notify(idletimer_tg_kobj, NULL, timer->attr.attr.name);



	if (timer->send_nl_msg)

		notify_netlink_uevent(timer->attr.attr.name, timer);

}



static void idletimer_tg_expired(struct timer_list *t)
@@ -112,9 +226,56 @@ static void idletimer_tg_expired(struct timer_list *t) 
	struct idletimer_tg *timer = from_timer(timer, t, timer);



	pr_debug("timer %s expired\n", timer->attr.attr.name);

	spin_lock_bh(&timestamp_lock);

	timer->active = false;

	timer->work_pending = true;

	schedule_work(&timer->work);

	spin_unlock_bh(&timestamp_lock);

}



static int idletimer_resume(struct notifier_block *notifier,

		unsigned long pm_event, void *unused)

{

	struct timespec ts;

	unsigned long time_diff, now = jiffies;

	struct idletimer_tg *timer = container_of(notifier,

			struct idletimer_tg, pm_nb);

	if (!timer)

		return NOTIFY_DONE;

	switch (pm_event) {

	case PM_SUSPEND_PREPARE:

		get_monotonic_boottime(&timer->last_suspend_time);

		break;

	case PM_POST_SUSPEND:

		spin_lock_bh(&timestamp_lock);

		if (!timer->active) {

			spin_unlock_bh(&timestamp_lock);

			break;

		}

		/* since jiffies are not updated when suspended now represents

		 * the time it would have suspended */

		if (time_after(timer->timer.expires, now)) {

			get_monotonic_boottime(&ts);

			ts = timespec_sub(ts, timer->last_suspend_time);

			time_diff = timespec_to_jiffies(&ts);

			if (timer->timer.expires > (time_diff + now)) {

				mod_timer_pending(&timer->timer,

						(timer->timer.expires - time_diff));

			} else {

				del_timer(&timer->timer);

				timer->timer.expires = 0;

				timer->active = false;

				timer->work_pending = true;

				schedule_work(&timer->work);

			}

		}

		spin_unlock_bh(&timestamp_lock);

		break;

	default:

		break;

	}

	return NOTIFY_DONE;

}



static int idletimer_check_sysfs_name(const char *name, unsigned int size)

{
@@ -165,6 +326,21 @@ static int idletimer_tg_create(struct idletimer_tg_info *info) 


	timer_setup(&info->timer->timer, idletimer_tg_expired, 0);

	info->timer->refcnt = 1;

	info->timer->send_nl_msg = (info->send_nl_msg == 0) ? false : true;

	info->timer->active = true;

	info->timer->timeout = info->timeout;



	info->timer->delayed_timer_trigger.tv_sec = 0;

	info->timer->delayed_timer_trigger.tv_nsec = 0;

	info->timer->work_pending = false;

	info->timer->uid = 0;

	get_monotonic_boottime(&info->timer->last_modified_timer);



	info->timer->pm_nb.notifier_call = idletimer_resume;

	ret = register_pm_notifier(&info->timer->pm_nb);

	if (ret)

		printk(KERN_WARNING "[%s] Failed to register pm notifier %d\n",

				__func__, ret);



	INIT_WORK(&info->timer->work, idletimer_tg_work);
@@ -181,6 +357,42 @@ static int idletimer_tg_create(struct idletimer_tg_info *info) 
	return ret;

}



static void reset_timer(const struct idletimer_tg_info *info,

			struct sk_buff *skb)

{

	unsigned long now = jiffies;

	struct idletimer_tg *timer = info->timer;

	bool timer_prev;



	spin_lock_bh(&timestamp_lock);

	timer_prev = timer->active;

	timer->active = true;

	/* timer_prev is used to guard overflow problem in time_before*/

	if (!timer_prev || time_before(timer->timer.expires, now)) {

		pr_debug("Starting Checkentry timer (Expired, Jiffies): %lu, %lu\n",

				timer->timer.expires, now);



		/* Stores the uid resposible for waking up the radio */

		if (skb && (skb->sk)) {

			timer->uid = from_kuid_munged(current_user_ns(),

					sock_i_uid(skb_to_full_sk(skb)));

		}



		/* checks if there is a pending inactive notification*/

		if (timer->work_pending)

			timer->delayed_timer_trigger = timer->last_modified_timer;

		else {

			timer->work_pending = true;

			schedule_work(&timer->work);

		}

	}



	get_monotonic_boottime(&timer->last_modified_timer);

	mod_timer(&timer->timer,

			msecs_to_jiffies(info->timeout * 1000) + now);

	spin_unlock_bh(&timestamp_lock);

}



/*

 * The actual xt_tables plugin.

 */
@@ -188,15 +400,23 @@ static unsigned int idletimer_tg_target(struct sk_buff *skb, 
					 const struct xt_action_param *par)

{

	const struct idletimer_tg_info *info = par->targinfo;

	unsigned long now = jiffies;



	pr_debug("resetting timer %s, timeout period %u\n",

		 info->label, info->timeout);



	BUG_ON(!info->timer);



	mod_timer(&info->timer->timer,

		  msecs_to_jiffies(info->timeout * 1000) + jiffies);

	info->timer->active = true;



	if (time_before(info->timer->timer.expires, now)) {

		schedule_work(&info->timer->work);

		pr_debug("Starting timer %s (Expired, Jiffies): %lu, %lu\n",

			 info->label, info->timer->timer.expires, now);

	}



	/* TODO: Avoid modifying timers on each packet */

	reset_timer(info, skb);

	return XT_CONTINUE;

}
@@ -227,9 +447,7 @@ static int idletimer_tg_checkentry(const struct xt_tgchk_param *par) 
	info->timer = __idletimer_tg_find_by_label(info->label);

	if (info->timer) {

		info->timer->refcnt++;

		mod_timer(&info->timer->timer,

			  msecs_to_jiffies(info->timeout * 1000) + jiffies);



		reset_timer(info, NULL);

		pr_debug("increased refcnt of timer %s to %u\n",

			 info->label, info->timer->refcnt);

	} else {
@@ -242,6 +460,7 @@ static int idletimer_tg_checkentry(const struct xt_tgchk_param *par) 
	}



	mutex_unlock(&list_mutex);



	return 0;

}
@@ -258,8 +477,9 @@ static void idletimer_tg_destroy(const struct xt_tgdtor_param *par) 


		list_del(&info->timer->entry);

		del_timer_sync(&info->timer->timer);

		cancel_work_sync(&info->timer->work);

		sysfs_remove_file(idletimer_tg_kobj, &info->timer->attr.attr);

		unregister_pm_notifier(&info->timer->pm_nb);

		cancel_work_sync(&info->timer->work);

		kfree(info->timer->attr.attr.name);

		kfree(info->timer);

	} else {
@@ -272,6 +492,7 @@ static void idletimer_tg_destroy(const struct xt_tgdtor_param *par) 


static struct xt_target idletimer_tg __read_mostly = {

	.name		= "IDLETIMER",

	.revision	= 1,

	.family		= NFPROTO_UNSPEC,

	.target		= idletimer_tg_target,

	.targetsize     = sizeof(struct idletimer_tg_info),
@@ -338,3 +559,4 @@ MODULE_DESCRIPTION("Xtables: idle time monitor"); 
MODULE_LICENSE("GPL v2");

MODULE_ALIAS("ipt_IDLETIMER");

MODULE_ALIAS("ip6t_IDLETIMER");

MODULE_ALIAS("arpt_IDLETIMER");