?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'v6v7' into devel
[linux/fpc-iii.git] / net / 802 / garp.c
blobc1df2dad8c6b58470a51d459bd2263989d1d96f4
1 /*
2 * IEEE 802.1D Generic Attribute Registration Protocol (GARP)
3 *
4 * Copyright (c) 2008 Patrick McHardy <kaber@trash.net>
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * version 2 as published by the Free Software Foundation.
9 */
10 #include <linux/kernel.h>
11 #include <linux/timer.h>
12 #include <linux/skbuff.h>
13 #include <linux/netdevice.h>
14 #include <linux/etherdevice.h>
15 #include <linux/rtnetlink.h>
16 #include <linux/llc.h>
17 #include <linux/slab.h>
18 #include <net/llc.h>
19 #include <net/llc_pdu.h>
20 #include <net/garp.h>
21 #include <asm/unaligned.h>
22
23 static unsigned int garp_join_time __read_mostly = 200;
24 module_param(garp_join_time, uint, 0644);
25 MODULE_PARM_DESC(garp_join_time, "Join time in ms (default 200ms)");
26 MODULE_LICENSE("GPL");
27
28 static const struct garp_state_trans {
29 u8 state;
30 u8 action;
31 } garp_applicant_state_table[GARP_APPLICANT_MAX + 1][GARP_EVENT_MAX + 1] = {
32 [GARP_APPLICANT_VA] = {
33 [GARP_EVENT_TRANSMIT_PDU] = { .state = GARP_APPLICANT_AA,
34 .action = GARP_ACTION_S_JOIN_IN },
35 [GARP_EVENT_R_JOIN_IN] = { .state = GARP_APPLICANT_AA },
36 [GARP_EVENT_R_JOIN_EMPTY] = { .state = GARP_APPLICANT_VA },
37 [GARP_EVENT_R_EMPTY] = { .state = GARP_APPLICANT_VA },
38 [GARP_EVENT_R_LEAVE_IN] = { .state = GARP_APPLICANT_VA },
39 [GARP_EVENT_R_LEAVE_EMPTY] = { .state = GARP_APPLICANT_VP },
40 [GARP_EVENT_REQ_JOIN] = { .state = GARP_APPLICANT_INVALID },
41 [GARP_EVENT_REQ_LEAVE] = { .state = GARP_APPLICANT_LA },
42 },
43 [GARP_APPLICANT_AA] = {
44 [GARP_EVENT_TRANSMIT_PDU] = { .state = GARP_APPLICANT_QA,
45 .action = GARP_ACTION_S_JOIN_IN },
46 [GARP_EVENT_R_JOIN_IN] = { .state = GARP_APPLICANT_QA },
47 [GARP_EVENT_R_JOIN_EMPTY] = { .state = GARP_APPLICANT_VA },
48 [GARP_EVENT_R_EMPTY] = { .state = GARP_APPLICANT_VA },
49 [GARP_EVENT_R_LEAVE_IN] = { .state = GARP_APPLICANT_VA },
50 [GARP_EVENT_R_LEAVE_EMPTY] = { .state = GARP_APPLICANT_VP },
51 [GARP_EVENT_REQ_JOIN] = { .state = GARP_APPLICANT_INVALID },
52 [GARP_EVENT_REQ_LEAVE] = { .state = GARP_APPLICANT_LA },
53 },
54 [GARP_APPLICANT_QA] = {
55 [GARP_EVENT_TRANSMIT_PDU] = { .state = GARP_APPLICANT_INVALID },
56 [GARP_EVENT_R_JOIN_IN] = { .state = GARP_APPLICANT_QA },
57 [GARP_EVENT_R_JOIN_EMPTY] = { .state = GARP_APPLICANT_VA },
58 [GARP_EVENT_R_EMPTY] = { .state = GARP_APPLICANT_VA },
59 [GARP_EVENT_R_LEAVE_IN] = { .state = GARP_APPLICANT_VP },
60 [GARP_EVENT_R_LEAVE_EMPTY] = { .state = GARP_APPLICANT_VP },
61 [GARP_EVENT_REQ_JOIN] = { .state = GARP_APPLICANT_INVALID },
62 [GARP_EVENT_REQ_LEAVE] = { .state = GARP_APPLICANT_LA },
63 },
64 [GARP_APPLICANT_LA] = {
65 [GARP_EVENT_TRANSMIT_PDU] = { .state = GARP_APPLICANT_VO,
66 .action = GARP_ACTION_S_LEAVE_EMPTY },
67 [GARP_EVENT_R_JOIN_IN] = { .state = GARP_APPLICANT_LA },
68 [GARP_EVENT_R_JOIN_EMPTY] = { .state = GARP_APPLICANT_VO },
69 [GARP_EVENT_R_EMPTY] = { .state = GARP_APPLICANT_LA },
70 [GARP_EVENT_R_LEAVE_IN] = { .state = GARP_APPLICANT_LA },
71 [GARP_EVENT_R_LEAVE_EMPTY] = { .state = GARP_APPLICANT_VO },
72 [GARP_EVENT_REQ_JOIN] = { .state = GARP_APPLICANT_VA },
73 [GARP_EVENT_REQ_LEAVE] = { .state = GARP_APPLICANT_INVALID },
74 },
75 [GARP_APPLICANT_VP] = {
76 [GARP_EVENT_TRANSMIT_PDU] = { .state = GARP_APPLICANT_AA,
77 .action = GARP_ACTION_S_JOIN_IN },
78 [GARP_EVENT_R_JOIN_IN] = { .state = GARP_APPLICANT_AP },
79 [GARP_EVENT_R_JOIN_EMPTY] = { .state = GARP_APPLICANT_VP },
80 [GARP_EVENT_R_EMPTY] = { .state = GARP_APPLICANT_VP },
81 [GARP_EVENT_R_LEAVE_IN] = { .state = GARP_APPLICANT_VP },
82 [GARP_EVENT_R_LEAVE_EMPTY] = { .state = GARP_APPLICANT_VP },
83 [GARP_EVENT_REQ_JOIN] = { .state = GARP_APPLICANT_INVALID },
84 [GARP_EVENT_REQ_LEAVE] = { .state = GARP_APPLICANT_VO },
85 },
86 [GARP_APPLICANT_AP] = {
87 [GARP_EVENT_TRANSMIT_PDU] = { .state = GARP_APPLICANT_QA,
88 .action = GARP_ACTION_S_JOIN_IN },
89 [GARP_EVENT_R_JOIN_IN] = { .state = GARP_APPLICANT_QP },
90 [GARP_EVENT_R_JOIN_EMPTY] = { .state = GARP_APPLICANT_VP },
91 [GARP_EVENT_R_EMPTY] = { .state = GARP_APPLICANT_VP },
92 [GARP_EVENT_R_LEAVE_IN] = { .state = GARP_APPLICANT_VP },
93 [GARP_EVENT_R_LEAVE_EMPTY] = { .state = GARP_APPLICANT_VP },
94 [GARP_EVENT_REQ_JOIN] = { .state = GARP_APPLICANT_INVALID },
95 [GARP_EVENT_REQ_LEAVE] = { .state = GARP_APPLICANT_AO },
96 },
97 [GARP_APPLICANT_QP] = {
98 [GARP_EVENT_TRANSMIT_PDU] = { .state = GARP_APPLICANT_INVALID },
99 [GARP_EVENT_R_JOIN_IN] = { .state = GARP_APPLICANT_QP },
100 [GARP_EVENT_R_JOIN_EMPTY] = { .state = GARP_APPLICANT_VP },
101 [GARP_EVENT_R_EMPTY] = { .state = GARP_APPLICANT_VP },
102 [GARP_EVENT_R_LEAVE_IN] = { .state = GARP_APPLICANT_VP },
103 [GARP_EVENT_R_LEAVE_EMPTY] = { .state = GARP_APPLICANT_VP },
104 [GARP_EVENT_REQ_JOIN] = { .state = GARP_APPLICANT_INVALID },
105 [GARP_EVENT_REQ_LEAVE] = { .state = GARP_APPLICANT_QO },
106 },
107 [GARP_APPLICANT_VO] = {
108 [GARP_EVENT_TRANSMIT_PDU] = { .state = GARP_APPLICANT_INVALID },
109 [GARP_EVENT_R_JOIN_IN] = { .state = GARP_APPLICANT_AO },
110 [GARP_EVENT_R_JOIN_EMPTY] = { .state = GARP_APPLICANT_VO },
111 [GARP_EVENT_R_EMPTY] = { .state = GARP_APPLICANT_VO },
112 [GARP_EVENT_R_LEAVE_IN] = { .state = GARP_APPLICANT_VO },
113 [GARP_EVENT_R_LEAVE_EMPTY] = { .state = GARP_APPLICANT_VO },
114 [GARP_EVENT_REQ_JOIN] = { .state = GARP_APPLICANT_VP },
115 [GARP_EVENT_REQ_LEAVE] = { .state = GARP_APPLICANT_INVALID },
116 },
117 [GARP_APPLICANT_AO] = {
118 [GARP_EVENT_TRANSMIT_PDU] = { .state = GARP_APPLICANT_INVALID },
119 [GARP_EVENT_R_JOIN_IN] = { .state = GARP_APPLICANT_QO },
120 [GARP_EVENT_R_JOIN_EMPTY] = { .state = GARP_APPLICANT_VO },
121 [GARP_EVENT_R_EMPTY] = { .state = GARP_APPLICANT_VO },
122 [GARP_EVENT_R_LEAVE_IN] = { .state = GARP_APPLICANT_VO },
123 [GARP_EVENT_R_LEAVE_EMPTY] = { .state = GARP_APPLICANT_VO },
124 [GARP_EVENT_REQ_JOIN] = { .state = GARP_APPLICANT_AP },
125 [GARP_EVENT_REQ_LEAVE] = { .state = GARP_APPLICANT_INVALID },
126 },
127 [GARP_APPLICANT_QO] = {
128 [GARP_EVENT_TRANSMIT_PDU] = { .state = GARP_APPLICANT_INVALID },
129 [GARP_EVENT_R_JOIN_IN] = { .state = GARP_APPLICANT_QO },
130 [GARP_EVENT_R_JOIN_EMPTY] = { .state = GARP_APPLICANT_VO },
131 [GARP_EVENT_R_EMPTY] = { .state = GARP_APPLICANT_VO },
132 [GARP_EVENT_R_LEAVE_IN] = { .state = GARP_APPLICANT_VO },
133 [GARP_EVENT_R_LEAVE_EMPTY] = { .state = GARP_APPLICANT_VO },
134 [GARP_EVENT_REQ_JOIN] = { .state = GARP_APPLICANT_QP },
135 [GARP_EVENT_REQ_LEAVE] = { .state = GARP_APPLICANT_INVALID },
136 },
137 };
138
139 static int garp_attr_cmp(const struct garp_attr *attr,
140 const void *data, u8 len, u8 type)
141 {
142 if (attr->type != type)
143 return attr->type - type;
144 if (attr->dlen != len)
145 return attr->dlen - len;
146 return memcmp(attr->data, data, len);
147 }
148
149 static struct garp_attr *garp_attr_lookup(const struct garp_applicant *app,
150 const void *data, u8 len, u8 type)
151 {
152 struct rb_node *parent = app->gid.rb_node;
153 struct garp_attr *attr;
154 int d;
155
156 while (parent) {
157 attr = rb_entry(parent, struct garp_attr, node);
158 d = garp_attr_cmp(attr, data, len, type);
159 if (d < 0)
160 parent = parent->rb_left;
161 else if (d > 0)
162 parent = parent->rb_right;
163 else
164 return attr;
165 }
166 return NULL;
167 }
168
169 static void garp_attr_insert(struct garp_applicant *app, struct garp_attr *new)
170 {
171 struct rb_node *parent = NULL, **p = &app->gid.rb_node;
172 struct garp_attr *attr;
173 int d;
174
175 while (*p) {
176 parent = *p;
177 attr = rb_entry(parent, struct garp_attr, node);
178 d = garp_attr_cmp(attr, new->data, new->dlen, new->type);
179 if (d < 0)
180 p = &parent->rb_left;
181 else if (d > 0)
182 p = &parent->rb_right;
183 }
184 rb_link_node(&new->node, parent, p);
185 rb_insert_color(&new->node, &app->gid);
186 }
187
188 static struct garp_attr *garp_attr_create(struct garp_applicant *app,
189 const void *data, u8 len, u8 type)
190 {
191 struct garp_attr *attr;
192
193 attr = kmalloc(sizeof(*attr) + len, GFP_ATOMIC);
194 if (!attr)
195 return attr;
196 attr->state = GARP_APPLICANT_VO;
197 attr->type = type;
198 attr->dlen = len;
199 memcpy(attr->data, data, len);
200 garp_attr_insert(app, attr);
201 return attr;
202 }
203
204 static void garp_attr_destroy(struct garp_applicant *app, struct garp_attr *attr)
205 {
206 rb_erase(&attr->node, &app->gid);
207 kfree(attr);
208 }
209
210 static int garp_pdu_init(struct garp_applicant *app)
211 {
212 struct sk_buff *skb;
213 struct garp_pdu_hdr *gp;
214
215 #define LLC_RESERVE sizeof(struct llc_pdu_un)
216 skb = alloc_skb(app->dev->mtu + LL_RESERVED_SPACE(app->dev),
217 GFP_ATOMIC);
218 if (!skb)
219 return -ENOMEM;
220
221 skb->dev = app->dev;
222 skb->protocol = htons(ETH_P_802_2);
223 skb_reserve(skb, LL_RESERVED_SPACE(app->dev) + LLC_RESERVE);
224
225 gp = (struct garp_pdu_hdr *)__skb_put(skb, sizeof(*gp));
226 put_unaligned(htons(GARP_PROTOCOL_ID), &gp->protocol);
227
228 app->pdu = skb;
229 return 0;
230 }
231
232 static int garp_pdu_append_end_mark(struct garp_applicant *app)
233 {
234 if (skb_tailroom(app->pdu) < sizeof(u8))
235 return -1;
236 *(u8 *)__skb_put(app->pdu, sizeof(u8)) = GARP_END_MARK;
237 return 0;
238 }
239
240 static void garp_pdu_queue(struct garp_applicant *app)
241 {
242 if (!app->pdu)
243 return;
244
245 garp_pdu_append_end_mark(app);
246 garp_pdu_append_end_mark(app);
247
248 llc_pdu_header_init(app->pdu, LLC_PDU_TYPE_U, LLC_SAP_BSPAN,
249 LLC_SAP_BSPAN, LLC_PDU_CMD);
250 llc_pdu_init_as_ui_cmd(app->pdu);
251 llc_mac_hdr_init(app->pdu, app->dev->dev_addr,
252 app->app->proto.group_address);
253
254 skb_queue_tail(&app->queue, app->pdu);
255 app->pdu = NULL;
256 }
257
258 static void garp_queue_xmit(struct garp_applicant *app)
259 {
260 struct sk_buff *skb;
261
262 while ((skb = skb_dequeue(&app->queue)))
263 dev_queue_xmit(skb);
264 }
265
266 static int garp_pdu_append_msg(struct garp_applicant *app, u8 attrtype)
267 {
268 struct garp_msg_hdr *gm;
269
270 if (skb_tailroom(app->pdu) < sizeof(*gm))
271 return -1;
272 gm = (struct garp_msg_hdr *)__skb_put(app->pdu, sizeof(*gm));
273 gm->attrtype = attrtype;
274 garp_cb(app->pdu)->cur_type = attrtype;
275 return 0;
276 }
277
278 static int garp_pdu_append_attr(struct garp_applicant *app,
279 const struct garp_attr *attr,
280 enum garp_attr_event event)
281 {
282 struct garp_attr_hdr *ga;
283 unsigned int len;
284 int err;
285 again:
286 if (!app->pdu) {
287 err = garp_pdu_init(app);
288 if (err < 0)
289 return err;
290 }
291
292 if (garp_cb(app->pdu)->cur_type != attr->type) {
293 if (garp_cb(app->pdu)->cur_type &&
294 garp_pdu_append_end_mark(app) < 0)
295 goto queue;
296 if (garp_pdu_append_msg(app, attr->type) < 0)
297 goto queue;
298 }
299
300 len = sizeof(*ga) + attr->dlen;
301 if (skb_tailroom(app->pdu) < len)
302 goto queue;
303 ga = (struct garp_attr_hdr *)__skb_put(app->pdu, len);
304 ga->len = len;
305 ga->event = event;
306 memcpy(ga->data, attr->data, attr->dlen);
307 return 0;
308
309 queue:
310 garp_pdu_queue(app);
311 goto again;
312 }
313
314 static void garp_attr_event(struct garp_applicant *app,
315 struct garp_attr *attr, enum garp_event event)
316 {
317 enum garp_applicant_state state;
318
319 state = garp_applicant_state_table[attr->state][event].state;
320 if (state == GARP_APPLICANT_INVALID)
321 return;
322
323 switch (garp_applicant_state_table[attr->state][event].action) {
324 case GARP_ACTION_NONE:
325 break;
326 case GARP_ACTION_S_JOIN_IN:
327 /* When appending the attribute fails, don't update state in
328 * order to retry on next TRANSMIT_PDU event. */
329 if (garp_pdu_append_attr(app, attr, GARP_JOIN_IN) < 0)
330 return;
331 break;
332 case GARP_ACTION_S_LEAVE_EMPTY:
333 garp_pdu_append_attr(app, attr, GARP_LEAVE_EMPTY);
334 /* As a pure applicant, sending a leave message implies that
335 * the attribute was unregistered and can be destroyed. */
336 garp_attr_destroy(app, attr);
337 return;
338 default:
339 WARN_ON(1);
340 }
341
342 attr->state = state;
343 }
344
345 int garp_request_join(const struct net_device *dev,
346 const struct garp_application *appl,
347 const void *data, u8 len, u8 type)
348 {
349 struct garp_port *port = rtnl_dereference(dev->garp_port);
350 struct garp_applicant *app = rtnl_dereference(port->applicants[appl->type]);
351 struct garp_attr *attr;
352
353 spin_lock_bh(&app->lock);
354 attr = garp_attr_create(app, data, len, type);
355 if (!attr) {
356 spin_unlock_bh(&app->lock);
357 return -ENOMEM;
358 }
359 garp_attr_event(app, attr, GARP_EVENT_REQ_JOIN);
360 spin_unlock_bh(&app->lock);
361 return 0;
362 }
363 EXPORT_SYMBOL_GPL(garp_request_join);
364
365 void garp_request_leave(const struct net_device *dev,
366 const struct garp_application *appl,
367 const void *data, u8 len, u8 type)
368 {
369 struct garp_port *port = rtnl_dereference(dev->garp_port);
370 struct garp_applicant *app = rtnl_dereference(port->applicants[appl->type]);
371 struct garp_attr *attr;
372
373 spin_lock_bh(&app->lock);
374 attr = garp_attr_lookup(app, data, len, type);
375 if (!attr) {
376 spin_unlock_bh(&app->lock);
377 return;
378 }
379 garp_attr_event(app, attr, GARP_EVENT_REQ_LEAVE);
380 spin_unlock_bh(&app->lock);
381 }
382 EXPORT_SYMBOL_GPL(garp_request_leave);
383
384 static void garp_gid_event(struct garp_applicant *app, enum garp_event event)
385 {
386 struct rb_node *node, *next;
387 struct garp_attr *attr;
388
389 for (node = rb_first(&app->gid);
390 next = node ? rb_next(node) : NULL, node != NULL;
391 node = next) {
392 attr = rb_entry(node, struct garp_attr, node);
393 garp_attr_event(app, attr, event);
394 }
395 }
396
397 static void garp_join_timer_arm(struct garp_applicant *app)
398 {
399 unsigned long delay;
400
401 delay = (u64)msecs_to_jiffies(garp_join_time) * net_random() >> 32;
402 mod_timer(&app->join_timer, jiffies + delay);
403 }
404
405 static void garp_join_timer(unsigned long data)
406 {
407 struct garp_applicant *app = (struct garp_applicant *)data;
408
409 spin_lock(&app->lock);
410 garp_gid_event(app, GARP_EVENT_TRANSMIT_PDU);
411 garp_pdu_queue(app);
412 spin_unlock(&app->lock);
413
414 garp_queue_xmit(app);
415 garp_join_timer_arm(app);
416 }
417
418 static int garp_pdu_parse_end_mark(struct sk_buff *skb)
419 {
420 if (!pskb_may_pull(skb, sizeof(u8)))
421 return -1;
422 if (*skb->data == GARP_END_MARK) {
423 skb_pull(skb, sizeof(u8));
424 return -1;
425 }
426 return 0;
427 }
428
429 static int garp_pdu_parse_attr(struct garp_applicant *app, struct sk_buff *skb,
430 u8 attrtype)
431 {
432 const struct garp_attr_hdr *ga;
433 struct garp_attr *attr;
434 enum garp_event event;
435 unsigned int dlen;
436
437 if (!pskb_may_pull(skb, sizeof(*ga)))
438 return -1;
439 ga = (struct garp_attr_hdr *)skb->data;
440 if (ga->len < sizeof(*ga))
441 return -1;
442
443 if (!pskb_may_pull(skb, ga->len))
444 return -1;
445 skb_pull(skb, ga->len);
446 dlen = sizeof(*ga) - ga->len;
447
448 if (attrtype > app->app->maxattr)
449 return 0;
450
451 switch (ga->event) {
452 case GARP_LEAVE_ALL:
453 if (dlen != 0)
454 return -1;
455 garp_gid_event(app, GARP_EVENT_R_LEAVE_EMPTY);
456 return 0;
457 case GARP_JOIN_EMPTY:
458 event = GARP_EVENT_R_JOIN_EMPTY;
459 break;
460 case GARP_JOIN_IN:
461 event = GARP_EVENT_R_JOIN_IN;
462 break;
463 case GARP_LEAVE_EMPTY:
464 event = GARP_EVENT_R_LEAVE_EMPTY;
465 break;
466 case GARP_EMPTY:
467 event = GARP_EVENT_R_EMPTY;
468 break;
469 default:
470 return 0;
471 }
472
473 if (dlen == 0)
474 return -1;
475 attr = garp_attr_lookup(app, ga->data, dlen, attrtype);
476 if (attr == NULL)
477 return 0;
478 garp_attr_event(app, attr, event);
479 return 0;
480 }
481
482 static int garp_pdu_parse_msg(struct garp_applicant *app, struct sk_buff *skb)
483 {
484 const struct garp_msg_hdr *gm;
485
486 if (!pskb_may_pull(skb, sizeof(*gm)))
487 return -1;
488 gm = (struct garp_msg_hdr *)skb->data;
489 if (gm->attrtype == 0)
490 return -1;
491 skb_pull(skb, sizeof(*gm));
492
493 while (skb->len > 0) {
494 if (garp_pdu_parse_attr(app, skb, gm->attrtype) < 0)
495 return -1;
496 if (garp_pdu_parse_end_mark(skb) < 0)
497 break;
498 }
499 return 0;
500 }
501
502 static void garp_pdu_rcv(const struct stp_proto *proto, struct sk_buff *skb,
503 struct net_device *dev)
504 {
505 struct garp_application *appl = proto->data;
506 struct garp_port *port;
507 struct garp_applicant *app;
508 const struct garp_pdu_hdr *gp;
509
510 port = rcu_dereference(dev->garp_port);
511 if (!port)
512 goto err;
513 app = rcu_dereference(port->applicants[appl->type]);
514 if (!app)
515 goto err;
516
517 if (!pskb_may_pull(skb, sizeof(*gp)))
518 goto err;
519 gp = (struct garp_pdu_hdr *)skb->data;
520 if (get_unaligned(&gp->protocol) != htons(GARP_PROTOCOL_ID))
521 goto err;
522 skb_pull(skb, sizeof(*gp));
523
524 spin_lock(&app->lock);
525 while (skb->len > 0) {
526 if (garp_pdu_parse_msg(app, skb) < 0)
527 break;
528 if (garp_pdu_parse_end_mark(skb) < 0)
529 break;
530 }
531 spin_unlock(&app->lock);
532 err:
533 kfree_skb(skb);
534 }
535
536 static int garp_init_port(struct net_device *dev)
537 {
538 struct garp_port *port;
539
540 port = kzalloc(sizeof(*port), GFP_KERNEL);
541 if (!port)
542 return -ENOMEM;
543 rcu_assign_pointer(dev->garp_port, port);
544 return 0;
545 }
546
547 static void garp_release_port(struct net_device *dev)
548 {
549 struct garp_port *port = rtnl_dereference(dev->garp_port);
550 unsigned int i;
551
552 for (i = 0; i <= GARP_APPLICATION_MAX; i++) {
553 if (rtnl_dereference(port->applicants[i]))
554 return;
555 }
556 rcu_assign_pointer(dev->garp_port, NULL);
557 synchronize_rcu();
558 kfree(port);
559 }
560
561 int garp_init_applicant(struct net_device *dev, struct garp_application *appl)
562 {
563 struct garp_applicant *app;
564 int err;
565
566 ASSERT_RTNL();
567
568 if (!rtnl_dereference(dev->garp_port)) {
569 err = garp_init_port(dev);
570 if (err < 0)
571 goto err1;
572 }
573
574 err = -ENOMEM;
575 app = kzalloc(sizeof(*app), GFP_KERNEL);
576 if (!app)
577 goto err2;
578
579 err = dev_mc_add(dev, appl->proto.group_address);
580 if (err < 0)
581 goto err3;
582
583 app->dev = dev;
584 app->app = appl;
585 app->gid = RB_ROOT;
586 spin_lock_init(&app->lock);
587 skb_queue_head_init(&app->queue);
588 rcu_assign_pointer(dev->garp_port->applicants[appl->type], app);
589 setup_timer(&app->join_timer, garp_join_timer, (unsigned long)app);
590 garp_join_timer_arm(app);
591 return 0;
592
593 err3:
594 kfree(app);
595 err2:
596 garp_release_port(dev);
597 err1:
598 return err;
599 }
600 EXPORT_SYMBOL_GPL(garp_init_applicant);
601
602 void garp_uninit_applicant(struct net_device *dev, struct garp_application *appl)
603 {
604 struct garp_port *port = rtnl_dereference(dev->garp_port);
605 struct garp_applicant *app = rtnl_dereference(port->applicants[appl->type]);
606
607 ASSERT_RTNL();
608
609 rcu_assign_pointer(port->applicants[appl->type], NULL);
610 synchronize_rcu();
611
612 /* Delete timer and generate a final TRANSMIT_PDU event to flush out
613 * all pending messages before the applicant is gone. */
614 del_timer_sync(&app->join_timer);
615 garp_gid_event(app, GARP_EVENT_TRANSMIT_PDU);
616 garp_pdu_queue(app);
617 garp_queue_xmit(app);
618
619 dev_mc_del(dev, appl->proto.group_address);
620 kfree(app);
621 garp_release_port(dev);
622 }
623 EXPORT_SYMBOL_GPL(garp_uninit_applicant);
624
625 int garp_register_application(struct garp_application *appl)
626 {
627 appl->proto.rcv = garp_pdu_rcv;
628 appl->proto.data = appl;
629 return stp_proto_register(&appl->proto);
630 }
631 EXPORT_SYMBOL_GPL(garp_register_application);
632
633 void garp_unregister_application(struct garp_application *appl)
634 {
635 stp_proto_unregister(&appl->proto);
636 }
637 EXPORT_SYMBOL_GPL(garp_unregister_application);
Linux with added FPC-III support