2 * IEEE 802.1Q Multiple Registration Protocol (MRP)
4 * Copyright (c) 2012 Massachusetts Institute of Technology
6 * Adapted from code in net/802/garp.c
7 * Copyright (c) 2008 Patrick McHardy <kaber@trash.net>
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License
11 * version 2 as published by the Free Software Foundation.
13 #include <linux/kernel.h>
14 #include <linux/timer.h>
15 #include <linux/skbuff.h>
16 #include <linux/netdevice.h>
17 #include <linux/etherdevice.h>
18 #include <linux/rtnetlink.h>
19 #include <linux/slab.h>
20 #include <linux/module.h>
22 #include <asm/unaligned.h>
24 static unsigned int mrp_join_time __read_mostly = 200;
25 module_param(mrp_join_time, uint, 0644);
26 MODULE_PARM_DESC(mrp_join_time, "Join time in ms (default 200ms)");
28 static unsigned int mrp_periodic_time __read_mostly = 1000;
29 module_param(mrp_periodic_time, uint, 0644);
30 MODULE_PARM_DESC(mrp_periodic_time, "Periodic time in ms (default 1s)");
32 MODULE_LICENSE("GPL");
35 mrp_applicant_state_table[MRP_APPLICANT_MAX + 1][MRP_EVENT_MAX + 1] = {
36 [MRP_APPLICANT_VO] = {
37 [MRP_EVENT_NEW] = MRP_APPLICANT_VN,
38 [MRP_EVENT_JOIN] = MRP_APPLICANT_VP,
39 [MRP_EVENT_LV] = MRP_APPLICANT_VO,
40 [MRP_EVENT_TX] = MRP_APPLICANT_VO,
41 [MRP_EVENT_R_NEW] = MRP_APPLICANT_VO,
42 [MRP_EVENT_R_JOIN_IN] = MRP_APPLICANT_AO,
43 [MRP_EVENT_R_IN] = MRP_APPLICANT_VO,
44 [MRP_EVENT_R_JOIN_MT] = MRP_APPLICANT_VO,
45 [MRP_EVENT_R_MT] = MRP_APPLICANT_VO,
46 [MRP_EVENT_R_LV] = MRP_APPLICANT_VO,
47 [MRP_EVENT_R_LA] = MRP_APPLICANT_VO,
48 [MRP_EVENT_REDECLARE] = MRP_APPLICANT_VO,
49 [MRP_EVENT_PERIODIC] = MRP_APPLICANT_VO,
51 [MRP_APPLICANT_VP] = {
52 [MRP_EVENT_NEW] = MRP_APPLICANT_VN,
53 [MRP_EVENT_JOIN] = MRP_APPLICANT_VP,
54 [MRP_EVENT_LV] = MRP_APPLICANT_VO,
55 [MRP_EVENT_TX] = MRP_APPLICANT_AA,
56 [MRP_EVENT_R_NEW] = MRP_APPLICANT_VP,
57 [MRP_EVENT_R_JOIN_IN] = MRP_APPLICANT_AP,
58 [MRP_EVENT_R_IN] = MRP_APPLICANT_VP,
59 [MRP_EVENT_R_JOIN_MT] = MRP_APPLICANT_VP,
60 [MRP_EVENT_R_MT] = MRP_APPLICANT_VP,
61 [MRP_EVENT_R_LV] = MRP_APPLICANT_VP,
62 [MRP_EVENT_R_LA] = MRP_APPLICANT_VP,
63 [MRP_EVENT_REDECLARE] = MRP_APPLICANT_VP,
64 [MRP_EVENT_PERIODIC] = MRP_APPLICANT_VP,
66 [MRP_APPLICANT_VN] = {
67 [MRP_EVENT_NEW] = MRP_APPLICANT_VN,
68 [MRP_EVENT_JOIN] = MRP_APPLICANT_VN,
69 [MRP_EVENT_LV] = MRP_APPLICANT_LA,
70 [MRP_EVENT_TX] = MRP_APPLICANT_AN,
71 [MRP_EVENT_R_NEW] = MRP_APPLICANT_VN,
72 [MRP_EVENT_R_JOIN_IN] = MRP_APPLICANT_VN,
73 [MRP_EVENT_R_IN] = MRP_APPLICANT_VN,
74 [MRP_EVENT_R_JOIN_MT] = MRP_APPLICANT_VN,
75 [MRP_EVENT_R_MT] = MRP_APPLICANT_VN,
76 [MRP_EVENT_R_LV] = MRP_APPLICANT_VN,
77 [MRP_EVENT_R_LA] = MRP_APPLICANT_VN,
78 [MRP_EVENT_REDECLARE] = MRP_APPLICANT_VN,
79 [MRP_EVENT_PERIODIC] = MRP_APPLICANT_VN,
81 [MRP_APPLICANT_AN] = {
82 [MRP_EVENT_NEW] = MRP_APPLICANT_AN,
83 [MRP_EVENT_JOIN] = MRP_APPLICANT_AN,
84 [MRP_EVENT_LV] = MRP_APPLICANT_LA,
85 [MRP_EVENT_TX] = MRP_APPLICANT_QA,
86 [MRP_EVENT_R_NEW] = MRP_APPLICANT_AN,
87 [MRP_EVENT_R_JOIN_IN] = MRP_APPLICANT_AN,
88 [MRP_EVENT_R_IN] = MRP_APPLICANT_AN,
89 [MRP_EVENT_R_JOIN_MT] = MRP_APPLICANT_AN,
90 [MRP_EVENT_R_MT] = MRP_APPLICANT_AN,
91 [MRP_EVENT_R_LV] = MRP_APPLICANT_VN,
92 [MRP_EVENT_R_LA] = MRP_APPLICANT_VN,
93 [MRP_EVENT_REDECLARE] = MRP_APPLICANT_VN,
94 [MRP_EVENT_PERIODIC] = MRP_APPLICANT_AN,
96 [MRP_APPLICANT_AA] = {
97 [MRP_EVENT_NEW] = MRP_APPLICANT_VN,
98 [MRP_EVENT_JOIN] = MRP_APPLICANT_AA,
99 [MRP_EVENT_LV] = MRP_APPLICANT_LA,
100 [MRP_EVENT_TX] = MRP_APPLICANT_QA,
101 [MRP_EVENT_R_NEW] = MRP_APPLICANT_AA,
102 [MRP_EVENT_R_JOIN_IN] = MRP_APPLICANT_QA,
103 [MRP_EVENT_R_IN] = MRP_APPLICANT_AA,
104 [MRP_EVENT_R_JOIN_MT] = MRP_APPLICANT_AA,
105 [MRP_EVENT_R_MT] = MRP_APPLICANT_AA,
106 [MRP_EVENT_R_LV] = MRP_APPLICANT_VP,
107 [MRP_EVENT_R_LA] = MRP_APPLICANT_VP,
108 [MRP_EVENT_REDECLARE] = MRP_APPLICANT_VP,
109 [MRP_EVENT_PERIODIC] = MRP_APPLICANT_AA,
111 [MRP_APPLICANT_QA] = {
112 [MRP_EVENT_NEW] = MRP_APPLICANT_VN,
113 [MRP_EVENT_JOIN] = MRP_APPLICANT_QA,
114 [MRP_EVENT_LV] = MRP_APPLICANT_LA,
115 [MRP_EVENT_TX] = MRP_APPLICANT_QA,
116 [MRP_EVENT_R_NEW] = MRP_APPLICANT_QA,
117 [MRP_EVENT_R_JOIN_IN] = MRP_APPLICANT_QA,
118 [MRP_EVENT_R_IN] = MRP_APPLICANT_QA,
119 [MRP_EVENT_R_JOIN_MT] = MRP_APPLICANT_AA,
120 [MRP_EVENT_R_MT] = MRP_APPLICANT_AA,
121 [MRP_EVENT_R_LV] = MRP_APPLICANT_VP,
122 [MRP_EVENT_R_LA] = MRP_APPLICANT_VP,
123 [MRP_EVENT_REDECLARE] = MRP_APPLICANT_VP,
124 [MRP_EVENT_PERIODIC] = MRP_APPLICANT_AA,
126 [MRP_APPLICANT_LA] = {
127 [MRP_EVENT_NEW] = MRP_APPLICANT_VN,
128 [MRP_EVENT_JOIN] = MRP_APPLICANT_AA,
129 [MRP_EVENT_LV] = MRP_APPLICANT_LA,
130 [MRP_EVENT_TX] = MRP_APPLICANT_VO,
131 [MRP_EVENT_R_NEW] = MRP_APPLICANT_LA,
132 [MRP_EVENT_R_JOIN_IN] = MRP_APPLICANT_LA,
133 [MRP_EVENT_R_IN] = MRP_APPLICANT_LA,
134 [MRP_EVENT_R_JOIN_MT] = MRP_APPLICANT_LA,
135 [MRP_EVENT_R_MT] = MRP_APPLICANT_LA,
136 [MRP_EVENT_R_LV] = MRP_APPLICANT_LA,
137 [MRP_EVENT_R_LA] = MRP_APPLICANT_LA,
138 [MRP_EVENT_REDECLARE] = MRP_APPLICANT_LA,
139 [MRP_EVENT_PERIODIC] = MRP_APPLICANT_LA,
141 [MRP_APPLICANT_AO] = {
142 [MRP_EVENT_NEW] = MRP_APPLICANT_VN,
143 [MRP_EVENT_JOIN] = MRP_APPLICANT_AP,
144 [MRP_EVENT_LV] = MRP_APPLICANT_AO,
145 [MRP_EVENT_TX] = MRP_APPLICANT_AO,
146 [MRP_EVENT_R_NEW] = MRP_APPLICANT_AO,
147 [MRP_EVENT_R_JOIN_IN] = MRP_APPLICANT_QO,
148 [MRP_EVENT_R_IN] = MRP_APPLICANT_AO,
149 [MRP_EVENT_R_JOIN_MT] = MRP_APPLICANT_AO,
150 [MRP_EVENT_R_MT] = MRP_APPLICANT_AO,
151 [MRP_EVENT_R_LV] = MRP_APPLICANT_VO,
152 [MRP_EVENT_R_LA] = MRP_APPLICANT_VO,
153 [MRP_EVENT_REDECLARE] = MRP_APPLICANT_VO,
154 [MRP_EVENT_PERIODIC] = MRP_APPLICANT_AO,
156 [MRP_APPLICANT_QO] = {
157 [MRP_EVENT_NEW] = MRP_APPLICANT_VN,
158 [MRP_EVENT_JOIN] = MRP_APPLICANT_QP,
159 [MRP_EVENT_LV] = MRP_APPLICANT_QO,
160 [MRP_EVENT_TX] = MRP_APPLICANT_QO,
161 [MRP_EVENT_R_NEW] = MRP_APPLICANT_QO,
162 [MRP_EVENT_R_JOIN_IN] = MRP_APPLICANT_QO,
163 [MRP_EVENT_R_IN] = MRP_APPLICANT_QO,
164 [MRP_EVENT_R_JOIN_MT] = MRP_APPLICANT_AO,
165 [MRP_EVENT_R_MT] = MRP_APPLICANT_AO,
166 [MRP_EVENT_R_LV] = MRP_APPLICANT_VO,
167 [MRP_EVENT_R_LA] = MRP_APPLICANT_VO,
168 [MRP_EVENT_REDECLARE] = MRP_APPLICANT_VO,
169 [MRP_EVENT_PERIODIC] = MRP_APPLICANT_QO,
171 [MRP_APPLICANT_AP] = {
172 [MRP_EVENT_NEW] = MRP_APPLICANT_VN,
173 [MRP_EVENT_JOIN] = MRP_APPLICANT_AP,
174 [MRP_EVENT_LV] = MRP_APPLICANT_AO,
175 [MRP_EVENT_TX] = MRP_APPLICANT_QA,
176 [MRP_EVENT_R_NEW] = MRP_APPLICANT_AP,
177 [MRP_EVENT_R_JOIN_IN] = MRP_APPLICANT_QP,
178 [MRP_EVENT_R_IN] = MRP_APPLICANT_AP,
179 [MRP_EVENT_R_JOIN_MT] = MRP_APPLICANT_AP,
180 [MRP_EVENT_R_MT] = MRP_APPLICANT_AP,
181 [MRP_EVENT_R_LV] = MRP_APPLICANT_VP,
182 [MRP_EVENT_R_LA] = MRP_APPLICANT_VP,
183 [MRP_EVENT_REDECLARE] = MRP_APPLICANT_VP,
184 [MRP_EVENT_PERIODIC] = MRP_APPLICANT_AP,
186 [MRP_APPLICANT_QP] = {
187 [MRP_EVENT_NEW] = MRP_APPLICANT_VN,
188 [MRP_EVENT_JOIN] = MRP_APPLICANT_QP,
189 [MRP_EVENT_LV] = MRP_APPLICANT_QO,
190 [MRP_EVENT_TX] = MRP_APPLICANT_QP,
191 [MRP_EVENT_R_NEW] = MRP_APPLICANT_QP,
192 [MRP_EVENT_R_JOIN_IN] = MRP_APPLICANT_QP,
193 [MRP_EVENT_R_IN] = MRP_APPLICANT_QP,
194 [MRP_EVENT_R_JOIN_MT] = MRP_APPLICANT_AP,
195 [MRP_EVENT_R_MT] = MRP_APPLICANT_AP,
196 [MRP_EVENT_R_LV] = MRP_APPLICANT_VP,
197 [MRP_EVENT_R_LA] = MRP_APPLICANT_VP,
198 [MRP_EVENT_REDECLARE] = MRP_APPLICANT_VP,
199 [MRP_EVENT_PERIODIC] = MRP_APPLICANT_AP,
204 mrp_tx_action_table[MRP_APPLICANT_MAX + 1] = {
205 [MRP_APPLICANT_VO] = MRP_TX_ACTION_S_IN_OPTIONAL,
206 [MRP_APPLICANT_VP] = MRP_TX_ACTION_S_JOIN_IN,
207 [MRP_APPLICANT_VN] = MRP_TX_ACTION_S_NEW,
208 [MRP_APPLICANT_AN] = MRP_TX_ACTION_S_NEW,
209 [MRP_APPLICANT_AA] = MRP_TX_ACTION_S_JOIN_IN,
210 [MRP_APPLICANT_QA] = MRP_TX_ACTION_S_JOIN_IN_OPTIONAL,
211 [MRP_APPLICANT_LA] = MRP_TX_ACTION_S_LV,
212 [MRP_APPLICANT_AO] = MRP_TX_ACTION_S_IN_OPTIONAL,
213 [MRP_APPLICANT_QO] = MRP_TX_ACTION_S_IN_OPTIONAL,
214 [MRP_APPLICANT_AP] = MRP_TX_ACTION_S_JOIN_IN,
215 [MRP_APPLICANT_QP] = MRP_TX_ACTION_S_IN_OPTIONAL,
218 static void mrp_attrvalue_inc(void *value, u8 len)
222 /* Add 1 to the last byte. If it becomes zero,
223 * go to the previous byte and repeat.
225 while (len > 0 && !++v[--len])
229 static int mrp_attr_cmp(const struct mrp_attr *attr,
230 const void *value, u8 len, u8 type)
232 if (attr->type != type)
233 return attr->type - type;
234 if (attr->len != len)
235 return attr->len - len;
236 return memcmp(attr->value, value, len);
239 static struct mrp_attr *mrp_attr_lookup(const struct mrp_applicant *app,
240 const void *value, u8 len, u8 type)
242 struct rb_node *parent = app->mad.rb_node;
243 struct mrp_attr *attr;
247 attr = rb_entry(parent, struct mrp_attr, node);
248 d = mrp_attr_cmp(attr, value, len, type);
250 parent = parent->rb_left;
252 parent = parent->rb_right;
259 static struct mrp_attr *mrp_attr_create(struct mrp_applicant *app,
260 const void *value, u8 len, u8 type)
262 struct rb_node *parent = NULL, **p = &app->mad.rb_node;
263 struct mrp_attr *attr;
268 attr = rb_entry(parent, struct mrp_attr, node);
269 d = mrp_attr_cmp(attr, value, len, type);
271 p = &parent->rb_left;
273 p = &parent->rb_right;
275 /* The attribute already exists; re-use it. */
279 attr = kmalloc(sizeof(*attr) + len, GFP_ATOMIC);
282 attr->state = MRP_APPLICANT_VO;
285 memcpy(attr->value, value, len);
287 rb_link_node(&attr->node, parent, p);
288 rb_insert_color(&attr->node, &app->mad);
292 static void mrp_attr_destroy(struct mrp_applicant *app, struct mrp_attr *attr)
294 rb_erase(&attr->node, &app->mad);
298 static void mrp_attr_destroy_all(struct mrp_applicant *app)
300 struct rb_node *node, *next;
301 struct mrp_attr *attr;
303 for (node = rb_first(&app->mad);
304 next = node ? rb_next(node) : NULL, node != NULL;
306 attr = rb_entry(node, struct mrp_attr, node);
307 mrp_attr_destroy(app, attr);
311 static int mrp_pdu_init(struct mrp_applicant *app)
314 struct mrp_pdu_hdr *ph;
316 skb = alloc_skb(app->dev->mtu + LL_RESERVED_SPACE(app->dev),
322 skb->protocol = app->app->pkttype.type;
323 skb_reserve(skb, LL_RESERVED_SPACE(app->dev));
324 skb_reset_network_header(skb);
325 skb_reset_transport_header(skb);
327 ph = (struct mrp_pdu_hdr *)__skb_put(skb, sizeof(*ph));
328 ph->version = app->app->version;
334 static int mrp_pdu_append_end_mark(struct mrp_applicant *app)
338 if (skb_tailroom(app->pdu) < sizeof(*endmark))
340 endmark = (__be16 *)__skb_put(app->pdu, sizeof(*endmark));
341 put_unaligned(MRP_END_MARK, endmark);
345 static void mrp_pdu_queue(struct mrp_applicant *app)
350 if (mrp_cb(app->pdu)->mh)
351 mrp_pdu_append_end_mark(app);
352 mrp_pdu_append_end_mark(app);
354 dev_hard_header(app->pdu, app->dev, ntohs(app->app->pkttype.type),
355 app->app->group_address, app->dev->dev_addr,
358 skb_queue_tail(&app->queue, app->pdu);
362 static void mrp_queue_xmit(struct mrp_applicant *app)
366 while ((skb = skb_dequeue(&app->queue)))
370 static int mrp_pdu_append_msg_hdr(struct mrp_applicant *app,
371 u8 attrtype, u8 attrlen)
373 struct mrp_msg_hdr *mh;
375 if (mrp_cb(app->pdu)->mh) {
376 if (mrp_pdu_append_end_mark(app) < 0)
378 mrp_cb(app->pdu)->mh = NULL;
379 mrp_cb(app->pdu)->vah = NULL;
382 if (skb_tailroom(app->pdu) < sizeof(*mh))
384 mh = (struct mrp_msg_hdr *)__skb_put(app->pdu, sizeof(*mh));
385 mh->attrtype = attrtype;
386 mh->attrlen = attrlen;
387 mrp_cb(app->pdu)->mh = mh;
391 static int mrp_pdu_append_vecattr_hdr(struct mrp_applicant *app,
392 const void *firstattrvalue, u8 attrlen)
394 struct mrp_vecattr_hdr *vah;
396 if (skb_tailroom(app->pdu) < sizeof(*vah) + attrlen)
398 vah = (struct mrp_vecattr_hdr *)__skb_put(app->pdu,
399 sizeof(*vah) + attrlen);
400 put_unaligned(0, &vah->lenflags);
401 memcpy(vah->firstattrvalue, firstattrvalue, attrlen);
402 mrp_cb(app->pdu)->vah = vah;
403 memcpy(mrp_cb(app->pdu)->attrvalue, firstattrvalue, attrlen);
407 static int mrp_pdu_append_vecattr_event(struct mrp_applicant *app,
408 const struct mrp_attr *attr,
409 enum mrp_vecattr_event vaevent)
416 err = mrp_pdu_init(app);
421 /* If there is no Message header in the PDU, or the Message header is
422 * for a different attribute type, add an EndMark (if necessary) and a
423 * new Message header to the PDU.
425 if (!mrp_cb(app->pdu)->mh ||
426 mrp_cb(app->pdu)->mh->attrtype != attr->type ||
427 mrp_cb(app->pdu)->mh->attrlen != attr->len) {
428 if (mrp_pdu_append_msg_hdr(app, attr->type, attr->len) < 0)
432 /* If there is no VectorAttribute header for this Message in the PDU,
433 * or this attribute's value does not sequentially follow the previous
434 * attribute's value, add a new VectorAttribute header to the PDU.
436 if (!mrp_cb(app->pdu)->vah ||
437 memcmp(mrp_cb(app->pdu)->attrvalue, attr->value, attr->len)) {
438 if (mrp_pdu_append_vecattr_hdr(app, attr->value, attr->len) < 0)
442 len = be16_to_cpu(get_unaligned(&mrp_cb(app->pdu)->vah->lenflags));
445 /* Events are packed into Vectors in the PDU, three to a byte. Add a
446 * byte to the end of the Vector if necessary.
449 if (skb_tailroom(app->pdu) < sizeof(u8))
451 vaevents = (u8 *)__skb_put(app->pdu, sizeof(u8));
453 vaevents = (u8 *)(skb_tail_pointer(app->pdu) - sizeof(u8));
458 *vaevents = vaevent * (__MRP_VECATTR_EVENT_MAX *
459 __MRP_VECATTR_EVENT_MAX);
462 *vaevents += vaevent * __MRP_VECATTR_EVENT_MAX;
465 *vaevents += vaevent;
471 /* Increment the length of the VectorAttribute in the PDU, as well as
472 * the value of the next attribute that would continue its Vector.
474 put_unaligned(cpu_to_be16(++len), &mrp_cb(app->pdu)->vah->lenflags);
475 mrp_attrvalue_inc(mrp_cb(app->pdu)->attrvalue, attr->len);
484 static void mrp_attr_event(struct mrp_applicant *app,
485 struct mrp_attr *attr, enum mrp_event event)
487 enum mrp_applicant_state state;
489 state = mrp_applicant_state_table[attr->state][event];
490 if (state == MRP_APPLICANT_INVALID) {
495 if (event == MRP_EVENT_TX) {
496 /* When appending the attribute fails, don't update its state
497 * in order to retry at the next TX event.
500 switch (mrp_tx_action_table[attr->state]) {
501 case MRP_TX_ACTION_NONE:
502 case MRP_TX_ACTION_S_JOIN_IN_OPTIONAL:
503 case MRP_TX_ACTION_S_IN_OPTIONAL:
505 case MRP_TX_ACTION_S_NEW:
506 if (mrp_pdu_append_vecattr_event(
507 app, attr, MRP_VECATTR_EVENT_NEW) < 0)
510 case MRP_TX_ACTION_S_JOIN_IN:
511 if (mrp_pdu_append_vecattr_event(
512 app, attr, MRP_VECATTR_EVENT_JOIN_IN) < 0)
515 case MRP_TX_ACTION_S_LV:
516 if (mrp_pdu_append_vecattr_event(
517 app, attr, MRP_VECATTR_EVENT_LV) < 0)
519 /* As a pure applicant, sending a leave message
520 * implies that the attribute was unregistered and
523 mrp_attr_destroy(app, attr);
533 int mrp_request_join(const struct net_device *dev,
534 const struct mrp_application *appl,
535 const void *value, u8 len, u8 type)
537 struct mrp_port *port = rtnl_dereference(dev->mrp_port);
538 struct mrp_applicant *app = rtnl_dereference(
539 port->applicants[appl->type]);
540 struct mrp_attr *attr;
542 if (sizeof(struct mrp_skb_cb) + len >
543 FIELD_SIZEOF(struct sk_buff, cb))
546 spin_lock_bh(&app->lock);
547 attr = mrp_attr_create(app, value, len, type);
549 spin_unlock_bh(&app->lock);
552 mrp_attr_event(app, attr, MRP_EVENT_JOIN);
553 spin_unlock_bh(&app->lock);
556 EXPORT_SYMBOL_GPL(mrp_request_join);
558 void mrp_request_leave(const struct net_device *dev,
559 const struct mrp_application *appl,
560 const void *value, u8 len, u8 type)
562 struct mrp_port *port = rtnl_dereference(dev->mrp_port);
563 struct mrp_applicant *app = rtnl_dereference(
564 port->applicants[appl->type]);
565 struct mrp_attr *attr;
567 if (sizeof(struct mrp_skb_cb) + len >
568 FIELD_SIZEOF(struct sk_buff, cb))
571 spin_lock_bh(&app->lock);
572 attr = mrp_attr_lookup(app, value, len, type);
574 spin_unlock_bh(&app->lock);
577 mrp_attr_event(app, attr, MRP_EVENT_LV);
578 spin_unlock_bh(&app->lock);
580 EXPORT_SYMBOL_GPL(mrp_request_leave);
582 static void mrp_mad_event(struct mrp_applicant *app, enum mrp_event event)
584 struct rb_node *node, *next;
585 struct mrp_attr *attr;
587 for (node = rb_first(&app->mad);
588 next = node ? rb_next(node) : NULL, node != NULL;
590 attr = rb_entry(node, struct mrp_attr, node);
591 mrp_attr_event(app, attr, event);
595 static void mrp_join_timer_arm(struct mrp_applicant *app)
599 delay = (u64)msecs_to_jiffies(mrp_join_time) * prandom_u32() >> 32;
600 mod_timer(&app->join_timer, jiffies + delay);
603 static void mrp_join_timer(unsigned long data)
605 struct mrp_applicant *app = (struct mrp_applicant *)data;
607 spin_lock(&app->lock);
608 mrp_mad_event(app, MRP_EVENT_TX);
610 spin_unlock(&app->lock);
613 mrp_join_timer_arm(app);
616 static void mrp_periodic_timer_arm(struct mrp_applicant *app)
618 mod_timer(&app->periodic_timer,
619 jiffies + msecs_to_jiffies(mrp_periodic_time));
622 static void mrp_periodic_timer(unsigned long data)
624 struct mrp_applicant *app = (struct mrp_applicant *)data;
626 spin_lock(&app->lock);
627 mrp_mad_event(app, MRP_EVENT_PERIODIC);
629 spin_unlock(&app->lock);
631 mrp_periodic_timer_arm(app);
634 static int mrp_pdu_parse_end_mark(struct sk_buff *skb, int *offset)
638 if (skb_copy_bits(skb, *offset, &endmark, sizeof(endmark)) < 0)
640 if (endmark == MRP_END_MARK) {
641 *offset += sizeof(endmark);
647 static void mrp_pdu_parse_vecattr_event(struct mrp_applicant *app,
649 enum mrp_vecattr_event vaevent)
651 struct mrp_attr *attr;
652 enum mrp_event event;
654 attr = mrp_attr_lookup(app, mrp_cb(skb)->attrvalue,
655 mrp_cb(skb)->mh->attrlen,
656 mrp_cb(skb)->mh->attrtype);
661 case MRP_VECATTR_EVENT_NEW:
662 event = MRP_EVENT_R_NEW;
664 case MRP_VECATTR_EVENT_JOIN_IN:
665 event = MRP_EVENT_R_JOIN_IN;
667 case MRP_VECATTR_EVENT_IN:
668 event = MRP_EVENT_R_IN;
670 case MRP_VECATTR_EVENT_JOIN_MT:
671 event = MRP_EVENT_R_JOIN_MT;
673 case MRP_VECATTR_EVENT_MT:
674 event = MRP_EVENT_R_MT;
676 case MRP_VECATTR_EVENT_LV:
677 event = MRP_EVENT_R_LV;
683 mrp_attr_event(app, attr, event);
686 static int mrp_pdu_parse_vecattr(struct mrp_applicant *app,
687 struct sk_buff *skb, int *offset)
689 struct mrp_vecattr_hdr _vah;
691 u8 vaevents, vaevent;
693 mrp_cb(skb)->vah = skb_header_pointer(skb, *offset, sizeof(_vah),
695 if (!mrp_cb(skb)->vah)
697 *offset += sizeof(_vah);
699 if (get_unaligned(&mrp_cb(skb)->vah->lenflags) &
700 MRP_VECATTR_HDR_FLAG_LA)
701 mrp_mad_event(app, MRP_EVENT_R_LA);
702 valen = be16_to_cpu(get_unaligned(&mrp_cb(skb)->vah->lenflags) &
703 MRP_VECATTR_HDR_LEN_MASK);
705 /* The VectorAttribute structure in a PDU carries event information
706 * about one or more attributes having consecutive values. Only the
707 * value for the first attribute is contained in the structure. So
708 * we make a copy of that value, and then increment it each time we
709 * advance to the next event in its Vector.
711 if (sizeof(struct mrp_skb_cb) + mrp_cb(skb)->mh->attrlen >
712 FIELD_SIZEOF(struct sk_buff, cb))
714 if (skb_copy_bits(skb, *offset, mrp_cb(skb)->attrvalue,
715 mrp_cb(skb)->mh->attrlen) < 0)
717 *offset += mrp_cb(skb)->mh->attrlen;
719 /* In a VectorAttribute, the Vector contains events which are packed
720 * three to a byte. We process one byte of the Vector at a time.
723 if (skb_copy_bits(skb, *offset, &vaevents,
724 sizeof(vaevents)) < 0)
726 *offset += sizeof(vaevents);
728 /* Extract and process the first event. */
729 vaevent = vaevents / (__MRP_VECATTR_EVENT_MAX *
730 __MRP_VECATTR_EVENT_MAX);
731 if (vaevent >= __MRP_VECATTR_EVENT_MAX) {
732 /* The byte is malformed; stop processing. */
735 mrp_pdu_parse_vecattr_event(app, skb, vaevent);
737 /* If present, extract and process the second event. */
740 mrp_attrvalue_inc(mrp_cb(skb)->attrvalue,
741 mrp_cb(skb)->mh->attrlen);
742 vaevents %= (__MRP_VECATTR_EVENT_MAX *
743 __MRP_VECATTR_EVENT_MAX);
744 vaevent = vaevents / __MRP_VECATTR_EVENT_MAX;
745 mrp_pdu_parse_vecattr_event(app, skb, vaevent);
747 /* If present, extract and process the third event. */
750 mrp_attrvalue_inc(mrp_cb(skb)->attrvalue,
751 mrp_cb(skb)->mh->attrlen);
752 vaevents %= __MRP_VECATTR_EVENT_MAX;
754 mrp_pdu_parse_vecattr_event(app, skb, vaevent);
759 static int mrp_pdu_parse_msg(struct mrp_applicant *app, struct sk_buff *skb,
762 struct mrp_msg_hdr _mh;
764 mrp_cb(skb)->mh = skb_header_pointer(skb, *offset, sizeof(_mh), &_mh);
765 if (!mrp_cb(skb)->mh)
767 *offset += sizeof(_mh);
769 if (mrp_cb(skb)->mh->attrtype == 0 ||
770 mrp_cb(skb)->mh->attrtype > app->app->maxattr ||
771 mrp_cb(skb)->mh->attrlen == 0)
774 while (skb->len > *offset) {
775 if (mrp_pdu_parse_end_mark(skb, offset) < 0)
777 if (mrp_pdu_parse_vecattr(app, skb, offset) < 0)
783 static int mrp_rcv(struct sk_buff *skb, struct net_device *dev,
784 struct packet_type *pt, struct net_device *orig_dev)
786 struct mrp_application *appl = container_of(pt, struct mrp_application,
788 struct mrp_port *port;
789 struct mrp_applicant *app;
790 struct mrp_pdu_hdr _ph;
791 const struct mrp_pdu_hdr *ph;
792 int offset = skb_network_offset(skb);
794 /* If the interface is in promiscuous mode, drop the packet if
795 * it was unicast to another host.
797 if (unlikely(skb->pkt_type == PACKET_OTHERHOST))
799 skb = skb_share_check(skb, GFP_ATOMIC);
802 port = rcu_dereference(dev->mrp_port);
805 app = rcu_dereference(port->applicants[appl->type]);
809 ph = skb_header_pointer(skb, offset, sizeof(_ph), &_ph);
812 offset += sizeof(_ph);
814 if (ph->version != app->app->version)
817 spin_lock(&app->lock);
818 while (skb->len > offset) {
819 if (mrp_pdu_parse_end_mark(skb, &offset) < 0)
821 if (mrp_pdu_parse_msg(app, skb, &offset) < 0)
824 spin_unlock(&app->lock);
830 static int mrp_init_port(struct net_device *dev)
832 struct mrp_port *port;
834 port = kzalloc(sizeof(*port), GFP_KERNEL);
837 rcu_assign_pointer(dev->mrp_port, port);
841 static void mrp_release_port(struct net_device *dev)
843 struct mrp_port *port = rtnl_dereference(dev->mrp_port);
846 for (i = 0; i <= MRP_APPLICATION_MAX; i++) {
847 if (rtnl_dereference(port->applicants[i]))
850 RCU_INIT_POINTER(dev->mrp_port, NULL);
851 kfree_rcu(port, rcu);
854 int mrp_init_applicant(struct net_device *dev, struct mrp_application *appl)
856 struct mrp_applicant *app;
861 if (!rtnl_dereference(dev->mrp_port)) {
862 err = mrp_init_port(dev);
868 app = kzalloc(sizeof(*app), GFP_KERNEL);
872 err = dev_mc_add(dev, appl->group_address);
879 spin_lock_init(&app->lock);
880 skb_queue_head_init(&app->queue);
881 rcu_assign_pointer(dev->mrp_port->applicants[appl->type], app);
882 setup_timer(&app->join_timer, mrp_join_timer, (unsigned long)app);
883 mrp_join_timer_arm(app);
884 setup_timer(&app->periodic_timer, mrp_periodic_timer,
886 mrp_periodic_timer_arm(app);
892 mrp_release_port(dev);
896 EXPORT_SYMBOL_GPL(mrp_init_applicant);
898 void mrp_uninit_applicant(struct net_device *dev, struct mrp_application *appl)
900 struct mrp_port *port = rtnl_dereference(dev->mrp_port);
901 struct mrp_applicant *app = rtnl_dereference(
902 port->applicants[appl->type]);
906 RCU_INIT_POINTER(port->applicants[appl->type], NULL);
908 /* Delete timer and generate a final TX event to flush out
909 * all pending messages before the applicant is gone.
911 del_timer_sync(&app->join_timer);
912 del_timer_sync(&app->periodic_timer);
914 spin_lock_bh(&app->lock);
915 mrp_mad_event(app, MRP_EVENT_TX);
916 mrp_attr_destroy_all(app);
918 spin_unlock_bh(&app->lock);
922 dev_mc_del(dev, appl->group_address);
924 mrp_release_port(dev);
926 EXPORT_SYMBOL_GPL(mrp_uninit_applicant);
928 int mrp_register_application(struct mrp_application *appl)
930 appl->pkttype.func = mrp_rcv;
931 dev_add_pack(&appl->pkttype);
934 EXPORT_SYMBOL_GPL(mrp_register_application);
936 void mrp_unregister_application(struct mrp_application *appl)
938 dev_remove_pack(&appl->pkttype);
940 EXPORT_SYMBOL_GPL(mrp_unregister_application);