2 * Monitoring code for network dropped packet alerts
4 * Copyright (C) 2009 Neil Horman <nhorman@tuxdriver.com>
7 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
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>
31 #include <trace/events/skb.h>
32 #include <trace/events/napi.h>
34 #include <asm/unaligned.h>
40 * Globals, our netlink socket pointer
41 * and the work handle that will send up
44 static int trace_state
= TRACE_OFF
;
45 static DEFINE_MUTEX(trace_state_mutex
);
47 struct per_cpu_dm_data
{
50 struct work_struct dm_alert_work
;
51 struct timer_list send_timer
;
54 struct dm_hw_stat_delta
{
55 struct net_device
*dev
;
56 unsigned long last_rx
;
57 struct list_head list
;
59 unsigned long last_drop_val
;
62 static struct genl_family net_drop_monitor_family
;
64 static DEFINE_PER_CPU(struct per_cpu_dm_data
, dm_cpu_data
);
66 static int dm_hit_limit
= 64;
67 static int dm_delay
= 1;
68 static unsigned long dm_hw_check_delta
= 2*HZ
;
69 static LIST_HEAD(hw_stats_list
);
71 static struct sk_buff
*reset_per_cpu_data(struct per_cpu_dm_data
*data
)
74 struct net_dm_alert_msg
*msg
;
79 al
= sizeof(struct net_dm_alert_msg
);
80 al
+= dm_hit_limit
* sizeof(struct net_dm_drop_point
);
81 al
+= sizeof(struct nlattr
);
83 skb
= genlmsg_new(al
, GFP_KERNEL
);
86 genlmsg_put(skb
, 0, 0, &net_drop_monitor_family
,
88 nla
= nla_reserve(skb
, NLA_UNSPEC
,
89 sizeof(struct net_dm_alert_msg
));
93 mod_timer(&data
->send_timer
, jiffies
+ HZ
/ 10);
96 spin_lock_irqsave(&data
->lock
, flags
);
98 spin_unlock_irqrestore(&data
->lock
, flags
);
103 static const struct genl_multicast_group dropmon_mcgrps
[] = {
104 { .name
= "events", },
107 static void send_dm_alert(struct work_struct
*work
)
110 struct per_cpu_dm_data
*data
;
112 data
= container_of(work
, struct per_cpu_dm_data
, dm_alert_work
);
114 skb
= reset_per_cpu_data(data
);
117 genlmsg_multicast(&net_drop_monitor_family
, skb
, 0,
122 * This is the timer function to delay the sending of an alert
123 * in the event that more drops will arrive during the
126 static void sched_send_work(unsigned long _data
)
128 struct per_cpu_dm_data
*data
= (struct per_cpu_dm_data
*)_data
;
130 schedule_work(&data
->dm_alert_work
);
133 static void trace_drop_common(struct sk_buff
*skb
, void *location
)
135 struct net_dm_alert_msg
*msg
;
136 struct nlmsghdr
*nlh
;
139 struct sk_buff
*dskb
;
140 struct per_cpu_dm_data
*data
;
143 local_irq_save(flags
);
144 data
= this_cpu_ptr(&dm_cpu_data
);
145 spin_lock(&data
->lock
);
151 nlh
= (struct nlmsghdr
*)dskb
->data
;
152 nla
= genlmsg_data(nlmsg_data(nlh
));
154 for (i
= 0; i
< msg
->entries
; i
++) {
155 if (!memcmp(&location
, msg
->points
[i
].pc
, sizeof(void *))) {
156 msg
->points
[i
].count
++;
160 if (msg
->entries
== dm_hit_limit
)
163 * We need to create a new entry
165 __nla_reserve_nohdr(dskb
, sizeof(struct net_dm_drop_point
));
166 nla
->nla_len
+= NLA_ALIGN(sizeof(struct net_dm_drop_point
));
167 memcpy(msg
->points
[msg
->entries
].pc
, &location
, sizeof(void *));
168 msg
->points
[msg
->entries
].count
= 1;
171 if (!timer_pending(&data
->send_timer
)) {
172 data
->send_timer
.expires
= jiffies
+ dm_delay
* HZ
;
173 add_timer(&data
->send_timer
);
177 spin_unlock_irqrestore(&data
->lock
, flags
);
180 static void trace_kfree_skb_hit(void *ignore
, struct sk_buff
*skb
, void *location
)
182 trace_drop_common(skb
, location
);
185 static void trace_napi_poll_hit(void *ignore
, struct napi_struct
*napi
,
186 int work
, int budget
)
188 struct dm_hw_stat_delta
*new_stat
;
191 * Don't check napi structures with no associated device
197 list_for_each_entry_rcu(new_stat
, &hw_stats_list
, list
) {
199 * only add a note to our monitor buffer if:
200 * 1) this is the dev we received on
201 * 2) its after the last_rx delta
202 * 3) our rx_dropped count has gone up
204 if ((new_stat
->dev
== napi
->dev
) &&
205 (time_after(jiffies
, new_stat
->last_rx
+ dm_hw_check_delta
)) &&
206 (napi
->dev
->stats
.rx_dropped
!= new_stat
->last_drop_val
)) {
207 trace_drop_common(NULL
, NULL
);
208 new_stat
->last_drop_val
= napi
->dev
->stats
.rx_dropped
;
209 new_stat
->last_rx
= jiffies
;
216 static int set_all_monitor_traces(int state
)
219 struct dm_hw_stat_delta
*new_stat
= NULL
;
220 struct dm_hw_stat_delta
*temp
;
222 mutex_lock(&trace_state_mutex
);
224 if (state
== trace_state
) {
231 if (!try_module_get(THIS_MODULE
)) {
236 rc
|= register_trace_kfree_skb(trace_kfree_skb_hit
, NULL
);
237 rc
|= register_trace_napi_poll(trace_napi_poll_hit
, NULL
);
241 rc
|= unregister_trace_kfree_skb(trace_kfree_skb_hit
, NULL
);
242 rc
|= unregister_trace_napi_poll(trace_napi_poll_hit
, NULL
);
244 tracepoint_synchronize_unregister();
247 * Clean the device list
249 list_for_each_entry_safe(new_stat
, temp
, &hw_stats_list
, list
) {
250 if (new_stat
->dev
== NULL
) {
251 list_del_rcu(&new_stat
->list
);
252 kfree_rcu(new_stat
, rcu
);
256 module_put(THIS_MODULE
);
270 mutex_unlock(&trace_state_mutex
);
276 static int net_dm_cmd_config(struct sk_buff
*skb
,
277 struct genl_info
*info
)
282 static int net_dm_cmd_trace(struct sk_buff
*skb
,
283 struct genl_info
*info
)
285 switch (info
->genlhdr
->cmd
) {
286 case NET_DM_CMD_START
:
287 return set_all_monitor_traces(TRACE_ON
);
288 case NET_DM_CMD_STOP
:
289 return set_all_monitor_traces(TRACE_OFF
);
295 static int dropmon_net_event(struct notifier_block
*ev_block
,
296 unsigned long event
, void *ptr
)
298 struct net_device
*dev
= netdev_notifier_info_to_dev(ptr
);
299 struct dm_hw_stat_delta
*new_stat
= NULL
;
300 struct dm_hw_stat_delta
*tmp
;
303 case NETDEV_REGISTER
:
304 new_stat
= kzalloc(sizeof(struct dm_hw_stat_delta
), GFP_KERNEL
);
310 new_stat
->last_rx
= jiffies
;
311 mutex_lock(&trace_state_mutex
);
312 list_add_rcu(&new_stat
->list
, &hw_stats_list
);
313 mutex_unlock(&trace_state_mutex
);
315 case NETDEV_UNREGISTER
:
316 mutex_lock(&trace_state_mutex
);
317 list_for_each_entry_safe(new_stat
, tmp
, &hw_stats_list
, list
) {
318 if (new_stat
->dev
== dev
) {
319 new_stat
->dev
= NULL
;
320 if (trace_state
== TRACE_OFF
) {
321 list_del_rcu(&new_stat
->list
);
322 kfree_rcu(new_stat
, rcu
);
327 mutex_unlock(&trace_state_mutex
);
334 static const struct genl_ops dropmon_ops
[] = {
336 .cmd
= NET_DM_CMD_CONFIG
,
337 .doit
= net_dm_cmd_config
,
340 .cmd
= NET_DM_CMD_START
,
341 .doit
= net_dm_cmd_trace
,
344 .cmd
= NET_DM_CMD_STOP
,
345 .doit
= net_dm_cmd_trace
,
349 static struct genl_family net_drop_monitor_family __ro_after_init
= {
353 .module
= THIS_MODULE
,
355 .n_ops
= ARRAY_SIZE(dropmon_ops
),
356 .mcgrps
= dropmon_mcgrps
,
357 .n_mcgrps
= ARRAY_SIZE(dropmon_mcgrps
),
360 static struct notifier_block dropmon_net_notifier
= {
361 .notifier_call
= dropmon_net_event
364 static int __init
init_net_drop_monitor(void)
366 struct per_cpu_dm_data
*data
;
369 pr_info("Initializing network drop monitor service\n");
371 if (sizeof(void *) > 8) {
372 pr_err("Unable to store program counters on this arch, Drop monitor failed\n");
376 rc
= genl_register_family(&net_drop_monitor_family
);
378 pr_err("Could not create drop monitor netlink family\n");
381 WARN_ON(net_drop_monitor_family
.mcgrp_offset
!= NET_DM_GRP_ALERT
);
383 rc
= register_netdevice_notifier(&dropmon_net_notifier
);
385 pr_crit("Failed to register netdevice notifier\n");
391 for_each_possible_cpu(cpu
) {
392 data
= &per_cpu(dm_cpu_data
, cpu
);
393 INIT_WORK(&data
->dm_alert_work
, send_dm_alert
);
394 init_timer(&data
->send_timer
);
395 data
->send_timer
.data
= (unsigned long)data
;
396 data
->send_timer
.function
= sched_send_work
;
397 spin_lock_init(&data
->lock
);
398 reset_per_cpu_data(data
);
405 genl_unregister_family(&net_drop_monitor_family
);
410 static void exit_net_drop_monitor(void)
412 struct per_cpu_dm_data
*data
;
415 BUG_ON(unregister_netdevice_notifier(&dropmon_net_notifier
));
418 * Because of the module_get/put we do in the trace state change path
419 * we are guarnateed not to have any current users when we get here
420 * all we need to do is make sure that we don't have any running timers
421 * or pending schedule calls
424 for_each_possible_cpu(cpu
) {
425 data
= &per_cpu(dm_cpu_data
, cpu
);
426 del_timer_sync(&data
->send_timer
);
427 cancel_work_sync(&data
->dm_alert_work
);
429 * At this point, we should have exclusive access
430 * to this struct and can free the skb inside it
432 kfree_skb(data
->skb
);
435 BUG_ON(genl_unregister_family(&net_drop_monitor_family
));
438 module_init(init_net_drop_monitor
);
439 module_exit(exit_net_drop_monitor
);
441 MODULE_LICENSE("GPL v2");
442 MODULE_AUTHOR("Neil Horman <nhorman@tuxdriver.com>");
443 MODULE_ALIAS_GENL_FAMILY("NET_DM");