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