[GitHub/mt8127/android_kernel_alcatel_ttab.git] / net / core / drop_monitor.c

/*
 * Monitoring code for network dropped packet alerts
 *
 * Copyright (C) 2009 Neil Horman <nhorman@tuxdriver.com>
 */

#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/string.h>
#include <linux/if_arp.h>
#include <linux/inetdevice.h>
#include <linux/inet.h>
#include <linux/interrupt.h>
#include <linux/netpoll.h>
#include <linux/sched.h>
#include <linux/delay.h>
#include <linux/types.h>
#include <linux/workqueue.h>
#include <linux/netlink.h>
#include <linux/net_dropmon.h>
#include <linux/percpu.h>
#include <linux/timer.h>
#include <linux/bitops.h>
#include <linux/slab.h>
#include <net/genetlink.h>
#include <net/netevent.h>

#include <trace/events/skb.h>
#include <trace/events/napi.h>

#include <asm/unaligned.h>

#define TRACE_ON 1
#define TRACE_OFF 0

static void send_dm_alert(struct work_struct *unused);


/*
 * Globals, our netlink socket pointer
 * and the work handle that will send up
 * netlink alerts
 */
static int trace_state = TRACE_OFF;
static DEFINE_MUTEX(trace_state_mutex);

struct per_cpu_dm_data {
	struct work_struct dm_alert_work;
	struct sk_buff __rcu *skb;
	atomic_t dm_hit_count;
	struct timer_list send_timer;
	int cpu;
};

struct dm_hw_stat_delta {
	struct net_device *dev;
	unsigned long last_rx;
	struct list_head list;
	struct rcu_head rcu;
	unsigned long last_drop_val;
};

static struct genl_family net_drop_monitor_family = {
	.id             = GENL_ID_GENERATE,
	.hdrsize        = 0,
	.name           = "NET_DM",
	.version        = 2,
	.maxattr        = NET_DM_CMD_MAX,
};

static DEFINE_PER_CPU(struct per_cpu_dm_data, dm_cpu_data);

static int dm_hit_limit = 64;
static int dm_delay = 1;
static unsigned long dm_hw_check_delta = 2*HZ;
static LIST_HEAD(hw_stats_list);

static void reset_per_cpu_data(struct per_cpu_dm_data *data)
{
	size_t al;
	struct net_dm_alert_msg *msg;
	struct nlattr *nla;
	struct sk_buff *skb;
	struct sk_buff *oskb = rcu_dereference_protected(data->skb, 1);

	al = sizeof(struct net_dm_alert_msg);
	al += dm_hit_limit * sizeof(struct net_dm_drop_point);
	al += sizeof(struct nlattr);

	skb = genlmsg_new(al, GFP_KERNEL);

	if (skb) {
		genlmsg_put(skb, 0, 0, &net_drop_monitor_family,
				0, NET_DM_CMD_ALERT);
		nla = nla_reserve(skb, NLA_UNSPEC,
				  sizeof(struct net_dm_alert_msg));
		msg = nla_data(nla);
		memset(msg, 0, al);
	} else
		schedule_work_on(data->cpu, &data->dm_alert_work);

	/*
	 * Don't need to lock this, since we are guaranteed to only
	 * run this on a single cpu at a time.
	 * Note also that we only update data->skb if the old and new skb
	 * pointers don't match.  This ensures that we don't continually call
	 * synchornize_rcu if we repeatedly fail to alloc a new netlink message.
	 */
	if (skb != oskb) {
		rcu_assign_pointer(data->skb, skb);

		synchronize_rcu();

		atomic_set(&data->dm_hit_count, dm_hit_limit);
	}

}

static void send_dm_alert(struct work_struct *unused)
{
	struct sk_buff *skb;
	struct per_cpu_dm_data *data = &get_cpu_var(dm_cpu_data);

	WARN_ON_ONCE(data->cpu != smp_processor_id());

	/*
	 * Grab the skb we're about to send
	 */
	skb = rcu_dereference_protected(data->skb, 1);

	/*
	 * Replace it with a new one
	 */
	reset_per_cpu_data(data);

	/*
	 * Ship it!
	 */
	if (skb)
		genlmsg_multicast(skb, 0, NET_DM_GRP_ALERT, GFP_KERNEL);

	put_cpu_var(dm_cpu_data);
}

