[mirror_ubuntu-bionic-kernel.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;
};

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 int initialized = 0;

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 if (initialized)
		schedule_work_on(smp_processor_id(), &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);

	/*
	 * 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);
		reset_per_cpu_data(data);
		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;
	}

	initialized = 1;

	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;
	51	struct timer_list send_timer;
	52	};
	53
4ea7e386 NH	54	struct dm_hw_stat_delta {
4ea7e386 NH	55	struct net_device *dev;
5848cc09	56	unsigned long last_rx;
4ea7e386 NH	57	struct list_head list;
	58	struct rcu_head rcu;
	59	unsigned long last_drop_val;
	60	};
	61
9a8afc8d NH	62	static struct genl_family net_drop_monitor_family = {
	63	.id = GENL_ID_GENERATE,
	64	.hdrsize = 0,
	65	.name = "NET_DM",
683703a2	66	.version = 2,
9a8afc8d NH	67	.maxattr = NET_DM_CMD_MAX,
	68	};
	69
	70	static DEFINE_PER_CPU(struct per_cpu_dm_data, dm_cpu_data);
	71
	72	static int dm_hit_limit = 64;
	73	static int dm_delay = 1;
4ea7e386 NH	74	static unsigned long dm_hw_check_delta = 2*HZ;
4ea7e386 NH	75	static LIST_HEAD(hw_stats_list);
3885ca78	76	static int initialized = 0;
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);
	99	} else if (initialized)
	100	schedule_work_on(smp_processor_id(), &data->dm_alert_work);
	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 NH	123
	124	/*
	125	* Grab the skb we're about to send
	126	*/
3885ca78	127	skb = rcu_dereference_protected(data->skb, 1);
9a8afc8d NH	128
	129	/*
	130	* Replace it with a new one
	131	*/
	132	reset_per_cpu_data(data);
	133
	134	/*
	135	* Ship it!
	136	*/
3885ca78 NH	137	if (skb)
3885ca78 NH	138	genlmsg_multicast(skb, 0, NET_DM_GRP_ALERT, GFP_KERNEL);
9a8afc8d	139
3885ca78	140	put_cpu_var(dm_cpu_data);
9a8afc8d NH	141	}
	142
	143	/*
	144	* This is the timer function to delay the sending of an alert
	145	* in the event that more drops will arrive during the
	146	* hysteresis period. Note that it operates under the timer interrupt
	147	* so we don't need to disable preemption here
	148	*/
	149	static void sched_send_work(unsigned long unused)
	150	{
3885ca78 NH	151	struct per_cpu_dm_data *data = &get_cpu_var(dm_cpu_data);
	152
	153	schedule_work_on(smp_processor_id(), &data->dm_alert_work);
9a8afc8d	154
3885ca78	155	put_cpu_var(dm_cpu_data);
9a8afc8d NH	156	}
9a8afc8d NH	157
4ea7e386	158	static void trace_drop_common(struct sk_buff skb, void location)
9a8afc8d NH	159	{
	160	struct net_dm_alert_msg *msg;
	161	struct nlmsghdr *nlh;
683703a2	162	struct nlattr *nla;
9a8afc8d	163	int i;
3885ca78 NH	164	struct sk_buff *dskb;
3885ca78 NH	165	struct per_cpu_dm_data *data = &get_cpu_var(dm_cpu_data);
9a8afc8d NH	166
9a8afc8d NH	167
3885ca78 NH	168	rcu_read_lock();
	169	dskb = rcu_dereference(data->skb);
	170
	171	if (!dskb)
	172	goto out;
	173
9a8afc8d NH	174	if (!atomic_add_unless(&data->dm_hit_count, -1, 0)) {
	175	/*
	176	* we're already at zero, discard this hit
	177	*/
	178	goto out;
	179	}
	180
3885ca78	181	nlh = (struct nlmsghdr *)dskb->data;
683703a2 NH	182	nla = genlmsg_data(nlmsg_data(nlh));
683703a2 NH	183	msg = nla_data(nla);
9a8afc8d NH	184	for (i = 0; i < msg->entries; i++) {
	185	if (!memcmp(&location, msg->points[i].pc, sizeof(void *))) {
	186	msg->points[i].count++;
bbe362be	187	atomic_inc(&data->dm_hit_count);
9a8afc8d NH	188	goto out;
	189	}
	190	}
	191
	192	/*
	193	* We need to create a new entry
	194	*/
3885ca78	195	__nla_reserve_nohdr(dskb, sizeof(struct net_dm_drop_point));
683703a2	196	nla->nla_len += NLA_ALIGN(sizeof(struct net_dm_drop_point));
9a8afc8d NH	197	memcpy(msg->points[msg->entries].pc, &location, sizeof(void *));
	198	msg->points[msg->entries].count = 1;
	199	msg->entries++;
	200
	201	if (!timer_pending(&data->send_timer)) {
	202	data->send_timer.expires = jiffies + dm_delay * HZ;
	203	add_timer_on(&data->send_timer, smp_processor_id());
	204	}
	205
	206	out:
3885ca78 NH	207	rcu_read_unlock();
3885ca78 NH	208	put_cpu_var(dm_cpu_data);
9a8afc8d NH	209	return;
	210	}
	211
