Commit | Line | Data |
---|---|---|
03db3a2d MB |
1 | /* |
2 | * Copyright (c) 2015, Mellanox Technologies inc. All rights reserved. | |
3 | * | |
4 | * This software is available to you under a choice of one of two | |
5 | * licenses. You may choose to be licensed under the terms of the GNU | |
6 | * General Public License (GPL) Version 2, available from the file | |
7 | * COPYING in the main directory of this source tree, or the | |
8 | * OpenIB.org BSD license below: | |
9 | * | |
10 | * Redistribution and use in source and binary forms, with or | |
11 | * without modification, are permitted provided that the following | |
12 | * conditions are met: | |
13 | * | |
14 | * - Redistributions of source code must retain the above | |
15 | * copyright notice, this list of conditions and the following | |
16 | * disclaimer. | |
17 | * | |
18 | * - Redistributions in binary form must reproduce the above | |
19 | * copyright notice, this list of conditions and the following | |
20 | * disclaimer in the documentation and/or other materials | |
21 | * provided with the distribution. | |
22 | * | |
23 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, | |
24 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | |
25 | * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND | |
26 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS | |
27 | * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | |
28 | * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN | |
29 | * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE | |
30 | * SOFTWARE. | |
31 | */ | |
32 | ||
33 | #include "core_priv.h" | |
34 | ||
35 | #include <linux/in.h> | |
36 | #include <linux/in6.h> | |
37 | ||
38 | /* For in6_dev_get/in6_dev_put */ | |
39 | #include <net/addrconf.h> | |
238fdf48 | 40 | #include <net/bonding.h> |
03db3a2d MB |
41 | |
42 | #include <rdma/ib_cache.h> | |
43 | #include <rdma/ib_addr.h> | |
44 | ||
45 | enum gid_op_type { | |
46 | GID_DEL = 0, | |
47 | GID_ADD | |
48 | }; | |
49 | ||
50 | struct update_gid_event_work { | |
51 | struct work_struct work; | |
52 | union ib_gid gid; | |
53 | struct ib_gid_attr gid_attr; | |
54 | enum gid_op_type gid_op; | |
55 | }; | |
56 | ||
238fdf48 | 57 | #define ROCE_NETDEV_CALLBACK_SZ 3 |
03db3a2d MB |
58 | struct netdev_event_work_cmd { |
59 | roce_netdev_callback cb; | |
60 | roce_netdev_filter filter; | |
238fdf48 MB |
61 | struct net_device *ndev; |
62 | struct net_device *filter_ndev; | |
03db3a2d MB |
63 | }; |
64 | ||
65 | struct netdev_event_work { | |
66 | struct work_struct work; | |
67 | struct netdev_event_work_cmd cmds[ROCE_NETDEV_CALLBACK_SZ]; | |
03db3a2d MB |
68 | }; |
69 | ||
b39ffa1d MB |
70 | static const struct { |
71 | bool (*is_supported)(const struct ib_device *device, u8 port_num); | |
72 | enum ib_gid_type gid_type; | |
73 | } PORT_CAP_TO_GID_TYPE[] = { | |
7766a99f MB |
74 | {rdma_protocol_roce_eth_encap, IB_GID_TYPE_ROCE}, |
75 | {rdma_protocol_roce_udp_encap, IB_GID_TYPE_ROCE_UDP_ENCAP}, | |
b39ffa1d MB |
76 | }; |
77 | ||
78 | #define CAP_TO_GID_TABLE_SIZE ARRAY_SIZE(PORT_CAP_TO_GID_TYPE) | |
79 | ||
80 | unsigned long roce_gid_type_mask_support(struct ib_device *ib_dev, u8 port) | |
81 | { | |
82 | int i; | |
83 | unsigned int ret_flags = 0; | |
84 | ||
85 | if (!rdma_protocol_roce(ib_dev, port)) | |
86 | return 1UL << IB_GID_TYPE_IB; | |
87 | ||
88 | for (i = 0; i < CAP_TO_GID_TABLE_SIZE; i++) | |
89 | if (PORT_CAP_TO_GID_TYPE[i].is_supported(ib_dev, port)) | |
90 | ret_flags |= 1UL << PORT_CAP_TO_GID_TYPE[i].gid_type; | |
91 | ||
92 | return ret_flags; | |
93 | } | |
94 | EXPORT_SYMBOL(roce_gid_type_mask_support); | |
95 | ||
03db3a2d MB |
96 | static void update_gid(enum gid_op_type gid_op, struct ib_device *ib_dev, |
97 | u8 port, union ib_gid *gid, | |
98 | struct ib_gid_attr *gid_attr) | |
99 | { | |
b39ffa1d MB |
100 | int i; |
101 | unsigned long gid_type_mask = roce_gid_type_mask_support(ib_dev, port); | |
102 | ||
103 | for (i = 0; i < IB_GID_TYPE_SIZE; i++) { | |
104 | if ((1UL << i) & gid_type_mask) { | |
105 | gid_attr->gid_type = i; | |
106 | switch (gid_op) { | |
107 | case GID_ADD: | |
108 | ib_cache_gid_add(ib_dev, port, | |
109 | gid, gid_attr); | |
110 | break; | |
111 | case GID_DEL: | |
112 | ib_cache_gid_del(ib_dev, port, | |
113 | gid, gid_attr); | |
114 | break; | |
115 | } | |
116 | } | |
03db3a2d MB |
117 | } |
118 | } | |
119 | ||
238fdf48 MB |
120 | enum bonding_slave_state { |
121 | BONDING_SLAVE_STATE_ACTIVE = 1UL << 0, | |
122 | BONDING_SLAVE_STATE_INACTIVE = 1UL << 1, | |
123 | /* No primary slave or the device isn't a slave in bonding */ | |
124 | BONDING_SLAVE_STATE_NA = 1UL << 2, | |
125 | }; | |
126 | ||
127 | static enum bonding_slave_state is_eth_active_slave_of_bonding_rcu(struct net_device *dev, | |
128 | struct net_device *upper) | |
129 | { | |
130 | if (upper && netif_is_bond_master(upper)) { | |
131 | struct net_device *pdev = | |
132 | bond_option_active_slave_get_rcu(netdev_priv(upper)); | |
133 | ||
134 | if (pdev) | |
135 | return dev == pdev ? BONDING_SLAVE_STATE_ACTIVE : | |
136 | BONDING_SLAVE_STATE_INACTIVE; | |
137 | } | |
138 | ||
139 | return BONDING_SLAVE_STATE_NA; | |
140 | } | |
141 | ||
238fdf48 MB |
142 | #define REQUIRED_BOND_STATES (BONDING_SLAVE_STATE_ACTIVE | \ |
143 | BONDING_SLAVE_STATE_NA) | |
03db3a2d MB |
144 | static int is_eth_port_of_netdev(struct ib_device *ib_dev, u8 port, |
145 | struct net_device *rdma_ndev, void *cookie) | |
146 | { | |
238fdf48 | 147 | struct net_device *event_ndev = (struct net_device *)cookie; |
03db3a2d | 148 | struct net_device *real_dev; |
238fdf48 MB |
149 | int res; |
150 | ||
151 | if (!rdma_ndev) | |
152 | return 0; | |
153 | ||
154 | rcu_read_lock(); | |
155 | real_dev = rdma_vlan_dev_real_dev(event_ndev); | |
156 | if (!real_dev) | |
157 | real_dev = event_ndev; | |
158 | ||
6020d7e5 | 159 | res = ((rdma_is_upper_dev_rcu(rdma_ndev, event_ndev) && |
238fdf48 MB |
160 | (is_eth_active_slave_of_bonding_rcu(rdma_ndev, real_dev) & |
161 | REQUIRED_BOND_STATES)) || | |
162 | real_dev == rdma_ndev); | |
163 | ||
164 | rcu_read_unlock(); | |
165 | return res; | |
166 | } | |
167 | ||
168 | static int is_eth_port_inactive_slave(struct ib_device *ib_dev, u8 port, | |
169 | struct net_device *rdma_ndev, void *cookie) | |
170 | { | |
03db3a2d | 171 | struct net_device *master_dev; |
03db3a2d MB |
172 | int res; |
173 | ||
174 | if (!rdma_ndev) | |
175 | return 0; | |
176 | ||
177 | rcu_read_lock(); | |
178 | master_dev = netdev_master_upper_dev_get_rcu(rdma_ndev); | |
238fdf48 MB |
179 | res = is_eth_active_slave_of_bonding_rcu(rdma_ndev, master_dev) == |
180 | BONDING_SLAVE_STATE_INACTIVE; | |
03db3a2d MB |
181 | rcu_read_unlock(); |
182 | ||
183 | return res; | |
184 | } | |
185 | ||
186 | static int pass_all_filter(struct ib_device *ib_dev, u8 port, | |
187 | struct net_device *rdma_ndev, void *cookie) | |
188 | { | |
189 | return 1; | |
190 | } | |
191 | ||
238fdf48 MB |
192 | static int upper_device_filter(struct ib_device *ib_dev, u8 port, |
193 | struct net_device *rdma_ndev, void *cookie) | |
194 | { | |
195 | struct net_device *event_ndev = (struct net_device *)cookie; | |
196 | int res; | |
197 | ||
198 | if (!rdma_ndev) | |
199 | return 0; | |
200 | ||
201 | if (rdma_ndev == event_ndev) | |
202 | return 1; | |
203 | ||
204 | rcu_read_lock(); | |
6020d7e5 | 205 | res = rdma_is_upper_dev_rcu(rdma_ndev, event_ndev); |
238fdf48 MB |
206 | rcu_read_unlock(); |
207 | ||
208 | return res; | |
209 | } | |
210 | ||
03db3a2d MB |
211 | static void update_gid_ip(enum gid_op_type gid_op, |
212 | struct ib_device *ib_dev, | |
213 | u8 port, struct net_device *ndev, | |
214 | struct sockaddr *addr) | |
215 | { | |
216 | union ib_gid gid; | |
217 | struct ib_gid_attr gid_attr; | |
218 | ||
219 | rdma_ip2gid(addr, &gid); | |
220 | memset(&gid_attr, 0, sizeof(gid_attr)); | |
221 | gid_attr.ndev = ndev; | |
222 | ||
223 | update_gid(gid_op, ib_dev, port, &gid, &gid_attr); | |
224 | } | |
225 | ||
226 | static void enum_netdev_default_gids(struct ib_device *ib_dev, | |
227 | u8 port, struct net_device *event_ndev, | |
228 | struct net_device *rdma_ndev) | |
229 | { | |
b39ffa1d MB |
230 | unsigned long gid_type_mask; |
231 | ||
238fdf48 MB |
232 | rcu_read_lock(); |
233 | if (!rdma_ndev || | |
234 | ((rdma_ndev != event_ndev && | |
6020d7e5 | 235 | !rdma_is_upper_dev_rcu(rdma_ndev, event_ndev)) || |
238fdf48 MB |
236 | is_eth_active_slave_of_bonding_rcu(rdma_ndev, |
237 | netdev_master_upper_dev_get_rcu(rdma_ndev)) == | |
238 | BONDING_SLAVE_STATE_INACTIVE)) { | |
239 | rcu_read_unlock(); | |
03db3a2d | 240 | return; |
238fdf48 MB |
241 | } |
242 | rcu_read_unlock(); | |
03db3a2d | 243 | |
b39ffa1d MB |
244 | gid_type_mask = roce_gid_type_mask_support(ib_dev, port); |
245 | ||
246 | ib_cache_gid_set_default_gid(ib_dev, port, rdma_ndev, gid_type_mask, | |
03db3a2d MB |
247 | IB_CACHE_GID_DEFAULT_MODE_SET); |
248 | } | |
249 | ||
238fdf48 MB |
250 | static void bond_delete_netdev_default_gids(struct ib_device *ib_dev, |
251 | u8 port, | |
252 | struct net_device *event_ndev, | |
253 | struct net_device *rdma_ndev) | |
254 | { | |
255 | struct net_device *real_dev = rdma_vlan_dev_real_dev(event_ndev); | |
256 | ||
257 | if (!rdma_ndev) | |
258 | return; | |
259 | ||
260 | if (!real_dev) | |
261 | real_dev = event_ndev; | |
262 | ||
263 | rcu_read_lock(); | |
264 | ||
6020d7e5 | 265 | if (rdma_is_upper_dev_rcu(rdma_ndev, event_ndev) && |
238fdf48 MB |
266 | is_eth_active_slave_of_bonding_rcu(rdma_ndev, real_dev) == |
267 | BONDING_SLAVE_STATE_INACTIVE) { | |
b39ffa1d MB |
268 | unsigned long gid_type_mask; |
269 | ||
238fdf48 MB |
270 | rcu_read_unlock(); |
271 | ||
b39ffa1d MB |
272 | gid_type_mask = roce_gid_type_mask_support(ib_dev, port); |
273 | ||
238fdf48 | 274 | ib_cache_gid_set_default_gid(ib_dev, port, rdma_ndev, |
b39ffa1d | 275 | gid_type_mask, |
238fdf48 MB |
276 | IB_CACHE_GID_DEFAULT_MODE_DELETE); |
277 | } else { | |
278 | rcu_read_unlock(); | |
279 | } | |
280 | } | |
281 | ||
03db3a2d MB |
282 | static void enum_netdev_ipv4_ips(struct ib_device *ib_dev, |
283 | u8 port, struct net_device *ndev) | |
284 | { | |
285 | struct in_device *in_dev; | |
39096420 MB |
286 | struct sin_list { |
287 | struct list_head list; | |
288 | struct sockaddr_in ip; | |
289 | }; | |
290 | struct sin_list *sin_iter; | |
291 | struct sin_list *sin_temp; | |
292 | ||
293 | LIST_HEAD(sin_list); | |
03db3a2d MB |
294 | if (ndev->reg_state >= NETREG_UNREGISTERING) |
295 | return; | |
296 | ||
39096420 MB |
297 | rcu_read_lock(); |
298 | in_dev = __in_dev_get_rcu(ndev); | |
299 | if (!in_dev) { | |
300 | rcu_read_unlock(); | |
03db3a2d | 301 | return; |
39096420 | 302 | } |
03db3a2d MB |
303 | |
304 | for_ifa(in_dev) { | |
39096420 MB |
305 | struct sin_list *entry = kzalloc(sizeof(*entry), GFP_ATOMIC); |
306 | ||
307 | if (!entry) { | |
308 | pr_warn("roce_gid_mgmt: couldn't allocate entry for IPv4 update\n"); | |
309 | continue; | |
310 | } | |
311 | entry->ip.sin_family = AF_INET; | |
312 | entry->ip.sin_addr.s_addr = ifa->ifa_address; | |
313 | list_add_tail(&entry->list, &sin_list); | |
03db3a2d MB |
314 | } |
315 | endfor_ifa(in_dev); | |
39096420 | 316 | rcu_read_unlock(); |
03db3a2d | 317 | |
39096420 MB |
318 | list_for_each_entry_safe(sin_iter, sin_temp, &sin_list, list) { |
319 | update_gid_ip(GID_ADD, ib_dev, port, ndev, | |
320 | (struct sockaddr *)&sin_iter->ip); | |
321 | list_del(&sin_iter->list); | |
322 | kfree(sin_iter); | |
323 | } | |
03db3a2d MB |
324 | } |
325 | ||
326 | static void enum_netdev_ipv6_ips(struct ib_device *ib_dev, | |
327 | u8 port, struct net_device *ndev) | |
328 | { | |
329 | struct inet6_ifaddr *ifp; | |
330 | struct inet6_dev *in6_dev; | |
331 | struct sin6_list { | |
332 | struct list_head list; | |
333 | struct sockaddr_in6 sin6; | |
334 | }; | |
335 | struct sin6_list *sin6_iter; | |
336 | struct sin6_list *sin6_temp; | |
337 | struct ib_gid_attr gid_attr = {.ndev = ndev}; | |
338 | LIST_HEAD(sin6_list); | |
339 | ||
340 | if (ndev->reg_state >= NETREG_UNREGISTERING) | |
341 | return; | |
342 | ||
343 | in6_dev = in6_dev_get(ndev); | |
344 | if (!in6_dev) | |
345 | return; | |
346 | ||
347 | read_lock_bh(&in6_dev->lock); | |
348 | list_for_each_entry(ifp, &in6_dev->addr_list, if_list) { | |
349 | struct sin6_list *entry = kzalloc(sizeof(*entry), GFP_ATOMIC); | |
350 | ||
351 | if (!entry) { | |
352 | pr_warn("roce_gid_mgmt: couldn't allocate entry for IPv6 update\n"); | |
353 | continue; | |
354 | } | |
355 | ||
356 | entry->sin6.sin6_family = AF_INET6; | |
357 | entry->sin6.sin6_addr = ifp->addr; | |
358 | list_add_tail(&entry->list, &sin6_list); | |
359 | } | |
360 | read_unlock_bh(&in6_dev->lock); | |
361 | ||
362 | in6_dev_put(in6_dev); | |
363 | ||
364 | list_for_each_entry_safe(sin6_iter, sin6_temp, &sin6_list, list) { | |
365 | union ib_gid gid; | |
366 | ||
367 | rdma_ip2gid((struct sockaddr *)&sin6_iter->sin6, &gid); | |
368 | update_gid(GID_ADD, ib_dev, port, &gid, &gid_attr); | |
369 | list_del(&sin6_iter->list); | |
370 | kfree(sin6_iter); | |
371 | } | |
372 | } | |
373 | ||
238fdf48 MB |
374 | static void _add_netdev_ips(struct ib_device *ib_dev, u8 port, |
375 | struct net_device *ndev) | |
376 | { | |
377 | enum_netdev_ipv4_ips(ib_dev, port, ndev); | |
378 | if (IS_ENABLED(CONFIG_IPV6)) | |
379 | enum_netdev_ipv6_ips(ib_dev, port, ndev); | |
380 | } | |
381 | ||
03db3a2d MB |
382 | static void add_netdev_ips(struct ib_device *ib_dev, u8 port, |
383 | struct net_device *rdma_ndev, void *cookie) | |
384 | { | |
385 | struct net_device *event_ndev = (struct net_device *)cookie; | |
386 | ||
387 | enum_netdev_default_gids(ib_dev, port, event_ndev, rdma_ndev); | |
238fdf48 | 388 | _add_netdev_ips(ib_dev, port, event_ndev); |
03db3a2d MB |
389 | } |
390 | ||
391 | static void del_netdev_ips(struct ib_device *ib_dev, u8 port, | |
392 | struct net_device *rdma_ndev, void *cookie) | |
393 | { | |
394 | struct net_device *event_ndev = (struct net_device *)cookie; | |
395 | ||
396 | ib_cache_gid_del_all_netdev_gids(ib_dev, port, event_ndev); | |
397 | } | |
398 | ||
399 | static void enum_all_gids_of_dev_cb(struct ib_device *ib_dev, | |
400 | u8 port, | |
401 | struct net_device *rdma_ndev, | |
402 | void *cookie) | |
403 | { | |
404 | struct net *net; | |
405 | struct net_device *ndev; | |
406 | ||
407 | /* Lock the rtnl to make sure the netdevs does not move under | |
408 | * our feet | |
409 | */ | |
410 | rtnl_lock(); | |
411 | for_each_net(net) | |
412 | for_each_netdev(net, ndev) | |
413 | if (is_eth_port_of_netdev(ib_dev, port, rdma_ndev, ndev)) | |
414 | add_netdev_ips(ib_dev, port, rdma_ndev, ndev); | |
415 | rtnl_unlock(); | |
416 | } | |
417 | ||
418 | /* This function will rescan all of the network devices in the system | |
419 | * and add their gids, as needed, to the relevant RoCE devices. */ | |
420 | int roce_rescan_device(struct ib_device *ib_dev) | |
421 | { | |
422 | ib_enum_roce_netdev(ib_dev, pass_all_filter, NULL, | |
423 | enum_all_gids_of_dev_cb, NULL); | |
424 | ||
425 | return 0; | |
426 | } | |
427 | ||
428 | static void callback_for_addr_gid_device_scan(struct ib_device *device, | |
429 | u8 port, | |
430 | struct net_device *rdma_ndev, | |
431 | void *cookie) | |
432 | { | |
433 | struct update_gid_event_work *parsed = cookie; | |
434 | ||
435 | return update_gid(parsed->gid_op, device, | |
436 | port, &parsed->gid, | |
437 | &parsed->gid_attr); | |
438 | } | |
439 | ||
238fdf48 MB |
440 | static void handle_netdev_upper(struct ib_device *ib_dev, u8 port, |
441 | void *cookie, | |
442 | void (*handle_netdev)(struct ib_device *ib_dev, | |
443 | u8 port, | |
444 | struct net_device *ndev)) | |
445 | { | |
446 | struct net_device *ndev = (struct net_device *)cookie; | |
447 | struct upper_list { | |
448 | struct list_head list; | |
449 | struct net_device *upper; | |
450 | }; | |
451 | struct net_device *upper; | |
452 | struct list_head *iter; | |
453 | struct upper_list *upper_iter; | |
454 | struct upper_list *upper_temp; | |
455 | LIST_HEAD(upper_list); | |
456 | ||
457 | rcu_read_lock(); | |
458 | netdev_for_each_all_upper_dev_rcu(ndev, upper, iter) { | |
459 | struct upper_list *entry = kmalloc(sizeof(*entry), | |
460 | GFP_ATOMIC); | |
461 | ||
462 | if (!entry) { | |
463 | pr_info("roce_gid_mgmt: couldn't allocate entry to delete ndev\n"); | |
464 | continue; | |
465 | } | |
466 | ||
467 | list_add_tail(&entry->list, &upper_list); | |
468 | dev_hold(upper); | |
469 | entry->upper = upper; | |
470 | } | |
471 | rcu_read_unlock(); | |
472 | ||
473 | handle_netdev(ib_dev, port, ndev); | |
474 | list_for_each_entry_safe(upper_iter, upper_temp, &upper_list, | |
475 | list) { | |
476 | handle_netdev(ib_dev, port, upper_iter->upper); | |
477 | dev_put(upper_iter->upper); | |
478 | list_del(&upper_iter->list); | |
479 | kfree(upper_iter); | |
480 | } | |
481 | } | |
482 | ||
483 | static void _roce_del_all_netdev_gids(struct ib_device *ib_dev, u8 port, | |
484 | struct net_device *event_ndev) | |
485 | { | |
486 | ib_cache_gid_del_all_netdev_gids(ib_dev, port, event_ndev); | |
487 | } | |
488 | ||
489 | static void del_netdev_upper_ips(struct ib_device *ib_dev, u8 port, | |
490 | struct net_device *rdma_ndev, void *cookie) | |
491 | { | |
492 | handle_netdev_upper(ib_dev, port, cookie, _roce_del_all_netdev_gids); | |
493 | } | |
494 | ||
495 | static void add_netdev_upper_ips(struct ib_device *ib_dev, u8 port, | |
496 | struct net_device *rdma_ndev, void *cookie) | |
497 | { | |
498 | handle_netdev_upper(ib_dev, port, cookie, _add_netdev_ips); | |
499 | } | |
500 | ||
501 | static void del_netdev_default_ips_join(struct ib_device *ib_dev, u8 port, | |
502 | struct net_device *rdma_ndev, | |
503 | void *cookie) | |
504 | { | |
505 | struct net_device *master_ndev; | |
506 | ||
507 | rcu_read_lock(); | |
508 | master_ndev = netdev_master_upper_dev_get_rcu(rdma_ndev); | |
509 | if (master_ndev) | |
510 | dev_hold(master_ndev); | |
511 | rcu_read_unlock(); | |
512 | ||
513 | if (master_ndev) { | |
514 | bond_delete_netdev_default_gids(ib_dev, port, master_ndev, | |
515 | rdma_ndev); | |
516 | dev_put(master_ndev); | |
517 | } | |
518 | } | |
519 | ||
520 | static void del_netdev_default_ips(struct ib_device *ib_dev, u8 port, | |
521 | struct net_device *rdma_ndev, void *cookie) | |
522 | { | |
523 | struct net_device *event_ndev = (struct net_device *)cookie; | |
524 | ||
525 | bond_delete_netdev_default_gids(ib_dev, port, event_ndev, rdma_ndev); | |
526 | } | |
527 | ||
03db3a2d MB |
528 | /* The following functions operate on all IB devices. netdevice_event and |
529 | * addr_event execute ib_enum_all_roce_netdevs through a work. | |
530 | * ib_enum_all_roce_netdevs iterates through all IB devices. | |
531 | */ | |
532 | ||
533 | static void netdevice_event_work_handler(struct work_struct *_work) | |
534 | { | |
535 | struct netdev_event_work *work = | |
536 | container_of(_work, struct netdev_event_work, work); | |
537 | unsigned int i; | |
538 | ||
238fdf48 MB |
539 | for (i = 0; i < ARRAY_SIZE(work->cmds) && work->cmds[i].cb; i++) { |
540 | ib_enum_all_roce_netdevs(work->cmds[i].filter, | |
541 | work->cmds[i].filter_ndev, | |
542 | work->cmds[i].cb, | |
543 | work->cmds[i].ndev); | |
544 | dev_put(work->cmds[i].ndev); | |
545 | dev_put(work->cmds[i].filter_ndev); | |
546 | } | |
03db3a2d | 547 | |
03db3a2d MB |
548 | kfree(work); |
549 | } | |
550 | ||
551 | static int netdevice_queue_work(struct netdev_event_work_cmd *cmds, | |
552 | struct net_device *ndev) | |
553 | { | |
238fdf48 | 554 | unsigned int i; |
03db3a2d MB |
555 | struct netdev_event_work *ndev_work = |
556 | kmalloc(sizeof(*ndev_work), GFP_KERNEL); | |
557 | ||
558 | if (!ndev_work) { | |
559 | pr_warn("roce_gid_mgmt: can't allocate work for netdevice_event\n"); | |
560 | return NOTIFY_DONE; | |
561 | } | |
562 | ||
563 | memcpy(ndev_work->cmds, cmds, sizeof(ndev_work->cmds)); | |
238fdf48 MB |
564 | for (i = 0; i < ARRAY_SIZE(ndev_work->cmds) && ndev_work->cmds[i].cb; i++) { |
565 | if (!ndev_work->cmds[i].ndev) | |
566 | ndev_work->cmds[i].ndev = ndev; | |
567 | if (!ndev_work->cmds[i].filter_ndev) | |
568 | ndev_work->cmds[i].filter_ndev = ndev; | |
569 | dev_hold(ndev_work->cmds[i].ndev); | |
570 | dev_hold(ndev_work->cmds[i].filter_ndev); | |
571 | } | |
03db3a2d MB |
572 | INIT_WORK(&ndev_work->work, netdevice_event_work_handler); |
573 | ||
574 | queue_work(ib_wq, &ndev_work->work); | |
575 | ||
576 | return NOTIFY_DONE; | |
577 | } | |
578 | ||
238fdf48 MB |
579 | static const struct netdev_event_work_cmd add_cmd = { |
580 | .cb = add_netdev_ips, .filter = is_eth_port_of_netdev}; | |
581 | static const struct netdev_event_work_cmd add_cmd_upper_ips = { | |
582 | .cb = add_netdev_upper_ips, .filter = is_eth_port_of_netdev}; | |
583 | ||
26d2177e | 584 | static void netdevice_event_changeupper(struct netdev_notifier_changeupper_info *changeupper_info, |
238fdf48 MB |
585 | struct netdev_event_work_cmd *cmds) |
586 | { | |
587 | static const struct netdev_event_work_cmd upper_ips_del_cmd = { | |
588 | .cb = del_netdev_upper_ips, .filter = upper_device_filter}; | |
589 | static const struct netdev_event_work_cmd bonding_default_del_cmd = { | |
590 | .cb = del_netdev_default_ips, .filter = is_eth_port_inactive_slave}; | |
591 | ||
26d2177e | 592 | if (changeupper_info->linking == false) { |
238fdf48 | 593 | cmds[0] = upper_ips_del_cmd; |
26d2177e | 594 | cmds[0].ndev = changeupper_info->upper_dev; |
238fdf48 | 595 | cmds[1] = add_cmd; |
26d2177e | 596 | } else { |
238fdf48 | 597 | cmds[0] = bonding_default_del_cmd; |
26d2177e | 598 | cmds[0].ndev = changeupper_info->upper_dev; |
238fdf48 | 599 | cmds[1] = add_cmd_upper_ips; |
26d2177e LT |
600 | cmds[1].ndev = changeupper_info->upper_dev; |
601 | cmds[1].filter_ndev = changeupper_info->upper_dev; | |
238fdf48 MB |
602 | } |
603 | } | |
604 | ||
03db3a2d MB |
605 | static int netdevice_event(struct notifier_block *this, unsigned long event, |
606 | void *ptr) | |
607 | { | |
03db3a2d MB |
608 | static const struct netdev_event_work_cmd del_cmd = { |
609 | .cb = del_netdev_ips, .filter = pass_all_filter}; | |
238fdf48 MB |
610 | static const struct netdev_event_work_cmd bonding_default_del_cmd_join = { |
611 | .cb = del_netdev_default_ips_join, .filter = is_eth_port_inactive_slave}; | |
612 | static const struct netdev_event_work_cmd default_del_cmd = { | |
613 | .cb = del_netdev_default_ips, .filter = pass_all_filter}; | |
614 | static const struct netdev_event_work_cmd bonding_event_ips_del_cmd = { | |
615 | .cb = del_netdev_upper_ips, .filter = upper_device_filter}; | |
03db3a2d MB |
616 | struct net_device *ndev = netdev_notifier_info_to_dev(ptr); |
617 | struct netdev_event_work_cmd cmds[ROCE_NETDEV_CALLBACK_SZ] = { {NULL} }; | |
618 | ||
619 | if (ndev->type != ARPHRD_ETHER) | |
620 | return NOTIFY_DONE; | |
621 | ||
622 | switch (event) { | |
623 | case NETDEV_REGISTER: | |
624 | case NETDEV_UP: | |
238fdf48 MB |
625 | cmds[0] = bonding_default_del_cmd_join; |
626 | cmds[1] = add_cmd; | |
03db3a2d MB |
627 | break; |
628 | ||
629 | case NETDEV_UNREGISTER: | |
630 | if (ndev->reg_state < NETREG_UNREGISTERED) | |
631 | cmds[0] = del_cmd; | |
632 | else | |
633 | return NOTIFY_DONE; | |
634 | break; | |
635 | ||
636 | case NETDEV_CHANGEADDR: | |
238fdf48 | 637 | cmds[0] = default_del_cmd; |
03db3a2d MB |
638 | cmds[1] = add_cmd; |
639 | break; | |
238fdf48 MB |
640 | |
641 | case NETDEV_CHANGEUPPER: | |
642 | netdevice_event_changeupper( | |
26d2177e | 643 | container_of(ptr, struct netdev_notifier_changeupper_info, info), |
238fdf48 MB |
644 | cmds); |
645 | break; | |
646 | ||
647 | case NETDEV_BONDING_FAILOVER: | |
648 | cmds[0] = bonding_event_ips_del_cmd; | |
649 | cmds[1] = bonding_default_del_cmd_join; | |
650 | cmds[2] = add_cmd_upper_ips; | |
651 | break; | |
652 | ||
03db3a2d MB |
653 | default: |
654 | return NOTIFY_DONE; | |
655 | } | |
656 | ||
657 | return netdevice_queue_work(cmds, ndev); | |
658 | } | |
659 | ||
660 | static void update_gid_event_work_handler(struct work_struct *_work) | |
661 | { | |
662 | struct update_gid_event_work *work = | |
663 | container_of(_work, struct update_gid_event_work, work); | |
664 | ||
665 | ib_enum_all_roce_netdevs(is_eth_port_of_netdev, work->gid_attr.ndev, | |
666 | callback_for_addr_gid_device_scan, work); | |
667 | ||
668 | dev_put(work->gid_attr.ndev); | |
669 | kfree(work); | |
670 | } | |
671 | ||
672 | static int addr_event(struct notifier_block *this, unsigned long event, | |
673 | struct sockaddr *sa, struct net_device *ndev) | |
674 | { | |
675 | struct update_gid_event_work *work; | |
676 | enum gid_op_type gid_op; | |
677 | ||
678 | if (ndev->type != ARPHRD_ETHER) | |
679 | return NOTIFY_DONE; | |
680 | ||
681 | switch (event) { | |
682 | case NETDEV_UP: | |
683 | gid_op = GID_ADD; | |
684 | break; | |
685 | ||
686 | case NETDEV_DOWN: | |
687 | gid_op = GID_DEL; | |
688 | break; | |
689 | ||
690 | default: | |
691 | return NOTIFY_DONE; | |
692 | } | |
693 | ||
694 | work = kmalloc(sizeof(*work), GFP_ATOMIC); | |
695 | if (!work) { | |
696 | pr_warn("roce_gid_mgmt: Couldn't allocate work for addr_event\n"); | |
697 | return NOTIFY_DONE; | |
698 | } | |
699 | ||
700 | INIT_WORK(&work->work, update_gid_event_work_handler); | |
701 | ||
702 | rdma_ip2gid(sa, &work->gid); | |
703 | work->gid_op = gid_op; | |
704 | ||
705 | memset(&work->gid_attr, 0, sizeof(work->gid_attr)); | |
706 | dev_hold(ndev); | |
707 | work->gid_attr.ndev = ndev; | |
708 | ||
709 | queue_work(ib_wq, &work->work); | |
710 | ||
711 | return NOTIFY_DONE; | |
712 | } | |
713 | ||
714 | static int inetaddr_event(struct notifier_block *this, unsigned long event, | |
715 | void *ptr) | |
716 | { | |
717 | struct sockaddr_in in; | |
718 | struct net_device *ndev; | |
719 | struct in_ifaddr *ifa = ptr; | |
720 | ||
721 | in.sin_family = AF_INET; | |
722 | in.sin_addr.s_addr = ifa->ifa_address; | |
723 | ndev = ifa->ifa_dev->dev; | |
724 | ||
725 | return addr_event(this, event, (struct sockaddr *)&in, ndev); | |
726 | } | |
727 | ||
728 | static int inet6addr_event(struct notifier_block *this, unsigned long event, | |
729 | void *ptr) | |
730 | { | |
731 | struct sockaddr_in6 in6; | |
732 | struct net_device *ndev; | |
733 | struct inet6_ifaddr *ifa6 = ptr; | |
734 | ||
735 | in6.sin6_family = AF_INET6; | |
736 | in6.sin6_addr = ifa6->addr; | |
737 | ndev = ifa6->idev->dev; | |
738 | ||
739 | return addr_event(this, event, (struct sockaddr *)&in6, ndev); | |
740 | } | |
741 | ||
742 | static struct notifier_block nb_netdevice = { | |
743 | .notifier_call = netdevice_event | |
744 | }; | |
745 | ||
746 | static struct notifier_block nb_inetaddr = { | |
747 | .notifier_call = inetaddr_event | |
748 | }; | |
749 | ||
750 | static struct notifier_block nb_inet6addr = { | |
751 | .notifier_call = inet6addr_event | |
752 | }; | |
753 | ||
754 | int __init roce_gid_mgmt_init(void) | |
755 | { | |
756 | register_inetaddr_notifier(&nb_inetaddr); | |
757 | if (IS_ENABLED(CONFIG_IPV6)) | |
758 | register_inet6addr_notifier(&nb_inet6addr); | |
759 | /* We relay on the netdevice notifier to enumerate all | |
760 | * existing devices in the system. Register to this notifier | |
761 | * last to make sure we will not miss any IP add/del | |
762 | * callbacks. | |
763 | */ | |
764 | register_netdevice_notifier(&nb_netdevice); | |
765 | ||
766 | return 0; | |
767 | } | |
768 | ||
769 | void __exit roce_gid_mgmt_cleanup(void) | |
770 | { | |
771 | if (IS_ENABLED(CONFIG_IPV6)) | |
772 | unregister_inet6addr_notifier(&nb_inet6addr); | |
773 | unregister_inetaddr_notifier(&nb_inetaddr); | |
774 | unregister_netdevice_notifier(&nb_netdevice); | |
775 | /* Ensure all gid deletion tasks complete before we go down, | |
776 | * to avoid any reference to free'd memory. By the time | |
777 | * ib-core is removed, all physical devices have been removed, | |
778 | * so no issue with remaining hardware contexts. | |
779 | */ | |
780 | } |