/*
 * This is the timer function to delay the sending of an alert
 * in the event that more drops will arrive during the
 * hysteresis period.  Note that it operates under the timer interrupt
 * so we don't need to disable preemption here
 */
static void sched_send_work(unsigned long unused)
{
	struct per_cpu_dm_data *data =  &get_cpu_var(dm_cpu_data);

	schedule_work_on(smp_processor_id(), &data->dm_alert_work);

	put_cpu_var(dm_cpu_data);
}

static void trace_drop_common(struct sk_buff *skb, void *location)
{
	struct net_dm_alert_msg *msg;
	struct nlmsghdr *nlh;
	struct nlattr *nla;
	int i;
	struct sk_buff *dskb;
	struct per_cpu_dm_data *data = &get_cpu_var(dm_cpu_data);


	rcu_read_lock();
	dskb = rcu_dereference(data->skb);

	if (!dskb)
		goto out;

	if (!atomic_add_unless(&data->dm_hit_count, -1, 0)) {
		/*
		 * we're already at zero, discard this hit
		 */
		goto out;
	}

	nlh = (struct nlmsghdr *)dskb->data;
	nla = genlmsg_data(nlmsg_data(nlh));
	msg = nla_data(nla);
	for (i = 0; i < msg->entries; i++) {
		if (!memcmp(&location, msg->points[i].pc, sizeof(void *))) {
			msg->points[i].count++;
			atomic_inc(&data->dm_hit_count);
			goto out;
		}
	}

	/*
	 * We need to create a new entry
	 */
	__nla_reserve_nohdr(dskb, sizeof(struct net_dm_drop_point));
	nla->nla_len += NLA_ALIGN(sizeof(struct net_dm_drop_point));
	memcpy(msg->points[msg->entries].pc, &location, sizeof(void *));
	msg->points[msg->entries].count = 1;
	msg->entries++;

	if (!timer_pending(&data->send_timer)) {
		data->send_timer.expires = jiffies + dm_delay * HZ;
		add_timer_on(&data->send_timer, smp_processor_id());
	}

out:
	rcu_read_unlock();
	put_cpu_var(dm_cpu_data);
	return;
}

static void trace_kfree_skb_hit(void *ignore, struct sk_buff *skb, void *location)
{
	trace_drop_common(skb, location);
}

static void trace_napi_poll_hit(void *ignore, struct napi_struct *napi)
{
	struct dm_hw_stat_delta *new_stat;

	/*
	 * Don't check napi structures with no associated device
	 */
	if (!napi->dev)
		return;

	rcu_read_lock();
	list_for_each_entry_rcu(new_stat, &hw_stats_list, list) {
		/*
		 * only add a note to our monitor buffer if:
		 * 1) this is the dev we received on
		 * 2) its after the last_rx delta
		 * 3) our rx_dropped count has gone up
		 */
		if ((new_stat->dev == napi->dev)  &&
		    (time_after(jiffies, new_stat->last_rx + dm_hw_check_delta)) &&
		    (napi->dev->stats.rx_dropped != new_stat->last_drop_val)) {
			trace_drop_common(NULL, NULL);
			new_stat->last_drop_val = napi->dev->stats.rx_dropped;
			new_stat->last_rx = jiffies;
			break;
		}
	}
	rcu_read_unlock();
}

static int set_all_monitor_traces(int state)
{
	int rc = 0;
	struct dm_hw_stat_delta *new_stat = NULL;
	struct dm_hw_stat_delta *temp;

	mutex_lock(&trace_state_mutex);

	if (state == trace_state) {
		rc = -EAGAIN;
		goto out_unlock;
	}

	switch (state) {
	case TRACE_ON:
		rc |= register_trace_kfree_skb(trace_kfree_skb_hit, NULL);
		rc |= register_trace_napi_poll(trace_napi_poll_hit, NULL);
		break;
	case TRACE_OFF:
		rc |= unregister_trace_kfree_skb(trace_kfree_skb_hit, NULL);
		rc |= unregister_trace_napi_poll(trace_napi_poll_hit, NULL);

		tracepoint_synchronize_unregister();

		/*
		 * Clean the device list
		 */
		list_for_each_entry_safe(new_stat, temp, &hw_stats_list, list) {
			if (new_stat->dev == NULL) {
				list_del_rcu(&new_stat->list);
				kfree_rcu(new_stat, rcu);
			}
		}
		break;
	default:
		rc = 1;
		break;
	}

	if (!rc)
		trace_state = state;
	else
		rc = -EINPROGRESS;

out_unlock:
	mutex_unlock(&trace_state_mutex);

	return rc;
}


