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

TOMOYO Linux Cross Reference
Linux/net/hsr/hsr_netlink.c

Version: ~ [ linux-5.7-rc7 ] ~ [ linux-5.6.14 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.42 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.124 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.181 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.224 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.224 ] ~ [ 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.84 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /* Copyright 2011-2014 Autronica Fire and Security AS
  2  *
  3  * This program is free software; you can redistribute it and/or modify it
  4  * under the terms of the GNU General Public License as published by the Free
  5  * Software Foundation; either version 2 of the License, or (at your option)
  6  * any later version.
  7  *
  8  * Author(s):
  9  *      2011-2014 Arvid Brodin, arvid.brodin@alten.se
 10  *
 11  * Routines for handling Netlink messages for HSR.
 12  */
 13 
 14 #include "hsr_netlink.h"
 15 #include <linux/kernel.h>
 16 #include <net/rtnetlink.h>
 17 #include <net/genetlink.h>
 18 #include "hsr_main.h"
 19 #include "hsr_device.h"
 20 #include "hsr_framereg.h"
 21 
 22 static const struct nla_policy hsr_policy[IFLA_HSR_MAX + 1] = {
 23         [IFLA_HSR_SLAVE1]               = { .type = NLA_U32 },
 24         [IFLA_HSR_SLAVE2]               = { .type = NLA_U32 },
 25         [IFLA_HSR_MULTICAST_SPEC]       = { .type = NLA_U8 },
 26         [IFLA_HSR_SUPERVISION_ADDR]     = { .type = NLA_BINARY, .len = ETH_ALEN },
 27         [IFLA_HSR_SEQ_NR]               = { .type = NLA_U16 },
 28 };
 29 
 30 
 31 /* Here, it seems a netdevice has already been allocated for us, and the
 32  * hsr_dev_setup routine has been executed. Nice!
 33  */
 34 static int hsr_newlink(struct net *src_net, struct net_device *dev,
 35                        struct nlattr *tb[], struct nlattr *data[])
 36 {
 37         struct net_device *link[2];
 38         unsigned char multicast_spec;
 39 
 40         if (!data) {
 41                 netdev_info(dev, "HSR: No slave devices specified\n");
 42                 return -EINVAL;
 43         }
 44         if (!data[IFLA_HSR_SLAVE1]) {
 45                 netdev_info(dev, "HSR: Slave1 device not specified\n");
 46                 return -EINVAL;
 47         }
 48         link[0] = __dev_get_by_index(src_net, nla_get_u32(data[IFLA_HSR_SLAVE1]));
 49         if (!data[IFLA_HSR_SLAVE2]) {
 50                 netdev_info(dev, "HSR: Slave2 device not specified\n");
 51                 return -EINVAL;
 52         }
 53         link[1] = __dev_get_by_index(src_net, nla_get_u32(data[IFLA_HSR_SLAVE2]));
 54 
 55         if (!link[0] || !link[1])
 56                 return -ENODEV;
 57         if (link[0] == link[1])
 58                 return -EINVAL;
 59 
 60         if (!data[IFLA_HSR_MULTICAST_SPEC])
 61                 multicast_spec = 0;
 62         else
 63                 multicast_spec = nla_get_u8(data[IFLA_HSR_MULTICAST_SPEC]);
 64 
 65         return hsr_dev_finalize(dev, link, multicast_spec);
 66 }
 67 
 68 static int hsr_fill_info(struct sk_buff *skb, const struct net_device *dev)
 69 {
 70         struct hsr_priv *hsr;
 71         struct hsr_port *port;
 72         int res;
 73 
 74         hsr = netdev_priv(dev);
 75 
 76         res = 0;
 77 
 78         rcu_read_lock();
 79         port = hsr_port_get_hsr(hsr, HSR_PT_SLAVE_A);
 80         if (port)
 81                 res = nla_put_u32(skb, IFLA_HSR_SLAVE1, port->dev->ifindex);
 82         rcu_read_unlock();
 83         if (res)
 84                 goto nla_put_failure;
 85 
 86         rcu_read_lock();
 87         port = hsr_port_get_hsr(hsr, HSR_PT_SLAVE_B);
 88         if (port)
 89                 res = nla_put_u32(skb, IFLA_HSR_SLAVE2, port->dev->ifindex);
 90         rcu_read_unlock();
 91         if (res)
 92                 goto nla_put_failure;
 93 
 94         if (nla_put(skb, IFLA_HSR_SUPERVISION_ADDR, ETH_ALEN,
 95                     hsr->sup_multicast_addr) ||
 96             nla_put_u16(skb, IFLA_HSR_SEQ_NR, hsr->sequence_nr))
 97                 goto nla_put_failure;
 98 
 99         return 0;
100 
101 nla_put_failure:
102         return -EMSGSIZE;
103 }
104 
105 static struct rtnl_link_ops hsr_link_ops __read_mostly = {
106         .kind           = "hsr",
107         .maxtype        = IFLA_HSR_MAX,
108         .policy         = hsr_policy,
109         .priv_size      = sizeof(struct hsr_priv),
110         .setup          = hsr_dev_setup,
111         .newlink        = hsr_newlink,
112         .fill_info      = hsr_fill_info,
113 };
114 
115 
116 
117 /* attribute policy */
118 /* NLA_BINARY missing in libnl; use NLA_UNSPEC in userspace instead. */
119 static const struct nla_policy hsr_genl_policy[HSR_A_MAX + 1] = {
120         [HSR_A_NODE_ADDR] = { .type = NLA_BINARY, .len = ETH_ALEN },
121         [HSR_A_NODE_ADDR_B] = { .type = NLA_BINARY, .len = ETH_ALEN },
122         [HSR_A_IFINDEX] = { .type = NLA_U32 },
123         [HSR_A_IF1_AGE] = { .type = NLA_U32 },
124         [HSR_A_IF2_AGE] = { .type = NLA_U32 },
125         [HSR_A_IF1_SEQ] = { .type = NLA_U16 },
126         [HSR_A_IF2_SEQ] = { .type = NLA_U16 },
127 };
128 
129 static struct genl_family hsr_genl_family = {
130         .id = GENL_ID_GENERATE,
131         .hdrsize = 0,
132         .name = "HSR",
133         .version = 1,
134         .maxattr = HSR_A_MAX,
135 };
136 
137 static const struct genl_multicast_group hsr_mcgrps[] = {
138         { .name = "hsr-network", },
139 };
140 
141 
142 
143 /* This is called if for some node with MAC address addr, we only get frames
144  * over one of the slave interfaces. This would indicate an open network ring
145  * (i.e. a link has failed somewhere).
146  */
147 void hsr_nl_ringerror(struct hsr_priv *hsr, unsigned char addr[ETH_ALEN],
148                       struct hsr_port *port)
149 {
150         struct sk_buff *skb;
151         void *msg_head;
152         struct hsr_port *master;
153         int res;
154 
155         skb = genlmsg_new(NLMSG_GOODSIZE, GFP_ATOMIC);
156         if (!skb)
157                 goto fail;
158 
159         msg_head = genlmsg_put(skb, 0, 0, &hsr_genl_family, 0, HSR_C_RING_ERROR);
160         if (!msg_head)
161                 goto nla_put_failure;
162 
163         res = nla_put(skb, HSR_A_NODE_ADDR, ETH_ALEN, addr);
164         if (res < 0)
165                 goto nla_put_failure;
166 
167         res = nla_put_u32(skb, HSR_A_IFINDEX, port->dev->ifindex);
168         if (res < 0)
169                 goto nla_put_failure;
170 
171         genlmsg_end(skb, msg_head);
172         genlmsg_multicast(&hsr_genl_family, skb, 0, 0, GFP_ATOMIC);
173 
174         return;
175 
176 nla_put_failure:
177         kfree_skb(skb);
178 
179 fail:
180         rcu_read_lock();
181         master = hsr_port_get_hsr(hsr, HSR_PT_MASTER);
182         netdev_warn(master->dev, "Could not send HSR ring error message\n");
183         rcu_read_unlock();
184 }
185 
186 /* This is called when we haven't heard from the node with MAC address addr for
187  * some time (just before the node is removed from the node table/list).
188  */
189 void hsr_nl_nodedown(struct hsr_priv *hsr, unsigned char addr[ETH_ALEN])
190 {
191         struct sk_buff *skb;
192         void *msg_head;
193         struct hsr_port *master;
194         int res;
195 
196         skb = genlmsg_new(NLMSG_GOODSIZE, GFP_ATOMIC);
197         if (!skb)
198                 goto fail;
199 
200         msg_head = genlmsg_put(skb, 0, 0, &hsr_genl_family, 0, HSR_C_NODE_DOWN);
201         if (!msg_head)
202                 goto nla_put_failure;
203 
204 
205         res = nla_put(skb, HSR_A_NODE_ADDR, ETH_ALEN, addr);
206         if (res < 0)
207                 goto nla_put_failure;
208 
209         genlmsg_end(skb, msg_head);
210         genlmsg_multicast(&hsr_genl_family, skb, 0, 0, GFP_ATOMIC);
211 
212         return;
213 
214 nla_put_failure:
215         kfree_skb(skb);
216 
217 fail:
218         rcu_read_lock();
219         master = hsr_port_get_hsr(hsr, HSR_PT_MASTER);
220         netdev_warn(master->dev, "Could not send HSR node down\n");
221         rcu_read_unlock();
222 }
223 
224 
225 /* HSR_C_GET_NODE_STATUS lets userspace query the internal HSR node table
226  * about the status of a specific node in the network, defined by its MAC
227  * address.
228  *
229  * Input: hsr ifindex, node mac address
230  * Output: hsr ifindex, node mac address (copied from request),
231  *         age of latest frame from node over slave 1, slave 2 [ms]
232  */
233 static int hsr_get_node_status(struct sk_buff *skb_in, struct genl_info *info)
234 {
235         /* For receiving */
236         struct nlattr *na;
237         struct net_device *hsr_dev;
238 
239         /* For sending */
240         struct sk_buff *skb_out;
241         void *msg_head;
242         struct hsr_priv *hsr;
243         struct hsr_port *port;
244         unsigned char hsr_node_addr_b[ETH_ALEN];
245         int hsr_node_if1_age;
246         u16 hsr_node_if1_seq;
247         int hsr_node_if2_age;
248         u16 hsr_node_if2_seq;
249         int addr_b_ifindex;
250         int res;
251 
252         if (!info)
253                 goto invalid;
254 
255         na = info->attrs[HSR_A_IFINDEX];
256         if (!na)
257                 goto invalid;
258         na = info->attrs[HSR_A_NODE_ADDR];
259         if (!na)
260                 goto invalid;
261 
262         hsr_dev = __dev_get_by_index(genl_info_net(info),
263                                         nla_get_u32(info->attrs[HSR_A_IFINDEX]));
264         if (!hsr_dev)
265                 goto invalid;
266         if (!is_hsr_master(hsr_dev))
267                 goto invalid;
268 
269 
270         /* Send reply */
271 
272         skb_out = genlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
273         if (!skb_out) {
274                 res = -ENOMEM;
275                 goto fail;
276         }
277 
278         msg_head = genlmsg_put(skb_out, NETLINK_CB(skb_in).portid,
279                                 info->snd_seq, &hsr_genl_family, 0,
280                                 HSR_C_SET_NODE_STATUS);
281         if (!msg_head) {
282                 res = -ENOMEM;
283                 goto nla_put_failure;
284         }
285 
286         res = nla_put_u32(skb_out, HSR_A_IFINDEX, hsr_dev->ifindex);
287         if (res < 0)
288                 goto nla_put_failure;
289 
290         hsr = netdev_priv(hsr_dev);
291         res = hsr_get_node_data(hsr,
292                         (unsigned char *) nla_data(info->attrs[HSR_A_NODE_ADDR]),
293                         hsr_node_addr_b,
294                         &addr_b_ifindex,
295                         &hsr_node_if1_age,
296                         &hsr_node_if1_seq,
297                         &hsr_node_if2_age,
298                         &hsr_node_if2_seq);
299         if (res < 0)
300                 goto nla_put_failure;
301 
302         res = nla_put(skb_out, HSR_A_NODE_ADDR, ETH_ALEN,
303                                         nla_data(info->attrs[HSR_A_NODE_ADDR]));
304         if (res < 0)
305                 goto nla_put_failure;
306 
307         if (addr_b_ifindex > -1) {
308                 res = nla_put(skb_out, HSR_A_NODE_ADDR_B, ETH_ALEN,
309                                                                 hsr_node_addr_b);
310                 if (res < 0)
311                         goto nla_put_failure;
312 
313                 res = nla_put_u32(skb_out, HSR_A_ADDR_B_IFINDEX, addr_b_ifindex);
314                 if (res < 0)
315                         goto nla_put_failure;
316         }
317 
318         res = nla_put_u32(skb_out, HSR_A_IF1_AGE, hsr_node_if1_age);
319         if (res < 0)
320                 goto nla_put_failure;
321         res = nla_put_u16(skb_out, HSR_A_IF1_SEQ, hsr_node_if1_seq);
322         if (res < 0)
323                 goto nla_put_failure;
324         rcu_read_lock();
325         port = hsr_port_get_hsr(hsr, HSR_PT_SLAVE_A);
326         if (port)
327                 res = nla_put_u32(skb_out, HSR_A_IF1_IFINDEX,
328                                   port->dev->ifindex);
329         rcu_read_unlock();
330         if (res < 0)
331                 goto nla_put_failure;
332 
333         res = nla_put_u32(skb_out, HSR_A_IF2_AGE, hsr_node_if2_age);
334         if (res < 0)
335                 goto nla_put_failure;
336         res = nla_put_u16(skb_out, HSR_A_IF2_SEQ, hsr_node_if2_seq);
337         if (res < 0)
338                 goto nla_put_failure;
339         rcu_read_lock();
340         port = hsr_port_get_hsr(hsr, HSR_PT_SLAVE_B);
341         if (port)
342                 res = nla_put_u32(skb_out, HSR_A_IF2_IFINDEX,
343                                   port->dev->ifindex);
344         rcu_read_unlock();
345         if (res < 0)
346                 goto nla_put_failure;
347 
348         genlmsg_end(skb_out, msg_head);
349         genlmsg_unicast(genl_info_net(info), skb_out, info->snd_portid);
350 
351         return 0;
352 
353 invalid:
354         netlink_ack(skb_in, nlmsg_hdr(skb_in), -EINVAL);
355         return 0;
356 
357 nla_put_failure:
358         kfree_skb(skb_out);
359         /* Fall through */
360 
361 fail:
362         return res;
363 }
364 
365 /* Get a list of MacAddressA of all nodes known to this node (including self).
366  */
367 static int hsr_get_node_list(struct sk_buff *skb_in, struct genl_info *info)
368 {
369         /* For receiving */
370         struct nlattr *na;
371         struct net_device *hsr_dev;
372 
373         /* For sending */
374         struct sk_buff *skb_out;
375         void *msg_head;
376         struct hsr_priv *hsr;
377         void *pos;
378         unsigned char addr[ETH_ALEN];
379         int res;
380 
381         if (!info)
382                 goto invalid;
383 
384         na = info->attrs[HSR_A_IFINDEX];
385         if (!na)
386                 goto invalid;
387 
388         hsr_dev = __dev_get_by_index(genl_info_net(info),
389                                      nla_get_u32(info->attrs[HSR_A_IFINDEX]));
390         if (!hsr_dev)
391                 goto invalid;
392         if (!is_hsr_master(hsr_dev))
393                 goto invalid;
394 
395 
396         /* Send reply */
397 
398         skb_out = genlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
399         if (!skb_out) {
400                 res = -ENOMEM;
401                 goto fail;
402         }
403 
404         msg_head = genlmsg_put(skb_out, NETLINK_CB(skb_in).portid,
405                                 info->snd_seq, &hsr_genl_family, 0,
406                                 HSR_C_SET_NODE_LIST);
407         if (!msg_head) {
408                 res = -ENOMEM;
409                 goto nla_put_failure;
410         }
411 
412         res = nla_put_u32(skb_out, HSR_A_IFINDEX, hsr_dev->ifindex);
413         if (res < 0)
414                 goto nla_put_failure;
415 
416         hsr = netdev_priv(hsr_dev);
417 
418         rcu_read_lock();
419         pos = hsr_get_next_node(hsr, NULL, addr);
420         while (pos) {
421                 res = nla_put(skb_out, HSR_A_NODE_ADDR, ETH_ALEN, addr);
422                 if (res < 0) {
423                         rcu_read_unlock();
424                         goto nla_put_failure;
425                 }
426                 pos = hsr_get_next_node(hsr, pos, addr);
427         }
428         rcu_read_unlock();
429 
430         genlmsg_end(skb_out, msg_head);
431         genlmsg_unicast(genl_info_net(info), skb_out, info->snd_portid);
432 
433         return 0;
434 
435 invalid:
436         netlink_ack(skb_in, nlmsg_hdr(skb_in), -EINVAL);
437         return 0;
438 
439 nla_put_failure:
440         kfree_skb(skb_out);
441         /* Fall through */
442 
443 fail:
444         return res;
445 }
446 
447 
448 static const struct genl_ops hsr_ops[] = {
449         {
450                 .cmd = HSR_C_GET_NODE_STATUS,
451                 .flags = 0,
452                 .policy = hsr_genl_policy,
453                 .doit = hsr_get_node_status,
454                 .dumpit = NULL,
455         },
456         {
457                 .cmd = HSR_C_GET_NODE_LIST,
458                 .flags = 0,
459                 .policy = hsr_genl_policy,
460                 .doit = hsr_get_node_list,
461                 .dumpit = NULL,
462         },
463 };
464 
465 int __init hsr_netlink_init(void)
466 {
467         int rc;
468 
469         rc = rtnl_link_register(&hsr_link_ops);
470         if (rc)
471                 goto fail_rtnl_link_register;
472 
473         rc = genl_register_family_with_ops_groups(&hsr_genl_family, hsr_ops,
474                                                   hsr_mcgrps);
475         if (rc)
476                 goto fail_genl_register_family;
477 
478         return 0;
479 
480 fail_genl_register_family:
481         rtnl_link_unregister(&hsr_link_ops);
482 fail_rtnl_link_register:
483 
484         return rc;
485 }
486 
487 void __exit hsr_netlink_exit(void)
488 {
489         genl_unregister_family(&hsr_genl_family);
490         rtnl_link_unregister(&hsr_link_ops);
491 }
492 
493 MODULE_ALIAS_RTNL_LINK("hsr");
494 

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