38516ab5	212	static void trace_kfree_skb_hit(void ignore, struct sk_buff skb, void *location)
4ea7e386 NH	213	{
	214	trace_drop_common(skb, location);
	215	}
	216
38516ab5	217	static void trace_napi_poll_hit(void ignore, struct napi_struct napi)
4ea7e386 NH	218	{
	219	struct dm_hw_stat_delta *new_stat;
	220
	221	/*
5848cc09	222	* Don't check napi structures with no associated device
4ea7e386	223	*/
5848cc09	224	if (!napi->dev)
4ea7e386 NH	225	return;
	226
	227	rcu_read_lock();
	228	list_for_each_entry_rcu(new_stat, &hw_stats_list, list) {
5848cc09 NH	229	/*
	230	* only add a note to our monitor buffer if:
	231	* 1) this is the dev we received on
	232	* 2) its after the last_rx delta
	233	* 3) our rx_dropped count has gone up
	234	*/
4ea7e386	235	if ((new_stat->dev == napi->dev) &&
5848cc09	236	(time_after(jiffies, new_stat->last_rx + dm_hw_check_delta)) &&
4ea7e386 NH	237	(napi->dev->stats.rx_dropped != new_stat->last_drop_val)) {
	238	trace_drop_common(NULL, NULL);
	239	new_stat->last_drop_val = napi->dev->stats.rx_dropped;
5848cc09	240	new_stat->last_rx = jiffies;
4ea7e386 NH	241	break;
	242	}
	243	}
	244	rcu_read_unlock();
	245	}
	246
9a8afc8d NH	247	static int set_all_monitor_traces(int state)
	248	{
	249	int rc = 0;
4ea7e386 NH	250	struct dm_hw_stat_delta *new_stat = NULL;
	251	struct dm_hw_stat_delta *temp;
	252
cde2e9a6	253	mutex_lock(&trace_state_mutex);
9a8afc8d	254
4b706372 NH	255	if (state == trace_state) {
	256	rc = -EAGAIN;
	257	goto out_unlock;
	258	}
	259
9a8afc8d NH	260	switch (state) {
9a8afc8d NH	261	case TRACE_ON:
38516ab5 SR	262	rc \|= register_trace_kfree_skb(trace_kfree_skb_hit, NULL);
38516ab5 SR	263	rc \|= register_trace_napi_poll(trace_napi_poll_hit, NULL);
9a8afc8d NH	264	break;
9a8afc8d NH	265	case TRACE_OFF:
38516ab5 SR	266	rc \|= unregister_trace_kfree_skb(trace_kfree_skb_hit, NULL);
38516ab5 SR	267	rc \|= unregister_trace_napi_poll(trace_napi_poll_hit, NULL);
9a8afc8d NH	268
9a8afc8d NH	269	tracepoint_synchronize_unregister();
4ea7e386 NH	270
	271	/*
	272	* Clean the device list
	273	*/
	274	list_for_each_entry_safe(new_stat, temp, &hw_stats_list, list) {
	275	if (new_stat->dev == NULL) {
	276	list_del_rcu(&new_stat->list);
fa81c0e1	277	kfree_rcu(new_stat, rcu);
4ea7e386 NH	278	}
4ea7e386 NH	279	}
9a8afc8d NH	280	break;
	281	default:
	282	rc = 1;
	283	break;
	284	}
	285
4ea7e386 NH	286	if (!rc)
4ea7e386 NH	287	trace_state = state;
4b706372 NH	288	else
4b706372 NH	289	rc = -EINPROGRESS;
4ea7e386	290
4b706372	291	out_unlock:
cde2e9a6	292	mutex_unlock(&trace_state_mutex);
4ea7e386	293
9a8afc8d NH	294	return rc;
	295	}
	296
	297
	298	static int net_dm_cmd_config(struct sk_buff *skb,
	299	struct genl_info *info)
	300	{
	301	return -ENOTSUPP;
	302	}
	303
	304	static int net_dm_cmd_trace(struct sk_buff *skb,
	305	struct genl_info *info)
	306	{
	307	switch (info->genlhdr->cmd) {
	308	case NET_DM_CMD_START:
	309	return set_all_monitor_traces(TRACE_ON);
	310	break;
	311	case NET_DM_CMD_STOP:
	312	return set_all_monitor_traces(TRACE_OFF);
	313	break;
	314	}
	315
	316	return -ENOTSUPP;
	317	}
	318