static int net_dm_cmd_config(struct sk_buff *skb,
			struct genl_info *info)
{
	return -ENOTSUPP;
}

static int net_dm_cmd_trace(struct sk_buff *skb,
			struct genl_info *info)
{
	switch (info->genlhdr->cmd) {
	case NET_DM_CMD_START:
		return set_all_monitor_traces(TRACE_ON);
		break;
	case NET_DM_CMD_STOP:
		return set_all_monitor_traces(TRACE_OFF);
		break;
	}

	return -ENOTSUPP;
}

static int dropmon_net_event(struct notifier_block *ev_block,
			unsigned long event, void *ptr)
{
	struct net_device *dev = ptr;
	struct dm_hw_stat_delta *new_stat = NULL;
	struct dm_hw_stat_delta *tmp;

	switch (event) {
	case NETDEV_REGISTER:
		new_stat = kzalloc(sizeof(struct dm_hw_stat_delta), GFP_KERNEL);

		if (!new_stat)
			goto out;

		new_stat->dev = dev;
		new_stat->last_rx = jiffies;
		mutex_lock(&trace_state_mutex);
		list_add_rcu(&new_stat->list, &hw_stats_list);
		mutex_unlock(&trace_state_mutex);
		break;
	case NETDEV_UNREGISTER:
		mutex_lock(&trace_state_mutex);
		list_for_each_entry_safe(new_stat, tmp, &hw_stats_list, list) {
			if (new_stat->dev == dev) {
				new_stat->dev = NULL;
				if (trace_state == TRACE_OFF) {
					list_del_rcu(&new_stat->list);
					kfree_rcu(new_stat, rcu);
					break;
				}
			}
		}
		mutex_unlock(&trace_state_mutex);
		break;
	}
out:
	return NOTIFY_DONE;
}

static struct genl_ops dropmon_ops[] = {
	{
		.cmd = NET_DM_CMD_CONFIG,
		.doit = net_dm_cmd_config,
	},
	{
		.cmd = NET_DM_CMD_START,
		.doit = net_dm_cmd_trace,
	},
	{
		.cmd = NET_DM_CMD_STOP,
		.doit = net_dm_cmd_trace,
	},
};

static struct notifier_block dropmon_net_notifier = {
	.notifier_call = dropmon_net_event
};

static int __init init_net_drop_monitor(void)
{
	struct per_cpu_dm_data *data;
	int cpu, rc;

	printk(KERN_INFO "Initializing network drop monitor service\n");

	if (sizeof(void *) > 8) {
		printk(KERN_ERR "Unable to store program counters on this arch, Drop monitor failed\n");
		return -ENOSPC;
	}

	rc = genl_register_family_with_ops(&net_drop_monitor_family,
					   dropmon_ops,
					   ARRAY_SIZE(dropmon_ops));
	if (rc) {
		printk(KERN_ERR "Could not create drop monitor netlink family\n");
		return rc;
	}

	rc = register_netdevice_notifier(&dropmon_net_notifier);
	if (rc < 0) {
		printk(KERN_CRIT "Failed to register netdevice notifier\n");
		goto out_unreg;
	}

	rc = 0;

	for_each_present_cpu(cpu) {
		data = &per_cpu(dm_cpu_data, cpu);
		data->cpu = cpu;
		INIT_WORK(&data->dm_alert_work, send_dm_alert);
		init_timer(&data->send_timer);
		data->send_timer.data = cpu;
		data->send_timer.function = sched_send_work;
		reset_per_cpu_data(data);
	}


	goto out;

out_unreg:
	genl_unregister_family(&net_drop_monitor_family);
out:
	return rc;
}

late_initcall(init_net_drop_monitor);
Commit	Line	Data
9a8afc8d NH	1	/*
	2	* Monitoring code for network dropped packet alerts
	3	*
	4	* Copyright (C) 2009 Neil Horman <nhorman@tuxdriver.com>
	5	*/
	6
	7	#include <linux/netdevice.h>
	8	#include <linux/etherdevice.h>
	9	#include <linux/string.h>
	10	#include <linux/if_arp.h>
	11	#include <linux/inetdevice.h>
	12	#include <linux/inet.h>
	13	#include <linux/interrupt.h>
	14	#include <linux/netpoll.h>
	15	#include <linux/sched.h>
	16	#include <linux/delay.h>
	17	#include <linux/types.h>
	18	#include <linux/workqueue.h>
	19	#include <linux/netlink.h>
	20	#include <linux/net_dropmon.h>
	21	#include <linux/percpu.h>
	22	#include <linux/timer.h>
	23	#include <linux/bitops.h>
