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