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

TOMOYO Linux Cross Reference
Linux/net/802/mrp.c

Version: ~ [ linux-5.6-rc7 ] ~ [ linux-5.5.11 ] ~ [ linux-5.4.27 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.112 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.174 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.217 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.217 ] ~ [ 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.82 ] ~ [ 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-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ 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  *      IEEE 802.1Q Multiple Registration Protocol (MRP)
  3  *
  4  *      Copyright (c) 2012 Massachusetts Institute of Technology
  5  *
  6  *      Adapted from code in net/802/garp.c
  7  *      Copyright (c) 2008 Patrick McHardy <kaber@trash.net>
  8  *
  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.
 12  */
 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>
 21 #include <net/mrp.h>
 22 #include <asm/unaligned.h>
 23 
 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)");
 27 
 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)");
 31 
 32 MODULE_LICENSE("GPL");
 33 
 34 static const u8
 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,
 50         },
 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,
 65         },
 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,
 80         },
 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,
 95         },
 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,
110         },
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,
125         },
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,
140         },
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,
155         },
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,
170         },
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,
185         },
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,
200         },
201 };
202 
203 static const u8
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,
216 };
217 
218 static void mrp_attrvalue_inc(void *value, u8 len)
219 {
220         u8 *v = (u8 *)value;
221 
222         /* Add 1 to the last byte. If it becomes zero,
223          * go to the previous byte and repeat.
224          */
225         while (len > 0 && !++v[--len])
226                 ;
227 }
228 
229 static int mrp_attr_cmp(const struct mrp_attr *attr,
230                          const void *value, u8 len, u8 type)
231 {
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);
237 }
238 
239 static struct mrp_attr *mrp_attr_lookup(const struct mrp_applicant *app,
240                                         const void *value, u8 len, u8 type)
241 {
242         struct rb_node *parent = app->mad.rb_node;
243         struct mrp_attr *attr;
244         int d;
245 
246         while (parent) {
247                 attr = rb_entry(parent, struct mrp_attr, node);
248                 d = mrp_attr_cmp(attr, value, len, type);
249                 if (d > 0)
250                         parent = parent->rb_left;
251                 else if (d < 0)
252                         parent = parent->rb_right;
253                 else
254                         return attr;
255         }
256         return NULL;
257 }
258 
259 static struct mrp_attr *mrp_attr_create(struct mrp_applicant *app,
260                                         const void *value, u8 len, u8 type)
261 {
262         struct rb_node *parent = NULL, **p = &app->mad.rb_node;
263         struct mrp_attr *attr;
264         int d;
265 
266         while (*p) {
267                 parent = *p;
268                 attr = rb_entry(parent, struct mrp_attr, node);
269                 d = mrp_attr_cmp(attr, value, len, type);
270                 if (d > 0)
271                         p = &parent->rb_left;
272                 else if (d < 0)
273                         p = &parent->rb_right;
274                 else {
275                         /* The attribute already exists; re-use it. */
276                         return attr;
277                 }
278         }
279         attr = kmalloc(sizeof(*attr) + len, GFP_ATOMIC);
280         if (!attr)
281                 return attr;
282         attr->state = MRP_APPLICANT_VO;
283         attr->type  = type;
284         attr->len   = len;
285         memcpy(attr->value, value, len);
286 
287         rb_link_node(&attr->node, parent, p);
288         rb_insert_color(&attr->node, &app->mad);
289         return attr;
290 }
291 
292 static void mrp_attr_destroy(struct mrp_applicant *app, struct mrp_attr *attr)
293 {
294         rb_erase(&attr->node, &app->mad);
295         kfree(attr);
296 }
297 
298 static int mrp_pdu_init(struct mrp_applicant *app)
299 {
300         struct sk_buff *skb;
301         struct mrp_pdu_hdr *ph;
302 
303         skb = alloc_skb(app->dev->mtu + LL_RESERVED_SPACE(app->dev),
304                         GFP_ATOMIC);
305         if (!skb)
306                 return -ENOMEM;
307 
308         skb->dev = app->dev;
309         skb->protocol = app->app->pkttype.type;
310         skb_reserve(skb, LL_RESERVED_SPACE(app->dev));
311         skb_reset_network_header(skb);
312         skb_reset_transport_header(skb);
313 
314         ph = (struct mrp_pdu_hdr *)__skb_put(skb, sizeof(*ph));
315         ph->version = app->app->version;
316 
317         app->pdu = skb;
318         return 0;
319 }
320 
321 static int mrp_pdu_append_end_mark(struct mrp_applicant *app)
322 {
323         __be16 *endmark;
324 
325         if (skb_tailroom(app->pdu) < sizeof(*endmark))
326                 return -1;
327         endmark = (__be16 *)__skb_put(app->pdu, sizeof(*endmark));
328         put_unaligned(MRP_END_MARK, endmark);
329         return 0;
330 }
331 
332 static void mrp_pdu_queue(struct mrp_applicant *app)
333 {
334         if (!app->pdu)
335                 return;
336 
337         if (mrp_cb(app->pdu)->mh)
338                 mrp_pdu_append_end_mark(app);
339         mrp_pdu_append_end_mark(app);
340 
341         dev_hard_header(app->pdu, app->dev, ntohs(app->app->pkttype.type),
342                         app->app->group_address, app->dev->dev_addr,
343                         app->pdu->len);
344 
345         skb_queue_tail(&app->queue, app->pdu);
346         app->pdu = NULL;
347 }
348 
349 static void mrp_queue_xmit(struct mrp_applicant *app)
350 {
351         struct sk_buff *skb;
352 
353         while ((skb = skb_dequeue(&app->queue)))
354                 dev_queue_xmit(skb);
355 }
356 
357 static int mrp_pdu_append_msg_hdr(struct mrp_applicant *app,
358                                   u8 attrtype, u8 attrlen)
359 {
360         struct mrp_msg_hdr *mh;
361 
362         if (mrp_cb(app->pdu)->mh) {
363                 if (mrp_pdu_append_end_mark(app) < 0)
364                         return -1;
365                 mrp_cb(app->pdu)->mh = NULL;
366                 mrp_cb(app->pdu)->vah = NULL;
367         }
368 
369         if (skb_tailroom(app->pdu) < sizeof(*mh))
370                 return -1;
371         mh = (struct mrp_msg_hdr *)__skb_put(app->pdu, sizeof(*mh));
372         mh->attrtype = attrtype;
373         mh->attrlen = attrlen;
374         mrp_cb(app->pdu)->mh = mh;
375         return 0;
376 }
377 
378 static int mrp_pdu_append_vecattr_hdr(struct mrp_applicant *app,
379                                       const void *firstattrvalue, u8 attrlen)
380 {
381         struct mrp_vecattr_hdr *vah;
382 
383         if (skb_tailroom(app->pdu) < sizeof(*vah) + attrlen)
384                 return -1;
385         vah = (struct mrp_vecattr_hdr *)__skb_put(app->pdu,
386                                                   sizeof(*vah) + attrlen);
387         put_unaligned(0, &vah->lenflags);
388         memcpy(vah->firstattrvalue, firstattrvalue, attrlen);
389         mrp_cb(app->pdu)->vah = vah;
390         memcpy(mrp_cb(app->pdu)->attrvalue, firstattrvalue, attrlen);
391         return 0;
392 }
393 
394 static int mrp_pdu_append_vecattr_event(struct mrp_applicant *app,
395                                         const struct mrp_attr *attr,
396                                         enum mrp_vecattr_event vaevent)
397 {
398         u16 len, pos;
399         u8 *vaevents;
400         int err;
401 again:
402         if (!app->pdu) {
403                 err = mrp_pdu_init(app);
404                 if (err < 0)
405                         return err;
406         }
407 
408         /* If there is no Message header in the PDU, or the Message header is
409          * for a different attribute type, add an EndMark (if necessary) and a
410          * new Message header to the PDU.
411          */
412         if (!mrp_cb(app->pdu)->mh ||
413             mrp_cb(app->pdu)->mh->attrtype != attr->type ||
414             mrp_cb(app->pdu)->mh->attrlen != attr->len) {
415                 if (mrp_pdu_append_msg_hdr(app, attr->type, attr->len) < 0)
416                         goto queue;
417         }
418 
419         /* If there is no VectorAttribute header for this Message in the PDU,
420          * or this attribute's value does not sequentially follow the previous
421          * attribute's value, add a new VectorAttribute header to the PDU.
422          */
423         if (!mrp_cb(app->pdu)->vah ||
424             memcmp(mrp_cb(app->pdu)->attrvalue, attr->value, attr->len)) {
425                 if (mrp_pdu_append_vecattr_hdr(app, attr->value, attr->len) < 0)
426                         goto queue;
427         }
428 
429         len = be16_to_cpu(get_unaligned(&mrp_cb(app->pdu)->vah->lenflags));
430         pos = len % 3;
431 
432         /* Events are packed into Vectors in the PDU, three to a byte. Add a
433          * byte to the end of the Vector if necessary.
434          */
435         if (!pos) {
436                 if (skb_tailroom(app->pdu) < sizeof(u8))
437                         goto queue;
438                 vaevents = (u8 *)__skb_put(app->pdu, sizeof(u8));
439         } else {
440                 vaevents = (u8 *)(skb_tail_pointer(app->pdu) - sizeof(u8));
441         }
442 
443         switch (pos) {
444         case 0:
445                 *vaevents = vaevent * (__MRP_VECATTR_EVENT_MAX *
446                                        __MRP_VECATTR_EVENT_MAX);
447                 break;
448         case 1:
449                 *vaevents += vaevent * __MRP_VECATTR_EVENT_MAX;
450                 break;
451         case 2:
452                 *vaevents += vaevent;
453                 break;
454         default:
455                 WARN_ON(1);
456         }
457 
458         /* Increment the length of the VectorAttribute in the PDU, as well as
459          * the value of the next attribute that would continue its Vector.
460          */
461         put_unaligned(cpu_to_be16(++len), &mrp_cb(app->pdu)->vah->lenflags);
462         mrp_attrvalue_inc(mrp_cb(app->pdu)->attrvalue, attr->len);
463 
464         return 0;
465 
466 queue:
467         mrp_pdu_queue(app);
468         goto again;
469 }
470 
471 static void mrp_attr_event(struct mrp_applicant *app,
472                            struct mrp_attr *attr, enum mrp_event event)
473 {
474         enum mrp_applicant_state state;
475 
476         state = mrp_applicant_state_table[attr->state][event];
477         if (state == MRP_APPLICANT_INVALID) {
478                 WARN_ON(1);
479                 return;
480         }
481 
482         if (event == MRP_EVENT_TX) {
483                 /* When appending the attribute fails, don't update its state
484                  * in order to retry at the next TX event.
485                  */
486 
487                 switch (mrp_tx_action_table[attr->state]) {
488                 case MRP_TX_ACTION_NONE:
489                 case MRP_TX_ACTION_S_JOIN_IN_OPTIONAL:
490                 case MRP_TX_ACTION_S_IN_OPTIONAL:
491                         break;
492                 case MRP_TX_ACTION_S_NEW:
493                         if (mrp_pdu_append_vecattr_event(
494                                     app, attr, MRP_VECATTR_EVENT_NEW) < 0)
495                                 return;
496                         break;
497                 case MRP_TX_ACTION_S_JOIN_IN:
498                         if (mrp_pdu_append_vecattr_event(
499                                     app, attr, MRP_VECATTR_EVENT_JOIN_IN) < 0)
500                                 return;
501                         break;
502                 case MRP_TX_ACTION_S_LV:
503                         if (mrp_pdu_append_vecattr_event(
504                                     app, attr, MRP_VECATTR_EVENT_LV) < 0)
505                                 return;
506                         /* As a pure applicant, sending a leave message
507                          * implies that the attribute was unregistered and
508                          * can be destroyed.
509                          */
510                         mrp_attr_destroy(app, attr);
511                         return;
512                 default:
513                         WARN_ON(1);
514                 }
515         }
516 
517         attr->state = state;
518 }
519 
520 int mrp_request_join(const struct net_device *dev,
521                      const struct mrp_application *appl,
522                      const void *value, u8 len, u8 type)
523 {
524         struct mrp_port *port = rtnl_dereference(dev->mrp_port);
525         struct mrp_applicant *app = rtnl_dereference(
526                 port->applicants[appl->type]);
527         struct mrp_attr *attr;
528 
529         if (sizeof(struct mrp_skb_cb) + len >
530             FIELD_SIZEOF(struct sk_buff, cb))
531                 return -ENOMEM;
532 
533         spin_lock_bh(&app->lock);
534         attr = mrp_attr_create(app, value, len, type);
535         if (!attr) {
536                 spin_unlock_bh(&app->lock);
537                 return -ENOMEM;
538         }
539         mrp_attr_event(app, attr, MRP_EVENT_JOIN);
540         spin_unlock_bh(&app->lock);
541         return 0;
542 }
543 EXPORT_SYMBOL_GPL(mrp_request_join);
544 
545 void mrp_request_leave(const struct net_device *dev,
546                        const struct mrp_application *appl,
547                        const void *value, u8 len, u8 type)
548 {
549         struct mrp_port *port = rtnl_dereference(dev->mrp_port);
550         struct mrp_applicant *app = rtnl_dereference(
551                 port->applicants[appl->type]);
552         struct mrp_attr *attr;
553 
554         if (sizeof(struct mrp_skb_cb) + len >
555             FIELD_SIZEOF(struct sk_buff, cb))
556                 return;
557 
558         spin_lock_bh(&app->lock);
559         attr = mrp_attr_lookup(app, value, len, type);
560         if (!attr) {
561                 spin_unlock_bh(&app->lock);
562                 return;
563         }
564         mrp_attr_event(app, attr, MRP_EVENT_LV);
565         spin_unlock_bh(&app->lock);
566 }
567 EXPORT_SYMBOL_GPL(mrp_request_leave);
568 
569 static void mrp_mad_event(struct mrp_applicant *app, enum mrp_event event)
570 {
571         struct rb_node *node, *next;
572         struct mrp_attr *attr;
573 
574         for (node = rb_first(&app->mad);
575              next = node ? rb_next(node) : NULL, node != NULL;
576              node = next) {
577                 attr = rb_entry(node, struct mrp_attr, node);
578                 mrp_attr_event(app, attr, event);
579         }
580 }
581 
582 static void mrp_join_timer_arm(struct mrp_applicant *app)
583 {
584         unsigned long delay;
585 
586         delay = (u64)msecs_to_jiffies(mrp_join_time) * prandom_u32() >> 32;
587         mod_timer(&app->join_timer, jiffies + delay);
588 }
589 
590 static void mrp_join_timer(unsigned long data)
591 {
592         struct mrp_applicant *app = (struct mrp_applicant *)data;
593 
594         spin_lock(&app->lock);
595         mrp_mad_event(app, MRP_EVENT_TX);
596         mrp_pdu_queue(app);
597         spin_unlock(&app->lock);
598 
599         mrp_queue_xmit(app);
600         mrp_join_timer_arm(app);
601 }
602 
603 static void mrp_periodic_timer_arm(struct mrp_applicant *app)
604 {
605         mod_timer(&app->periodic_timer,
606                   jiffies + msecs_to_jiffies(mrp_periodic_time));
607 }
608 
609 static void mrp_periodic_timer(unsigned long data)
610 {
611         struct mrp_applicant *app = (struct mrp_applicant *)data;
612 
613         spin_lock(&app->lock);
614         mrp_mad_event(app, MRP_EVENT_PERIODIC);
615         mrp_pdu_queue(app);
616         spin_unlock(&app->lock);
617 
618         mrp_periodic_timer_arm(app);
619 }
620 
621 static int mrp_pdu_parse_end_mark(struct sk_buff *skb, int *offset)
622 {
623         __be16 endmark;
624 
625         if (skb_copy_bits(skb, *offset, &endmark, sizeof(endmark)) < 0)
626                 return -1;
627         if (endmark == MRP_END_MARK) {
628                 *offset += sizeof(endmark);
629                 return -1;
630         }
631         return 0;
632 }
633 
634 static void mrp_pdu_parse_vecattr_event(struct mrp_applicant *app,
635                                         struct sk_buff *skb,
636                                         enum mrp_vecattr_event vaevent)
637 {
638         struct mrp_attr *attr;
639         enum mrp_event event;
640 
641         attr = mrp_attr_lookup(app, mrp_cb(skb)->attrvalue,
642                                mrp_cb(skb)->mh->attrlen,
643                                mrp_cb(skb)->mh->attrtype);
644         if (attr == NULL)
645                 return;
646 
647         switch (vaevent) {
648         case MRP_VECATTR_EVENT_NEW:
649                 event = MRP_EVENT_R_NEW;
650                 break;
651         case MRP_VECATTR_EVENT_JOIN_IN:
652                 event = MRP_EVENT_R_JOIN_IN;
653                 break;
654         case MRP_VECATTR_EVENT_IN:
655                 event = MRP_EVENT_R_IN;
656                 break;
657         case MRP_VECATTR_EVENT_JOIN_MT:
658                 event = MRP_EVENT_R_JOIN_MT;
659                 break;
660         case MRP_VECATTR_EVENT_MT:
661                 event = MRP_EVENT_R_MT;
662                 break;
663         case MRP_VECATTR_EVENT_LV:
664                 event = MRP_EVENT_R_LV;
665                 break;
666         default:
667                 return;
668         }
669 
670         mrp_attr_event(app, attr, event);
671 }
672 
673 static int mrp_pdu_parse_vecattr(struct mrp_applicant *app,
674                                  struct sk_buff *skb, int *offset)
675 {
676         struct mrp_vecattr_hdr _vah;
677         u16 valen;
678         u8 vaevents, vaevent;
679 
680         mrp_cb(skb)->vah = skb_header_pointer(skb, *offset, sizeof(_vah),
681                                               &_vah);
682         if (!mrp_cb(skb)->vah)
683                 return -1;
684         *offset += sizeof(_vah);
685 
686         if (get_unaligned(&mrp_cb(skb)->vah->lenflags) &
687             MRP_VECATTR_HDR_FLAG_LA)
688                 mrp_mad_event(app, MRP_EVENT_R_LA);
689         valen = be16_to_cpu(get_unaligned(&mrp_cb(skb)->vah->lenflags) &
690                             MRP_VECATTR_HDR_LEN_MASK);
691 
692         /* The VectorAttribute structure in a PDU carries event information
693          * about one or more attributes having consecutive values. Only the
694          * value for the first attribute is contained in the structure. So
695          * we make a copy of that value, and then increment it each time we
696          * advance to the next event in its Vector.
697          */
698         if (sizeof(struct mrp_skb_cb) + mrp_cb(skb)->mh->attrlen >
699             FIELD_SIZEOF(struct sk_buff, cb))
700                 return -1;
701         if (skb_copy_bits(skb, *offset, mrp_cb(skb)->attrvalue,
702                           mrp_cb(skb)->mh->attrlen) < 0)
703                 return -1;
704         *offset += mrp_cb(skb)->mh->attrlen;
705 
706         /* In a VectorAttribute, the Vector contains events which are packed
707          * three to a byte. We process one byte of the Vector at a time.
708          */
709         while (valen > 0) {
710                 if (skb_copy_bits(skb, *offset, &vaevents,
711                                   sizeof(vaevents)) < 0)
712                         return -1;
713                 *offset += sizeof(vaevents);
714 
715                 /* Extract and process the first event. */
716                 vaevent = vaevents / (__MRP_VECATTR_EVENT_MAX *
717                                       __MRP_VECATTR_EVENT_MAX);
718                 if (vaevent >= __MRP_VECATTR_EVENT_MAX) {
719                         /* The byte is malformed; stop processing. */
720                         return -1;
721                 }
722                 mrp_pdu_parse_vecattr_event(app, skb, vaevent);
723 
724                 /* If present, extract and process the second event. */
725                 if (!--valen)
726                         break;
727                 mrp_attrvalue_inc(mrp_cb(skb)->attrvalue,
728                                   mrp_cb(skb)->mh->attrlen);
729                 vaevents %= (__MRP_VECATTR_EVENT_MAX *
730                              __MRP_VECATTR_EVENT_MAX);
731                 vaevent = vaevents / __MRP_VECATTR_EVENT_MAX;
732                 mrp_pdu_parse_vecattr_event(app, skb, vaevent);
733 
734                 /* If present, extract and process the third event. */
735                 if (!--valen)
736                         break;
737                 mrp_attrvalue_inc(mrp_cb(skb)->attrvalue,
738                                   mrp_cb(skb)->mh->attrlen);
739                 vaevents %= __MRP_VECATTR_EVENT_MAX;
740                 vaevent = vaevents;
741                 mrp_pdu_parse_vecattr_event(app, skb, vaevent);
742         }
743         return 0;
744 }
745 
746 static int mrp_pdu_parse_msg(struct mrp_applicant *app, struct sk_buff *skb,
747                              int *offset)
748 {
749         struct mrp_msg_hdr _mh;
750 
751         mrp_cb(skb)->mh = skb_header_pointer(skb, *offset, sizeof(_mh), &_mh);
752         if (!mrp_cb(skb)->mh)
753                 return -1;
754         *offset += sizeof(_mh);
755 
756         if (mrp_cb(skb)->mh->attrtype == 0 ||
757             mrp_cb(skb)->mh->attrtype > app->app->maxattr ||
758             mrp_cb(skb)->mh->attrlen == 0)
759                 return -1;
760 
761         while (skb->len > *offset) {
762                 if (mrp_pdu_parse_end_mark(skb, offset) < 0)
763                         break;
764                 if (mrp_pdu_parse_vecattr(app, skb, offset) < 0)
765                         return -1;
766         }
767         return 0;
768 }
769 
770 static int mrp_rcv(struct sk_buff *skb, struct net_device *dev,
771                    struct packet_type *pt, struct net_device *orig_dev)
772 {
773         struct mrp_application *appl = container_of(pt, struct mrp_application,
774                                                     pkttype);
775         struct mrp_port *port;
776         struct mrp_applicant *app;
777         struct mrp_pdu_hdr _ph;
778         const struct mrp_pdu_hdr *ph;
779         int offset = skb_network_offset(skb);
780 
781         /* If the interface is in promiscuous mode, drop the packet if
782          * it was unicast to another host.
783          */
784         if (unlikely(skb->pkt_type == PACKET_OTHERHOST))
785                 goto out;
786         skb = skb_share_check(skb, GFP_ATOMIC);
787         if (unlikely(!skb))
788                 goto out;
789         port = rcu_dereference(dev->mrp_port);
790         if (unlikely(!port))
791                 goto out;
792         app = rcu_dereference(port->applicants[appl->type]);
793         if (unlikely(!app))
794                 goto out;
795 
796         ph = skb_header_pointer(skb, offset, sizeof(_ph), &_ph);
797         if (!ph)
798                 goto out;
799         offset += sizeof(_ph);
800 
801         if (ph->version != app->app->version)
802                 goto out;
803 
804         spin_lock(&app->lock);
805         while (skb->len > offset) {
806                 if (mrp_pdu_parse_end_mark(skb, &offset) < 0)
807                         break;
808                 if (mrp_pdu_parse_msg(app, skb, &offset) < 0)
809                         break;
810         }
811         spin_unlock(&app->lock);
812 out:
813         kfree_skb(skb);
814         return 0;
815 }
816 
817 static int mrp_init_port(struct net_device *dev)
818 {
819         struct mrp_port *port;
820 
821         port = kzalloc(sizeof(*port), GFP_KERNEL);
822         if (!port)
823                 return -ENOMEM;
824         rcu_assign_pointer(dev->mrp_port, port);
825         return 0;
826 }
827 
828 static void mrp_release_port(struct net_device *dev)
829 {
830         struct mrp_port *port = rtnl_dereference(dev->mrp_port);
831         unsigned int i;
832 
833         for (i = 0; i <= MRP_APPLICATION_MAX; i++) {
834                 if (rtnl_dereference(port->applicants[i]))
835                         return;
836         }
837         RCU_INIT_POINTER(dev->mrp_port, NULL);
838         kfree_rcu(port, rcu);
839 }
840 
841 int mrp_init_applicant(struct net_device *dev, struct mrp_application *appl)
842 {
843         struct mrp_applicant *app;
844         int err;
845 
846         ASSERT_RTNL();
847 
848         if (!rtnl_dereference(dev->mrp_port)) {
849                 err = mrp_init_port(dev);
850                 if (err < 0)
851                         goto err1;
852         }
853 
854         err = -ENOMEM;
855         app = kzalloc(sizeof(*app), GFP_KERNEL);
856         if (!app)
857                 goto err2;
858 
859         err = dev_mc_add(dev, appl->group_address);
860         if (err < 0)
861                 goto err3;
862 
863         app->dev = dev;
864         app->app = appl;
865         app->mad = RB_ROOT;
866         spin_lock_init(&app->lock);
867         skb_queue_head_init(&app->queue);
868         rcu_assign_pointer(dev->mrp_port->applicants[appl->type], app);
869         setup_timer(&app->join_timer, mrp_join_timer, (unsigned long)app);
870         mrp_join_timer_arm(app);
871         setup_timer(&app->periodic_timer, mrp_periodic_timer,
872                     (unsigned long)app);
873         mrp_periodic_timer_arm(app);
874         return 0;
875 
876 err3:
877         kfree(app);
878 err2:
879         mrp_release_port(dev);
880 err1:
881         return err;
882 }
883 EXPORT_SYMBOL_GPL(mrp_init_applicant);
884 
885 void mrp_uninit_applicant(struct net_device *dev, struct mrp_application *appl)
886 {
887         struct mrp_port *port = rtnl_dereference(dev->mrp_port);
888         struct mrp_applicant *app = rtnl_dereference(
889                 port->applicants[appl->type]);
890 
891         ASSERT_RTNL();
892 
893         RCU_INIT_POINTER(port->applicants[appl->type], NULL);
894 
895         /* Delete timer and generate a final TX event to flush out
896          * all pending messages before the applicant is gone.
897          */
898         del_timer_sync(&app->join_timer);
899         del_timer_sync(&app->periodic_timer);
900 
901         spin_lock_bh(&app->lock);
902         mrp_mad_event(app, MRP_EVENT_TX);
903         mrp_pdu_queue(app);
904         spin_unlock_bh(&app->lock);
905 
906         mrp_queue_xmit(app);
907 
908         dev_mc_del(dev, appl->group_address);
909         kfree_rcu(app, rcu);
910         mrp_release_port(dev);
911 }
912 EXPORT_SYMBOL_GPL(mrp_uninit_applicant);
913 
914 int mrp_register_application(struct mrp_application *appl)
915 {
916         appl->pkttype.func = mrp_rcv;
917         dev_add_pack(&appl->pkttype);
918         return 0;
919 }
920 EXPORT_SYMBOL_GPL(mrp_register_application);
921 
922 void mrp_unregister_application(struct mrp_application *appl)
923 {
924         dev_remove_pack(&appl->pkttype);
925 }
926 EXPORT_SYMBOL_GPL(mrp_unregister_application);
927 

~ [ 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