5a0e3ad6	24	#include <linux/slab.h>
9a8afc8d	25	#include <net/genetlink.h>
4ea7e386	26	#include <net/netevent.h>
9a8afc8d	27
ad8d75ff	28	#include <trace/events/skb.h>
9cbc1cb8	29	#include <trace/events/napi.h>
9a8afc8d NH	30
	31	#include <asm/unaligned.h>
	32
	33	#define TRACE_ON 1
	34	#define TRACE_OFF 0
	35
	36	static void send_dm_alert(struct work_struct *unused);
	37
	38
	39	/*
	40	* Globals, our netlink socket pointer
	41	* and the work handle that will send up
	42	* netlink alerts
	43	*/
4ea7e386	44	static int trace_state = TRACE_OFF;
cde2e9a6	45	static DEFINE_MUTEX(trace_state_mutex);
9a8afc8d NH	46
	47	struct per_cpu_dm_data {
	48	struct work_struct dm_alert_work;
3885ca78	49	struct sk_buff __rcu *skb;
9a8afc8d NH	50	atomic_t dm_hit_count;
9a8afc8d NH	51	struct timer_list send_timer;
4fdcfa12	52	int cpu;
9a8afc8d NH	53	};
9a8afc8d NH	54
4ea7e386 NH	55	struct dm_hw_stat_delta {
4ea7e386 NH	56	struct net_device *dev;
5848cc09	57	unsigned long last_rx;
4ea7e386 NH	58	struct list_head list;
	59	struct rcu_head rcu;
	60	unsigned long last_drop_val;
	61	};
	62
9a8afc8d NH	63	static struct genl_family net_drop_monitor_family = {
	64	.id = GENL_ID_GENERATE,
	65	.hdrsize = 0,
	66	.name = "NET_DM",
683703a2	67	.version = 2,
9a8afc8d NH	68	.maxattr = NET_DM_CMD_MAX,
	69	};
	70
	71	static DEFINE_PER_CPU(struct per_cpu_dm_data, dm_cpu_data);
	72
	73	static int dm_hit_limit = 64;
	74	static int dm_delay = 1;
4ea7e386 NH	75	static unsigned long dm_hw_check_delta = 2*HZ;
4ea7e386 NH	76	static LIST_HEAD(hw_stats_list);
9a8afc8d NH	77
	78	static void reset_per_cpu_data(struct per_cpu_dm_data *data)
	79	{
	80	size_t al;
	81	struct net_dm_alert_msg *msg;
683703a2	82	struct nlattr *nla;
3885ca78 NH	83	struct sk_buff *skb;
3885ca78 NH	84	struct sk_buff *oskb = rcu_dereference_protected(data->skb, 1);
9a8afc8d NH	85
	86	al = sizeof(struct net_dm_alert_msg);
	87	al += dm_hit_limit * sizeof(struct net_dm_drop_point);
683703a2 NH	88	al += sizeof(struct nlattr);
683703a2 NH	89
3885ca78 NH	90	skb = genlmsg_new(al, GFP_KERNEL);
	91
	92	if (skb) {
	93	genlmsg_put(skb, 0, 0, &net_drop_monitor_family,
	94	0, NET_DM_CMD_ALERT);
	95	nla = nla_reserve(skb, NLA_UNSPEC,
	96	sizeof(struct net_dm_alert_msg));
	97	msg = nla_data(nla);
	98	memset(msg, 0, al);
4fdcfa12 NH	99	} else
4fdcfa12 NH	100	schedule_work_on(data->cpu, &data->dm_alert_work);
3885ca78 NH	101
	102	/*
	103	* Don't need to lock this, since we are guaranteed to only
	104	* run this on a single cpu at a time.
	105	* Note also that we only update data->skb if the old and new skb
	106	* pointers don't match. This ensures that we don't continually call
	107	* synchornize_rcu if we repeatedly fail to alloc a new netlink message.
	108	*/
	109	if (skb != oskb) {
	110	rcu_assign_pointer(data->skb, skb);
	111
	112	synchronize_rcu();
	113
	114	atomic_set(&data->dm_hit_count, dm_hit_limit);
	115	}
	116
9a8afc8d NH	117	}
	118
	119	static void send_dm_alert(struct work_struct *unused)
	120	{
	121	struct sk_buff *skb;
3885ca78	122	struct per_cpu_dm_data *data = &get_cpu_var(dm_cpu_data);
9a8afc8d	123
4fdcfa12 NH	124	WARN_ON_ONCE(data->cpu != smp_processor_id());
4fdcfa12 NH	125
9a8afc8d NH	126	/*
	127	* Grab the skb we're about to send
	128	*/
3885ca78	129	skb = rcu_dereference_protected(data->skb, 1);
9a8afc8d NH	130
	131	/*
	132	* Replace it with a new one
	133	*/
	134	reset_per_cpu_data(data);
	135
	136	/*
	137	* Ship it!
	138	*/
3885ca78 NH	139	if (skb)
3885ca78 NH	140	genlmsg_multicast(skb, 0, NET_DM_GRP_ALERT, GFP_KERNEL);
9a8afc8d	141
3885ca78	142	put_cpu_var(dm_cpu_data);
9a8afc8d NH	143	}
	144
	145	/*
	146	* This is the timer function to delay the sending of an alert
	147	* in the event that more drops will arrive during the
	148	* hysteresis period. Note that it operates under the timer interrupt
	149	* so we don't need to disable preemption here
	150	*/
	151	static void sched_send_work(unsigned long unused)
	152	{
3885ca78 NH	153	struct per_cpu_dm_data *data = &get_cpu_var(dm_cpu_data);
	154
	155	schedule_work_on(smp_processor_id(), &data->dm_alert_work);
9a8afc8d	156
3885ca78	157	put_cpu_var(dm_cpu_data);
9a8afc8d NH	158	}
9a8afc8d NH	159
4ea7e386	160	static void trace_drop_common(struct sk_buff skb, void location)
9a8afc8d NH	161	{
	162	struct net_dm_alert_msg *msg;
	163	struct nlmsghdr *nlh;
683703a2	164	struct nlattr *nla;
9a8afc8d	165	int i;
3885ca78 NH	166	struct sk_buff *dskb;
3885ca78 NH	167	struct per_cpu_dm_data *data = &get_cpu_var(dm_cpu_data);
9a8afc8d NH	168
9a8afc8d NH	169
3885ca78 NH	170	rcu_read_lock();
	171	dskb = rcu_dereference(data->skb);
	172
	173	if (!dskb)
	174	goto out;
	175
9a8afc8d NH	176	if (!atomic_add_unless(&data->dm_hit_count, -1, 0)) {
	177	/*
	178	* we're already at zero, discard this hit
	179	*/
	180	goto out;
	181	}
	182
3885ca78	183	nlh = (struct nlmsghdr *)dskb->data;
683703a2 NH	184	nla = genlmsg_data(nlmsg_data(nlh));
683703a2 NH	185	msg = nla_data(nla);
9a8afc8d NH	186	for (i = 0; i < msg->entries; i++) {
	187	if (!memcmp(&location, msg->points[i].pc, sizeof(void *))) {
	188	msg->points[i].count++;
bbe362be	189	atomic_inc(&data->dm_hit_count);
9a8afc8d NH	190	goto out;
	191	}
	192	}
	193
	194	/*
	195	* We need to create a new entry
	196	*/
3885ca78	197	__nla_reserve_nohdr(dskb, sizeof(struct net_dm_drop_point));
683703a2	198	nla->nla_len += NLA_ALIGN(sizeof(struct net_dm_drop_point));
9a8afc8d NH	199	memcpy(msg->points[msg->entries].pc, &location, sizeof(void *));
	200	msg->points[msg->entries].count = 1;
	201	msg->entries++;
	202
	203	if (!timer_pending(&data->send_timer)) {
	204	data->send_timer.expires = jiffies + dm_delay * HZ;
	205	add_timer_on(&data->send_timer, smp_processor_id());
	206	}
	207
	208	out:
3885ca78 NH	209	rcu_read_unlock();
3885ca78 NH	210	put_cpu_var(dm_cpu_data);
9a8afc8d NH	211	return;
	212	}
	213
