~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/core/drop_monitor.c

Version: ~ [ linux-5.9 ] ~ [ linux-5.8.14 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.70 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.150 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.200 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.238 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.238 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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  */
 44 static int trace_state = TRACE_OFF;
 45 static DEFINE_MUTEX(trace_state_mutex);
 46 
 47 struct 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 
 54 struct 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 
 62 static struct genl_family net_drop_monitor_family = {
 63         .id             = GENL_ID_GENERATE,
 64         .hdrsize        = 0,
 65         .name           = "NET_DM",
 66         .version        = 2,
 67 };
 68 
 69 static DEFINE_PER_CPU(struct per_cpu_dm_data, dm_cpu_data);
 70 
 71 static int dm_hit_limit = 64;
 72 static int dm_delay = 1;
 73 static unsigned long dm_hw_check_delta = 2*HZ;
 74 static LIST_HEAD(hw_stats_list);
 75 
 76 static 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 
108 static struct genl_multicast_group dropmon_mcgrps[] = {
109         { .name = "events", },
110 };
111 
112 static 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  */
131 static 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 
138 static 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 = &__get_cpu_var(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 
181 out:
182         spin_unlock_irqrestore(&data->lock, flags);
183 }
184 
185 static void trace_kfree_skb_hit(void *ignore, struct sk_buff *skb, void *location)
186 {
187         trace_drop_common(skb, location);
188 }
189 
190 static 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 
220 static 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 
273 out_unlock:
274         mutex_unlock(&trace_state_mutex);
275 
276         return rc;
277 }
278 
279 
280 static int net_dm_cmd_config(struct sk_buff *skb,
281                         struct genl_info *info)
282 {
283         return -ENOTSUPP;
284 }
285 
286 static 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                 break;
293         case NET_DM_CMD_STOP:
294                 return set_all_monitor_traces(TRACE_OFF);
295                 break;
296         }
297 
298         return -ENOTSUPP;
299 }
300 
301 static int dropmon_net_event(struct notifier_block *ev_block,
302                              unsigned long event, void *ptr)
303 {
304         struct net_device *dev = netdev_notifier_info_to_dev(ptr);
305         struct dm_hw_stat_delta *new_stat = NULL;
306         struct dm_hw_stat_delta *tmp;
307 
308         switch (event) {
309         case NETDEV_REGISTER:
310                 new_stat = kzalloc(sizeof(struct dm_hw_stat_delta), GFP_KERNEL);
311 
312                 if (!new_stat)
313                         goto out;
314 
315                 new_stat->dev = dev;
316                 new_stat->last_rx = jiffies;
317                 mutex_lock(&trace_state_mutex);
318                 list_add_rcu(&new_stat->list, &hw_stats_list);
319                 mutex_unlock(&trace_state_mutex);
320                 break;
321         case NETDEV_UNREGISTER:
322                 mutex_lock(&trace_state_mutex);
323                 list_for_each_entry_safe(new_stat, tmp, &hw_stats_list, list) {
324                         if (new_stat->dev == dev) {
325                                 new_stat->dev = NULL;
326                                 if (trace_state == TRACE_OFF) {
327                                         list_del_rcu(&new_stat->list);
328                                         kfree_rcu(new_stat, rcu);
329                                         break;
330                                 }
331                         }
332                 }
333                 mutex_unlock(&trace_state_mutex);
334                 break;
335         }
336 out:
337         return NOTIFY_DONE;
338 }
339 
340 static const struct genl_ops dropmon_ops[] = {
341         {
342                 .cmd = NET_DM_CMD_CONFIG,
343                 .doit = net_dm_cmd_config,
344         },
345         {
346                 .cmd = NET_DM_CMD_START,
347                 .doit = net_dm_cmd_trace,
348         },
349         {
350                 .cmd = NET_DM_CMD_STOP,
351                 .doit = net_dm_cmd_trace,
352         },
353 };
354 
355 static struct notifier_block dropmon_net_notifier = {
356         .notifier_call = dropmon_net_event
357 };
358 
359 static int __init init_net_drop_monitor(void)
360 {
361         struct per_cpu_dm_data *data;
362         int cpu, rc;
363 
364         pr_info("Initializing network drop monitor service\n");
365 
366         if (sizeof(void *) > 8) {
367                 pr_err("Unable to store program counters on this arch, Drop monitor failed\n");
368                 return -ENOSPC;
369         }
370 
371         rc = genl_register_family_with_ops_groups(&net_drop_monitor_family,
372                                                   dropmon_ops, dropmon_mcgrps);
373         if (rc) {
374                 pr_err("Could not create drop monitor netlink family\n");
375                 return rc;
376         }
377         WARN_ON(net_drop_monitor_family.mcgrp_offset != NET_DM_GRP_ALERT);
378 
379         rc = register_netdevice_notifier(&dropmon_net_notifier);
380         if (rc < 0) {
381                 pr_crit("Failed to register netdevice notifier\n");
382                 goto out_unreg;
383         }
384 
385         rc = 0;
386 
387         for_each_possible_cpu(cpu) {
388                 data = &per_cpu(dm_cpu_data, cpu);
389                 INIT_WORK(&data->dm_alert_work, send_dm_alert);
390                 init_timer(&data->send_timer);
391                 data->send_timer.data = (unsigned long)data;
392                 data->send_timer.function = sched_send_work;
393                 spin_lock_init(&data->lock);
394                 reset_per_cpu_data(data);
395         }
396 
397 
398         goto out;
399 
400 out_unreg:
401         genl_unregister_family(&net_drop_monitor_family);
402 out:
403         return rc;
404 }
405 
406 static void exit_net_drop_monitor(void)
407 {
408         struct per_cpu_dm_data *data;
409         int cpu;
410 
411         BUG_ON(unregister_netdevice_notifier(&dropmon_net_notifier));
412 
413         /*
414          * Because of the module_get/put we do in the trace state change path
415          * we are guarnateed not to have any current users when we get here
416          * all we need to do is make sure that we don't have any running timers
417          * or pending schedule calls
418          */
419 
420         for_each_possible_cpu(cpu) {
421                 data = &per_cpu(dm_cpu_data, cpu);
422                 del_timer_sync(&data->send_timer);
423                 cancel_work_sync(&data->dm_alert_work);
424                 /*
425                  * At this point, we should have exclusive access
426                  * to this struct and can free the skb inside it
427                  */
428                 kfree_skb(data->skb);
429         }
430 
431         BUG_ON(genl_unregister_family(&net_drop_monitor_family));
432 }
433 
434 module_init(init_net_drop_monitor);
435 module_exit(exit_net_drop_monitor);
436 
437 MODULE_LICENSE("GPL v2");
438 MODULE_AUTHOR("Neil Horman <nhorman@tuxdriver.com>");
439 MODULE_ALIAS_GENL_FAMILY("NET_DM");
440 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp