2 * wprobe-core.c: Wireless probe interface core
3 * Copyright (C) 2008-2009 Felix Fietkau <nbd@openwrt.org>
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License
7 * as published by the Free Software Foundation; either version 2
8 * of the License, or (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
16 #include <linux/kernel.h>
17 #include <linux/version.h>
18 #include <linux/module.h>
19 #include <linux/types.h>
20 #include <linux/spinlock.h>
21 #include <linux/rcupdate.h>
22 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26)
23 #include <linux/rculist.h>
25 #include <linux/list.h>
27 #include <linux/skbuff.h>
28 #include <linux/wprobe.h>
29 #include <linux/math64.h>
33 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,28)
34 #define list_for_each_rcu(pos, head) \
35 for (pos = rcu_dereference((head)->next); \
36 prefetch(pos->next), pos != (head); \
37 pos = rcu_dereference(pos->next))
40 #define WPROBE_MIN_INTERVAL 100 /* minimum measurement interval in msecs */
41 #define WPROBE_MAX_FILTER_SIZE 1024
42 #define WPROBE_MAX_FRAME_SIZE 1900
44 static struct list_head wprobe_if;
45 static spinlock_t wprobe_lock;
47 static struct genl_family wprobe_fam = {
48 .id = GENL_ID_GENERATE,
52 /* only the first set of attributes is used for queries */
53 .maxattr = WPROBE_ATTR_LAST,
56 /* fake radiotap header */
57 struct wprobe_rtap_hdr {
64 static void wprobe_update_stats(struct wprobe_iface *dev, struct wprobe_link *l);
65 static int wprobe_sync_data(struct wprobe_iface *dev, struct wprobe_link *l, bool query);
66 static void wprobe_free_filter(struct wprobe_filter *f);
69 wprobe_add_link(struct wprobe_iface *s, struct wprobe_link *l, const char *addr)
73 INIT_LIST_HEAD(&l->list);
74 l->val = kzalloc(sizeof(struct wprobe_value) * s->n_link_items, GFP_ATOMIC);
79 memcpy(&l->addr, addr, ETH_ALEN);
80 spin_lock_irqsave(&wprobe_lock, flags);
81 list_add_tail_rcu(&l->list, &s->links);
82 spin_unlock_irqrestore(&wprobe_lock, flags);
86 EXPORT_SYMBOL(wprobe_add_link);
89 wprobe_remove_link(struct wprobe_iface *s, struct wprobe_link *l)
93 spin_lock_irqsave(&wprobe_lock, flags);
94 list_del_rcu(&l->list);
95 spin_unlock_irqrestore(&wprobe_lock, flags);
99 EXPORT_SYMBOL(wprobe_remove_link);
102 wprobe_measure_timer(unsigned long data)
104 struct wprobe_iface *dev = (struct wprobe_iface *) data;
106 /* set next measurement interval */
107 mod_timer(&dev->measure_timer, jiffies +
108 msecs_to_jiffies(dev->measure_interval));
110 /* perform measurement */
111 wprobe_sync_data(dev, NULL, false);
115 wprobe_add_iface(struct wprobe_iface *s)
120 /* reset only wprobe private area */
121 memset(&s->list, 0, sizeof(struct wprobe_iface) - offsetof(struct wprobe_iface, list));
124 INIT_LIST_HEAD(&s->list);
125 INIT_LIST_HEAD(&s->links);
126 setup_timer(&s->measure_timer, wprobe_measure_timer, (unsigned long) s);
128 s->val = kzalloc(sizeof(struct wprobe_value) * s->n_global_items, GFP_ATOMIC);
132 vsize = max(s->n_link_items, s->n_global_items);
133 s->query_val = kzalloc(sizeof(struct wprobe_value) * vsize, GFP_ATOMIC);
137 /* initialize defaults to be able to handle overflow,
138 * user space will need to handle this if it keeps an
139 * internal histogram */
141 s->scale_max = (1 << 31);
146 spin_lock_irqsave(&wprobe_lock, flags);
147 list_add_rcu(&s->list, &wprobe_if);
148 spin_unlock_irqrestore(&wprobe_lock, flags);
157 EXPORT_SYMBOL(wprobe_add_iface);
160 wprobe_remove_iface(struct wprobe_iface *s)
164 BUG_ON(!list_empty(&s->links));
166 del_timer_sync(&s->measure_timer);
167 spin_lock_irqsave(&wprobe_lock, flags);
168 list_del_rcu(&s->list);
169 spin_unlock_irqrestore(&wprobe_lock, flags);
171 /* wait for all queries to finish before freeing the
172 * temporary value storage buffer */
177 if (s->active_filter)
178 wprobe_free_filter(s->active_filter);
180 EXPORT_SYMBOL(wprobe_remove_iface);
182 static struct wprobe_iface *
183 wprobe_get_dev(struct nlattr *attr)
185 struct wprobe_iface *dev = NULL;
186 struct wprobe_iface *p;
193 name = nla_data(attr);
194 list_for_each_entry_rcu(p, &wprobe_if, list) {
196 if (strcmp(name, p->name) != 0)
207 wprobe_add_frame(struct wprobe_iface *dev, const struct wprobe_wlan_hdr *hdr, void *data, int len)
209 struct wprobe_wlan_hdr *new_hdr;
210 struct wprobe_filter *f;
216 f = rcu_dereference(dev->active_filter);
220 spin_lock_irqsave(&f->lock, flags);
223 skb->len = sizeof(struct wprobe_rtap_hdr);
224 skb->tail = skb->data + skb->len;
225 if (len + skb->len > WPROBE_MAX_FRAME_SIZE)
226 len = WPROBE_MAX_FRAME_SIZE - skb->len;
228 new_hdr = (struct wprobe_wlan_hdr *) skb_put(skb, f->hdrlen);
229 memcpy(new_hdr, hdr, sizeof(struct wprobe_wlan_hdr));
230 new_hdr->len = cpu_to_be16(new_hdr->len);
232 memcpy(skb_put(skb, len), data, len);
234 for(i = 0; i < f->n_groups; i++) {
235 struct wprobe_filter_group *fg = &f->groups[i];
239 for (j = 0; j < fg->n_items; j++) {
240 struct wprobe_filter_item *fi = fg->items[j];
242 if (!fi->hdr.n_items) {
246 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,38)
247 if (sk_run_filter(skb, fi->filter) == 0)
250 if (sk_run_filter(skb, fi->filter, fi->hdr.n_items) == 0)
257 if (!found && def >= 0) {
262 struct wprobe_filter_counter *c = &fg->counters[j];
264 if (hdr->type >= WPROBE_PKT_TX)
271 spin_unlock_irqrestore(&f->lock, flags);
276 EXPORT_SYMBOL(wprobe_add_frame);
279 wprobe_sync_data(struct wprobe_iface *dev, struct wprobe_link *l, bool query)
281 struct wprobe_value *val;
286 n = dev->n_link_items;
289 n = dev->n_global_items;
293 spin_lock_irqsave(&dev->lock, flags);
294 err = dev->sync_data(dev, l, val, !query);
299 memcpy(dev->query_val, val, sizeof(struct wprobe_value) * n);
301 wprobe_update_stats(dev, l);
303 spin_unlock_irqrestore(&dev->lock, flags);
306 EXPORT_SYMBOL(wprobe_sync_data);
309 wprobe_scale_stats(struct wprobe_iface *dev, const struct wprobe_item *item,
310 struct wprobe_value *val, int n)
312 u64 scale_ts = jiffies_64;
315 for (i = 0; i < n; i++) {
316 if (!(item[i].flags & WPROBE_F_KEEPSTAT))
319 if (val[i].n <= dev->scale_min)
322 /* FIXME: div_s64 seems to be very imprecise here, even when
323 * the values are scaled up */
324 val[i].s *= dev->scale_m;
325 val[i].s = div_s64(val[i].s, dev->scale_d);
327 val[i].ss *= dev->scale_m;
328 val[i].ss = div_s64(val[i].ss, dev->scale_d);
330 val[i].n = (val[i].n * dev->scale_m) / dev->scale_d;
331 val[i].scale_timestamp = scale_ts;
337 wprobe_update_stats(struct wprobe_iface *dev, struct wprobe_link *l)
339 const struct wprobe_item *item;
340 struct wprobe_value *val;
341 bool scale_stats = false;
345 n = dev->n_link_items;
346 item = dev->link_items;
349 n = dev->n_global_items;
350 item = dev->global_items;
354 /* process statistics */
355 for (i = 0; i < n; i++) {
362 if ((item[i].flags & WPROBE_F_KEEPSTAT) &&
363 (dev->scale_max > 0) && (val[i].n > dev->scale_max)) {
367 switch(item[i].type) {
398 val[i].pending = false;
401 wprobe_scale_stats(dev, item, val, n);
403 EXPORT_SYMBOL(wprobe_update_stats);
405 static const struct nla_policy wprobe_policy[WPROBE_ATTR_LAST+1] = {
406 [WPROBE_ATTR_INTERFACE] = { .type = NLA_NUL_STRING },
407 [WPROBE_ATTR_MAC] = { .type = NLA_STRING },
408 [WPROBE_ATTR_FLAGS] = { .type = NLA_U32 },
411 [WPROBE_ATTR_INTERVAL] = { .type = NLA_MSECS },
412 [WPROBE_ATTR_SAMPLES_MIN] = { .type = NLA_U32 },
413 [WPROBE_ATTR_SAMPLES_MAX] = { .type = NLA_U32 },
414 [WPROBE_ATTR_SAMPLES_SCALE_M] = { .type = NLA_U32 },
415 [WPROBE_ATTR_SAMPLES_SCALE_D] = { .type = NLA_U32 },
416 [WPROBE_ATTR_FILTER] = { .type = NLA_BINARY, .len = 32768 },
420 wprobe_check_ptr(struct list_head *list, struct list_head *ptr)
424 list_for_each_rcu(p, list) {
432 wprobe_send_item_value(struct sk_buff *msg, struct netlink_callback *cb,
433 struct wprobe_iface *dev, struct wprobe_link *l,
434 const struct wprobe_item *item,
437 struct genlmsghdr *hdr;
438 struct wprobe_value *val = dev->query_val;
439 u64 time = val[i].last - val[i].first;
441 hdr = genlmsg_put(msg, NETLINK_CB(cb->skb).pid, cb->nlh->nlmsg_seq,
442 &wprobe_fam, NLM_F_MULTI, WPROBE_CMD_GET_INFO);
444 NLA_PUT_U32(msg, WPROBE_ATTR_ID, i);
445 NLA_PUT_U32(msg, WPROBE_ATTR_FLAGS, flags);
446 NLA_PUT_U8(msg, WPROBE_ATTR_TYPE, item[i].type);
447 NLA_PUT_U64(msg, WPROBE_ATTR_DURATION, time);
449 switch(item[i].type) {
452 NLA_PUT_U8(msg, item[i].type, val[i].U8);
456 NLA_PUT_U16(msg, item[i].type, val[i].U16);
460 NLA_PUT_U32(msg, item[i].type, val[i].U32);
464 NLA_PUT_U64(msg, item[i].type, val[i].U64);
466 case WPROBE_VAL_STRING:
468 NLA_PUT_STRING(msg, item[i].type, val[i].STRING);
470 NLA_PUT_STRING(msg, item[i].type, "");
471 /* bypass avg/stdev */
474 /* skip unknown values */
477 if (item[i].flags & WPROBE_F_KEEPSTAT) {
478 NLA_PUT_U64(msg, WPROBE_VAL_SUM, val[i].s);
479 NLA_PUT_U64(msg, WPROBE_VAL_SUM_SQ, val[i].ss);
480 NLA_PUT_U32(msg, WPROBE_VAL_SAMPLES, (u32) val[i].n);
481 NLA_PUT_MSECS(msg, WPROBE_VAL_SCALE_TIME, val[i].scale_timestamp);
484 genlmsg_end(msg, hdr);
488 genlmsg_cancel(msg, hdr);
493 wprobe_send_item_info(struct sk_buff *msg, struct netlink_callback *cb,
494 struct wprobe_iface *dev,
495 const struct wprobe_item *item, int i)
497 struct genlmsghdr *hdr;
499 hdr = genlmsg_put(msg, NETLINK_CB(cb->skb).pid, cb->nlh->nlmsg_seq,
500 &wprobe_fam, NLM_F_MULTI, WPROBE_CMD_GET_LIST);
502 if ((i == 0) && (dev->addr != NULL))
503 NLA_PUT(msg, WPROBE_ATTR_MAC, 6, dev->addr);
504 NLA_PUT_U32(msg, WPROBE_ATTR_ID, (u32) i);
505 NLA_PUT_STRING(msg, WPROBE_ATTR_NAME, item[i].name);
506 NLA_PUT_U8(msg, WPROBE_ATTR_TYPE, item[i].type);
507 NLA_PUT_U32(msg, WPROBE_ATTR_FLAGS, item[i].flags);
508 genlmsg_end(msg, hdr);
512 genlmsg_cancel(msg, hdr);
517 static struct wprobe_link *
518 wprobe_find_link(struct wprobe_iface *dev, const char *mac)
520 struct wprobe_link *l;
522 list_for_each_entry_rcu(l, &dev->links, list) {
523 if (!memcmp(l->addr, mac, 6))
530 wprobe_dump_filter_group(struct sk_buff *msg, struct wprobe_filter_group *fg, struct netlink_callback *cb)
532 struct genlmsghdr *hdr;
533 struct nlattr *group, *item;
536 hdr = genlmsg_put(msg, NETLINK_CB(cb->skb).pid, cb->nlh->nlmsg_seq,
537 &wprobe_fam, NLM_F_MULTI, WPROBE_CMD_GET_FILTER);
541 NLA_PUT_STRING(msg, WPROBE_ATTR_NAME, fg->name);
542 group = nla_nest_start(msg, WPROBE_ATTR_FILTER_GROUP);
543 for (i = 0; i < fg->n_items; i++) {
544 struct wprobe_filter_item *fi = fg->items[i];
545 struct wprobe_filter_counter *fc = &fg->counters[i];
547 item = nla_nest_start(msg, WPROBE_ATTR_FILTER_GROUP);
548 NLA_PUT_STRING(msg, WPROBE_ATTR_NAME, fi->hdr.name);
549 NLA_PUT_U64(msg, WPROBE_ATTR_RXCOUNT, fc->rx);
550 NLA_PUT_U64(msg, WPROBE_ATTR_TXCOUNT, fc->tx);
551 nla_nest_end(msg, item);
554 nla_nest_end(msg, group);
555 genlmsg_end(msg, hdr);
559 genlmsg_cancel(msg, hdr);
564 wprobe_dump_filters(struct sk_buff *skb, struct netlink_callback *cb)
566 struct wprobe_iface *dev = (struct wprobe_iface *)cb->args[0];
567 struct wprobe_filter *f;
572 err = nlmsg_parse(cb->nlh, GENL_HDRLEN + wprobe_fam.hdrsize,
573 wprobe_fam.attrbuf, wprobe_fam.maxattr, wprobe_policy);
577 dev = wprobe_get_dev(wprobe_fam.attrbuf[WPROBE_ATTR_INTERFACE]);
583 cb->args[0] = (long) dev;
586 if (!wprobe_check_ptr(&wprobe_if, &dev->list)) {
593 f = rcu_dereference(dev->active_filter);
597 for (i = cb->args[1]; i < f->n_groups; i++) {
598 if (unlikely(!wprobe_dump_filter_group(skb, &f->groups[i], cb)))
610 wprobe_dump_link(struct sk_buff *msg, struct wprobe_link *l, struct netlink_callback *cb)
612 struct genlmsghdr *hdr;
614 hdr = genlmsg_put(msg, NETLINK_CB(cb->skb).pid, cb->nlh->nlmsg_seq,
615 &wprobe_fam, NLM_F_MULTI, WPROBE_CMD_GET_LINKS);
619 NLA_PUT(msg, WPROBE_ATTR_MAC, 6, l->addr);
620 genlmsg_end(msg, hdr);
624 genlmsg_cancel(msg, hdr);
629 wprobe_dump_links(struct sk_buff *skb, struct netlink_callback *cb)
631 struct wprobe_iface *dev = (struct wprobe_iface *)cb->args[0];
632 struct wprobe_link *l;
637 err = nlmsg_parse(cb->nlh, GENL_HDRLEN + wprobe_fam.hdrsize,
638 wprobe_fam.attrbuf, wprobe_fam.maxattr, wprobe_policy);
642 dev = wprobe_get_dev(wprobe_fam.attrbuf[WPROBE_ATTR_INTERFACE]);
648 cb->args[0] = (long) dev;
650 if (!wprobe_check_ptr(&wprobe_if, &dev->list)) {
657 list_for_each_entry_rcu(l, &dev->links, list) {
661 if (unlikely(!wprobe_dump_link(skb, l, cb)))
673 #define WPROBE_F_LINK (1 << 31) /* for internal use */
675 wprobe_dump_info(struct sk_buff *skb, struct netlink_callback *cb)
677 struct wprobe_iface *dev = (struct wprobe_iface *)cb->args[0];
678 struct wprobe_link *l = (struct wprobe_link *)cb->args[1];
679 struct wprobe_value *val;
680 const struct wprobe_item *item;
681 struct genlmsghdr *hdr;
683 int cmd, n, i = cb->args[3];
684 u32 vflags = cb->args[2];
687 hdr = (struct genlmsghdr *)nlmsg_data(cb->nlh);
690 /* since the attribute value list might be too big for a single netlink
691 * message, the device, link and offset get stored in the netlink callback.
692 * if this is the first request, we need to do the full lookup for the device.
694 * access to the device and link structure is synchronized through rcu.
698 err = nlmsg_parse(cb->nlh, GENL_HDRLEN + wprobe_fam.hdrsize,
699 wprobe_fam.attrbuf, wprobe_fam.maxattr, wprobe_policy);
704 dev = wprobe_get_dev(wprobe_fam.attrbuf[WPROBE_ATTR_INTERFACE]);
708 if (cmd == WPROBE_CMD_GET_INFO) {
709 if (wprobe_fam.attrbuf[WPROBE_ATTR_MAC]) {
710 l = wprobe_find_link(dev, nla_data(wprobe_fam.attrbuf[WPROBE_ATTR_MAC]));
718 item = dev->link_items;
719 n = dev->n_link_items;
722 item = dev->global_items;
723 n = dev->n_global_items;
727 /* sync data and move to temp storage for the query */
728 spin_lock_irqsave(&dev->lock, flags);
729 err = wprobe_sync_data(dev, l, true);
731 memcpy(dev->query_val, val, n * sizeof(struct wprobe_value));
732 spin_unlock_irqrestore(&dev->lock, flags);
738 if (wprobe_fam.attrbuf[WPROBE_ATTR_FLAGS])
739 vflags |= nla_get_u32(wprobe_fam.attrbuf[WPROBE_ATTR_FLAGS]);
741 if (wprobe_fam.attrbuf[WPROBE_ATTR_MAC])
742 vflags |= WPROBE_F_LINK;
744 cb->args[0] = (long) dev;
745 cb->args[1] = (long) l;
746 cb->args[2] = vflags;
749 /* when pulling pointers from the callback, validate them
750 * against the list using rcu to make sure that we won't
751 * dereference pointers to free'd memory after the last
754 if (!wprobe_check_ptr(&wprobe_if, &dev->list))
757 if (l && !wprobe_check_ptr(&dev->links, &l->list))
761 if (vflags & WPROBE_F_LINK) {
762 item = dev->link_items;
763 n = dev->n_link_items;
765 item = dev->global_items;
766 n = dev->n_global_items;
771 case WPROBE_CMD_GET_INFO:
773 if (!wprobe_send_item_value(skb, cb, dev, l, item, i, vflags))
778 case WPROBE_CMD_GET_LIST:
780 if (!wprobe_send_item_info(skb, cb, dev, item, i))
799 wprobe_update_auto_measurement(struct wprobe_iface *dev, u32 interval)
801 if (interval && (interval < WPROBE_MIN_INTERVAL))
804 if (!interval && dev->measure_interval)
805 del_timer_sync(&dev->measure_timer);
807 dev->measure_interval = interval;
811 /* kick of a new measurement immediately */
812 mod_timer(&dev->measure_timer, jiffies + 1);
818 wprobe_measure(struct sk_buff *skb, struct genl_info *info)
820 struct wprobe_iface *dev;
821 struct wprobe_link *l = NULL;
825 dev = wprobe_get_dev(info->attrs[WPROBE_ATTR_INTERFACE]);
829 if (info->attrs[WPROBE_ATTR_MAC]) {
830 l = wprobe_find_link(dev, nla_data(wprobe_fam.attrbuf[WPROBE_ATTR_MAC]));
835 err = wprobe_sync_data(dev, l, false);
843 wprobe_check_filter(void *data, int datalen, int gs)
845 struct wprobe_filter_item_hdr *hdr;
846 void *orig_data = data;
847 void *end = data + datalen;
848 int i, j, k, is, cur_is;
850 for (i = j = is = 0; i < gs; i++) {
852 data += sizeof(*hdr);
858 cur_is = be32_to_cpu(hdr->n_items);
859 hdr->n_items = cur_is;
861 for (j = 0; j < cur_is; j++) {
862 struct sock_filter *sf;
866 data += sizeof(*hdr);
871 n_items = be32_to_cpu(hdr->n_items);
872 hdr->n_items = n_items;
879 for (k = 0; k < n_items; k++) {
880 sf->code = be16_to_cpu(sf->code);
881 sf->k = be32_to_cpu(sf->k);
884 if (sk_chk_filter(data, n_items) != 0) {
885 printk("%s: filter check failed at group %d, item %d\n", __func__, i, j);
889 data += n_items * sizeof(struct sock_filter);
895 printk(KERN_ERR "%s: overrun during filter check at group %d, item %d, offset=%d, len=%d\n", __func__, i, j, (data - orig_data), datalen);
900 wprobe_free_filter(struct wprobe_filter *f)
915 wprobe_set_filter(struct wprobe_iface *dev, void *data, int len)
917 struct wprobe_filter_hdr *fhdr;
918 struct wprobe_rtap_hdr *rtap;
919 struct wprobe_filter *f;
920 int i, j, cur_is, is, gs;
922 if (len < sizeof(*fhdr))
926 data += sizeof(*fhdr);
927 len -= sizeof(*fhdr);
929 if (memcmp(fhdr->magic, "WPFF", 4) != 0) {
930 printk(KERN_ERR "%s: filter rejected (invalid magic)\n", __func__);
934 gs = be16_to_cpu(fhdr->n_groups);
935 is = wprobe_check_filter(data, len, gs);
939 f = kzalloc(sizeof(struct wprobe_filter) +
940 gs * sizeof(struct wprobe_filter_group), GFP_ATOMIC);
944 f->skb = alloc_skb(WPROBE_MAX_FRAME_SIZE, GFP_ATOMIC);
948 f->data = kmalloc(len, GFP_ATOMIC);
952 f->items = kzalloc(sizeof(struct wprobe_filter_item *) * is, GFP_ATOMIC);
956 f->counters = kzalloc(sizeof(struct wprobe_filter_counter) * is, GFP_ATOMIC);
960 spin_lock_init(&f->lock);
961 memcpy(f->data, data, len);
964 if (f->hdrlen < sizeof(struct wprobe_wlan_hdr))
965 f->hdrlen = sizeof(struct wprobe_wlan_hdr);
967 rtap = (struct wprobe_rtap_hdr *)skb_put(f->skb, sizeof(*rtap));
968 memset(rtap, 0, sizeof(*rtap));
969 rtap->len = cpu_to_le16(sizeof(struct wprobe_rtap_hdr) + f->hdrlen);
973 for (i = 0; i < gs; i++) {
974 struct wprobe_filter_item_hdr *hdr = data;
975 struct wprobe_filter_group *g = &f->groups[i];
977 data += sizeof(*hdr);
979 g->items = &f->items[cur_is];
980 g->counters = &f->counters[cur_is];
981 g->n_items = hdr->n_items;
983 for (j = 0; j < g->n_items; j++) {
985 f->items[cur_is++] = data;
986 data += sizeof(*hdr) + hdr->n_items * sizeof(struct sock_filter);
989 rcu_assign_pointer(dev->active_filter, f);
993 wprobe_free_filter(f);
998 wprobe_set_config(struct sk_buff *skb, struct genl_info *info)
1000 struct wprobe_iface *dev;
1001 unsigned long flags;
1003 u32 scale_min, scale_max;
1004 u32 scale_m, scale_d;
1005 struct nlattr *attr;
1006 struct wprobe_filter *filter_free = NULL;
1009 dev = wprobe_get_dev(info->attrs[WPROBE_ATTR_INTERFACE]);
1014 spin_lock_irqsave(&dev->lock, flags);
1015 if (info->attrs[WPROBE_ATTR_MAC]) {
1016 /* not supported yet */
1020 if (info->attrs[WPROBE_ATTR_FLAGS]) {
1021 u32 flags = nla_get_u32(info->attrs[WPROBE_ATTR_FLAGS]);
1023 if (flags & BIT(WPROBE_F_RESET)) {
1024 struct wprobe_link *l;
1026 memset(dev->val, 0, sizeof(struct wprobe_value) * dev->n_global_items);
1027 list_for_each_entry_rcu(l, &dev->links, list) {
1028 memset(l->val, 0, sizeof(struct wprobe_value) * dev->n_link_items);
1033 if (info->attrs[WPROBE_ATTR_SAMPLES_MIN] ||
1034 info->attrs[WPROBE_ATTR_SAMPLES_MAX]) {
1035 if ((attr = info->attrs[WPROBE_ATTR_SAMPLES_MIN]))
1036 scale_min = nla_get_u32(attr);
1038 scale_min = dev->scale_min;
1040 if ((attr = info->attrs[WPROBE_ATTR_SAMPLES_MAX]))
1041 scale_max = nla_get_u32(attr);
1043 scale_max = dev->scale_max;
1045 if ((!scale_min && !scale_max) ||
1046 (scale_min && scale_max && (scale_min < scale_max))) {
1047 dev->scale_min = scale_min;
1048 dev->scale_max = scale_max;
1054 if (info->attrs[WPROBE_ATTR_SAMPLES_SCALE_M] &&
1055 info->attrs[WPROBE_ATTR_SAMPLES_SCALE_D]) {
1057 scale_m = nla_get_u32(info->attrs[WPROBE_ATTR_SAMPLES_SCALE_M]);
1058 scale_d = nla_get_u32(info->attrs[WPROBE_ATTR_SAMPLES_SCALE_D]);
1060 if (!scale_d || (scale_m > scale_d))
1063 dev->scale_m = scale_m;
1064 dev->scale_d = scale_d;
1067 if ((attr = info->attrs[WPROBE_ATTR_FILTER])) {
1068 filter_free = rcu_dereference(dev->active_filter);
1069 rcu_assign_pointer(dev->active_filter, NULL);
1070 if (nla_len(attr) > 0)
1071 wprobe_set_filter(dev, nla_data(attr), nla_len(attr));
1075 if (info->attrs[WPROBE_ATTR_INTERVAL]) {
1076 /* change of measurement interval requested */
1077 err = wprobe_update_auto_measurement(dev,
1078 (u32) nla_get_u64(info->attrs[WPROBE_ATTR_INTERVAL]));
1082 spin_unlock_irqrestore(&dev->lock, flags);
1087 wprobe_free_filter(filter_free);
1092 static struct genl_ops wprobe_ops[] = {
1094 .cmd = WPROBE_CMD_GET_INFO,
1095 .dumpit = wprobe_dump_info,
1096 .policy = wprobe_policy,
1099 .cmd = WPROBE_CMD_GET_LIST,
1100 .dumpit = wprobe_dump_info,
1101 .policy = wprobe_policy,
1104 .cmd = WPROBE_CMD_MEASURE,
1105 .doit = wprobe_measure,
1106 .policy = wprobe_policy,
1109 .cmd = WPROBE_CMD_GET_LINKS,
1110 .dumpit = wprobe_dump_links,
1111 .policy = wprobe_policy,
1114 .cmd = WPROBE_CMD_CONFIG,
1115 .doit = wprobe_set_config,
1116 .policy = wprobe_policy,
1119 .cmd = WPROBE_CMD_GET_FILTER,
1120 .dumpit = wprobe_dump_filters,
1121 .policy = wprobe_policy,
1128 BUG_ON(!list_empty(&wprobe_if));
1129 genl_unregister_family(&wprobe_fam);
1138 spin_lock_init(&wprobe_lock);
1139 INIT_LIST_HEAD(&wprobe_if);
1141 err = genl_register_family(&wprobe_fam);
1145 for (i = 0; i < ARRAY_SIZE(wprobe_ops); i++) {
1146 err = genl_register_ops(&wprobe_fam, &wprobe_ops[i]);
1154 genl_unregister_family(&wprobe_fam);
1158 module_init(wprobe_init);
1159 module_exit(wprobe_exit);
1160 MODULE_LICENSE("GPL");