38516ab5	214	static void trace_kfree_skb_hit(void ignore, struct sk_buff skb, void *location)
4ea7e386 NH	215	{
	216	trace_drop_common(skb, location);
	217	}
	218
38516ab5	219	static void trace_napi_poll_hit(void ignore, struct napi_struct napi)
4ea7e386 NH	220	{
	221	struct dm_hw_stat_delta *new_stat;
	222
	223	/*
5848cc09	224	* Don't check napi structures with no associated device
4ea7e386	225	*/
5848cc09	226	if (!napi->dev)
4ea7e386 NH	227	return;
	228
	229	rcu_read_lock();
	230	list_for_each_entry_rcu(new_stat, &hw_stats_list, list) {
5848cc09 NH	231	/*
	232	* only add a note to our monitor buffer if:
	233	* 1) this is the dev we received on
	234	* 2) its after the last_rx delta
	235	* 3) our rx_dropped count has gone up
	236	*/
4ea7e386	237	if ((new_stat->dev == napi->dev) &&
5848cc09	238	(time_after(jiffies, new_stat->last_rx + dm_hw_check_delta)) &&
4ea7e386 NH	239	(napi->dev->stats.rx_dropped != new_stat->last_drop_val)) {
	240	trace_drop_common(NULL, NULL);
	241	new_stat->last_drop_val = napi->dev->stats.rx_dropped;
5848cc09	242	new_stat->last_rx = jiffies;
4ea7e386 NH	243	break;
	244	}
	245	}
	246	rcu_read_unlock();
	247	}
	248
9a8afc8d NH	249	static int set_all_monitor_traces(int state)
	250	{
	251	int rc = 0;
4ea7e386 NH	252	struct dm_hw_stat_delta *new_stat = NULL;
	253	struct dm_hw_stat_delta *temp;
	254
cde2e9a6	255	mutex_lock(&trace_state_mutex);
9a8afc8d	256
4b706372 NH	257	if (state == trace_state) {
	258	rc = -EAGAIN;
	259	goto out_unlock;
	260	}
	261
9a8afc8d NH	262	switch (state) {
9a8afc8d NH	263	case TRACE_ON:
38516ab5 SR	264	rc \|= register_trace_kfree_skb(trace_kfree_skb_hit, NULL);
38516ab5 SR	265	rc \|= register_trace_napi_poll(trace_napi_poll_hit, NULL);
9a8afc8d NH	266	break;
9a8afc8d NH	267	case TRACE_OFF:
38516ab5 SR	268	rc \|= unregister_trace_kfree_skb(trace_kfree_skb_hit, NULL);
38516ab5 SR	269	rc \|= unregister_trace_napi_poll(trace_napi_poll_hit, NULL);
9a8afc8d NH	270
9a8afc8d NH	271	tracepoint_synchronize_unregister();
4ea7e386 NH	272
	273	/*
	274	* Clean the device list
	275	*/
	276	list_for_each_entry_safe(new_stat, temp, &hw_stats_list, list) {
	277	if (new_stat->dev == NULL) {
	278	list_del_rcu(&new_stat->list);
fa81c0e1	279	kfree_rcu(new_stat, rcu);
4ea7e386 NH	280	}
4ea7e386 NH	281	}
9a8afc8d NH	282	break;
	283	default:
	284	rc = 1;
	285	break;
	286	}
	287
4ea7e386 NH	288	if (!rc)
4ea7e386 NH	289	trace_state = state;
4b706372 NH	290	else
4b706372 NH	291	rc = -EINPROGRESS;
4ea7e386	292
4b706372	293	out_unlock:
cde2e9a6	294	mutex_unlock(&trace_state_mutex);
4ea7e386	295
9a8afc8d NH	296	return rc;
	297	}
	298
	299
	300	static int net_dm_cmd_config(struct sk_buff *skb,
	301	struct genl_info *info)
	302	{
	303	return -ENOTSUPP;
	304	}
	305
	306	static int net_dm_cmd_trace(struct sk_buff *skb,
	307	struct genl_info *info)
	308	{
	309	switch (info->genlhdr->cmd) {
	310	case NET_DM_CMD_START:
	311	return set_all_monitor_traces(TRACE_ON);
	312	break;
	313	case NET_DM_CMD_STOP:
	314	return set_all_monitor_traces(TRACE_OFF);
	315	break;
	316	}
	317
	318	return -ENOTSUPP;
	319	}
	320