4ea7e386 NH	319	static int dropmon_net_event(struct notifier_block *ev_block,
	320	unsigned long event, void *ptr)
	321	{
	322	struct net_device *dev = ptr;
	323	struct dm_hw_stat_delta *new_stat = NULL;
	324	struct dm_hw_stat_delta *tmp;
	325
	326	switch (event) {
	327	case NETDEV_REGISTER:
	328	new_stat = kzalloc(sizeof(struct dm_hw_stat_delta), GFP_KERNEL);
	329
	330	if (!new_stat)
	331	goto out;
	332
	333	new_stat->dev = dev;
5848cc09	334	new_stat->last_rx = jiffies;
cde2e9a6	335	mutex_lock(&trace_state_mutex);
4ea7e386	336	list_add_rcu(&new_stat->list, &hw_stats_list);
cde2e9a6	337	mutex_unlock(&trace_state_mutex);
4ea7e386 NH	338	break;
4ea7e386 NH	339	case NETDEV_UNREGISTER:
cde2e9a6	340	mutex_lock(&trace_state_mutex);
4ea7e386 NH	341	list_for_each_entry_safe(new_stat, tmp, &hw_stats_list, list) {
	342	if (new_stat->dev == dev) {
	343	new_stat->dev = NULL;
	344	if (trace_state == TRACE_OFF) {
	345	list_del_rcu(&new_stat->list);
fa81c0e1	346	kfree_rcu(new_stat, rcu);
4ea7e386 NH	347	break;
	348	}
	349	}
	350	}
cde2e9a6	351	mutex_unlock(&trace_state_mutex);
4ea7e386 NH	352	break;
	353	}
	354	out:
	355	return NOTIFY_DONE;
	356	}
9a8afc8d NH	357
	358	static struct genl_ops dropmon_ops[] = {
	359	{
	360	.cmd = NET_DM_CMD_CONFIG,
	361	.doit = net_dm_cmd_config,
	362	},
	363	{
	364	.cmd = NET_DM_CMD_START,
	365	.doit = net_dm_cmd_trace,
	366	},
	367	{
	368	.cmd = NET_DM_CMD_STOP,
	369	.doit = net_dm_cmd_trace,
	370	},
	371	};
	372
4ea7e386 NH	373	static struct notifier_block dropmon_net_notifier = {
	374	.notifier_call = dropmon_net_event
	375	};
	376
9a8afc8d NH	377	static int __init init_net_drop_monitor(void)
9a8afc8d NH	378	{
9a8afc8d	379	struct per_cpu_dm_data *data;
a256be70 CG	380	int cpu, rc;
a256be70 CG	381
ac0a121d	382	printk(KERN_INFO "Initializing network drop monitor service\n");
9a8afc8d NH	383
	384	if (sizeof(void *) > 8) {
	385	printk(KERN_ERR "Unable to store program counters on this arch, Drop monitor failed\n");
	386	return -ENOSPC;
	387	}
	388
a256be70 CG	389	rc = genl_register_family_with_ops(&net_drop_monitor_family,
	390	dropmon_ops,
	391	ARRAY_SIZE(dropmon_ops));
	392	if (rc) {
9a8afc8d	393	printk(KERN_ERR "Could not create drop monitor netlink family\n");
a256be70	394	return rc;
9a8afc8d NH	395	}
9a8afc8d NH	396
4ea7e386 NH	397	rc = register_netdevice_notifier(&dropmon_net_notifier);
	398	if (rc < 0) {
	399	printk(KERN_CRIT "Failed to register netdevice notifier\n");
	400	goto out_unreg;
	401	}
	402
9a8afc8d NH	403	rc = 0;
	404
	405	for_each_present_cpu(cpu) {
	406	data = &per_cpu(dm_cpu_data, cpu);
	407	reset_per_cpu_data(data);
	408	INIT_WORK(&data->dm_alert_work, send_dm_alert);
	409	init_timer(&data->send_timer);
	410	data->send_timer.data = cpu;
	411	data->send_timer.function = sched_send_work;
	412	}
4ea7e386	413
3885ca78 NH	414	initialized = 1;
3885ca78 NH	415
9a8afc8d NH	416	goto out;
	417
	418	out_unreg:
	419	genl_unregister_family(&net_drop_monitor_family);
	420	out:
	421	return rc;
	422	}
	423
	424	late_initcall(init_net_drop_monitor);