4ea7e386 NH	321	static int dropmon_net_event(struct notifier_block *ev_block,
	322	unsigned long event, void *ptr)
	323	{
	324	struct net_device *dev = ptr;
	325	struct dm_hw_stat_delta *new_stat = NULL;
	326	struct dm_hw_stat_delta *tmp;
	327
	328	switch (event) {
	329	case NETDEV_REGISTER:
	330	new_stat = kzalloc(sizeof(struct dm_hw_stat_delta), GFP_KERNEL);
	331
	332	if (!new_stat)
	333	goto out;
	334
	335	new_stat->dev = dev;
5848cc09	336	new_stat->last_rx = jiffies;
cde2e9a6	337	mutex_lock(&trace_state_mutex);
4ea7e386	338	list_add_rcu(&new_stat->list, &hw_stats_list);
cde2e9a6	339	mutex_unlock(&trace_state_mutex);
4ea7e386 NH	340	break;
4ea7e386 NH	341	case NETDEV_UNREGISTER:
cde2e9a6	342	mutex_lock(&trace_state_mutex);
4ea7e386 NH	343	list_for_each_entry_safe(new_stat, tmp, &hw_stats_list, list) {
	344	if (new_stat->dev == dev) {
	345	new_stat->dev = NULL;
	346	if (trace_state == TRACE_OFF) {
	347	list_del_rcu(&new_stat->list);
fa81c0e1	348	kfree_rcu(new_stat, rcu);
4ea7e386 NH	349	break;
	350	}
	351	}
	352	}
cde2e9a6	353	mutex_unlock(&trace_state_mutex);
4ea7e386 NH	354	break;
	355	}
	356	out:
	357	return NOTIFY_DONE;
	358	}
9a8afc8d NH	359
	360	static struct genl_ops dropmon_ops[] = {
	361	{
	362	.cmd = NET_DM_CMD_CONFIG,
	363	.doit = net_dm_cmd_config,
	364	},
	365	{
	366	.cmd = NET_DM_CMD_START,
	367	.doit = net_dm_cmd_trace,
	368	},
	369	{
	370	.cmd = NET_DM_CMD_STOP,
	371	.doit = net_dm_cmd_trace,
	372	},
	373	};
	374
4ea7e386 NH	375	static struct notifier_block dropmon_net_notifier = {
	376	.notifier_call = dropmon_net_event
	377	};
	378
9a8afc8d NH	379	static int __init init_net_drop_monitor(void)
9a8afc8d NH	380	{
9a8afc8d	381	struct per_cpu_dm_data *data;
a256be70 CG	382	int cpu, rc;
a256be70 CG	383
ac0a121d	384	printk(KERN_INFO "Initializing network drop monitor service\n");
9a8afc8d NH	385
	386	if (sizeof(void *) > 8) {
	387	printk(KERN_ERR "Unable to store program counters on this arch, Drop monitor failed\n");
	388	return -ENOSPC;
	389	}
	390
a256be70 CG	391	rc = genl_register_family_with_ops(&net_drop_monitor_family,
	392	dropmon_ops,
	393	ARRAY_SIZE(dropmon_ops));
	394	if (rc) {
9a8afc8d	395	printk(KERN_ERR "Could not create drop monitor netlink family\n");
a256be70	396	return rc;
9a8afc8d NH	397	}
9a8afc8d NH	398
4ea7e386 NH	399	rc = register_netdevice_notifier(&dropmon_net_notifier);
	400	if (rc < 0) {
	401	printk(KERN_CRIT "Failed to register netdevice notifier\n");
	402	goto out_unreg;
	403	}
	404
9a8afc8d NH	405	rc = 0;
	406
	407	for_each_present_cpu(cpu) {
	408	data = &per_cpu(dm_cpu_data, cpu);
4fdcfa12	409	data->cpu = cpu;
9a8afc8d NH	410	INIT_WORK(&data->dm_alert_work, send_dm_alert);
	411	init_timer(&data->send_timer);
	412	data->send_timer.data = cpu;
	413	data->send_timer.function = sched_send_work;
4fdcfa12	414	reset_per_cpu_data(data);
9a8afc8d	415	}
4ea7e386	416
3885ca78	417
9a8afc8d NH	418	goto out;
	419
	420	out_unreg:
	421	genl_unregister_family(&net_drop_monitor_family);
	422	out:
	423	return rc;
	424	}
	425
	426	late_initcall(init_net_drop_monitor);