Debian Codegraph @

src/network/networkd-sriov.c

raw
1 /* SPDX-License-Identifier: LGPL-2.1-or-later
2 * Copyright © 2020 VMware, Inc. */
3
4 #include "sd-netlink.h"
5
6 #include "device-private.h"
7 #include "device-util.h"
8 #include "errno-util.h"
9 #include "hashmap.h"
10 #include "networkd-link.h"
11 #include "networkd-manager.h"
12 #include "networkd-queue.h"
13 #include "networkd-sriov.h"
14 #include "set.h"
15 #include "string-util.h"
16
17 static int sr_iov_handler(sd_netlink *rtnl, sd_netlink_message *m, Request *req, Link *link, SRIOV *sr_iov) {
18 int r;
19
20 assert(m);
21 assert(link);
22
23 r = sd_netlink_message_get_errno(m);
24 if (r < 0)
25 log_link_message_warning_errno(link, m, r, "Failed to set up %s for SR-IOV virtual function %"PRIu32", ignoring",
26 sr_iov_attribute_to_string(req->type - _REQUEST_TYPE_SRIOV_BASE),
27 sr_iov->vf);
28
29 if (link->sr_iov_messages == 0) {
30 log_link_debug(link, "Applied settings for SR-IOV virtual functions.");
31 link->sr_iov_configured = true;
32 link_check_ready(link);
33 }
34
35 return 1;
36 }
37
38 static int sr_iov_configure(SRIOV *sr_iov, Link *link, Request *req) {
39 _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
40 int r;
41
42 assert(sr_iov);
43 assert(link);
44 assert(link->manager);
45 assert(link->manager->rtnl);
46 assert(link->ifindex > 0);
47 assert(req);
48
49 SRIOVAttribute attr = req->type - _REQUEST_TYPE_SRIOV_BASE;
50 assert(attr >= 0);
51 assert(attr < _SR_IOV_ATTRIBUTE_MAX);
52
53 log_link_debug(link, "Setting up %s for SR-IOV virtual function %"PRIu32".",
54 sr_iov_attribute_to_string(attr), sr_iov->vf);
55
56 r = sd_rtnl_message_new_link(link->manager->rtnl, &m, RTM_SETLINK, link->ifindex);
57 if (r < 0)
58 return r;
59
60 r = sr_iov_set_netlink_message(sr_iov, attr, m);
61 if (r < 0)
62 return r;
63
64 return request_call_netlink_async(link->manager->rtnl, m, req);
65 }
66
67 static int sr_iov_process_request(Request *req, Link *link, SRIOV *sr_iov) {
68 int r;
69
70 assert(req);
71 assert(link);
72 assert(sr_iov);
73
74 if (!IN_SET(link->state, LINK_STATE_CONFIGURING, LINK_STATE_CONFIGURED))
75 return 0;
76
77 r = sr_iov_configure(sr_iov, link, req);
78 if (r < 0)
79 return log_link_warning_errno(link, r,
80 "Failed to set up %s for SR-IOV virtual function %"PRIu32": %m",
81 sr_iov_attribute_to_string(req->type - _REQUEST_TYPE_SRIOV_BASE),
82 sr_iov->vf);
83
84 return 1;
85 }
86
87 int link_request_sr_iov_vfs(Link *link) {
88 SRIOV *sr_iov;
89 int r;
90
91 assert(link);
92 assert(link->network);
93
94 link->sr_iov_configured = false;
95
96 ORDERED_HASHMAP_FOREACH(sr_iov, link->network->sr_iov_by_section) {
97 for (SRIOVAttribute attr = 0; attr < _SR_IOV_ATTRIBUTE_MAX; attr++) {
98 if (!sr_iov_has_config(sr_iov, attr))
99 continue;
100
101 r = link_queue_request_safe(
102 link,
103 _REQUEST_TYPE_SRIOV_BASE + attr,
104 sr_iov,
105 NULL,
106 sr_iov_hash_func,
107 sr_iov_compare_func,
108 sr_iov_process_request,
109 &link->sr_iov_messages,
110 sr_iov_handler,
111 NULL);
112 if (r < 0)
113 return log_link_warning_errno(link, r,
114 "Failed to request to set up %s for SR-IOV virtual function %"PRIu32": %m",
115 sr_iov_attribute_to_string(attr), sr_iov->vf);
116 }
117 }
118
119 if (link->sr_iov_messages == 0) {
120 link->sr_iov_configured = true;
121 link_check_ready(link);
122 } else
123 log_link_debug(link, "Applying settings for SR-IOV virtual functions.");
124
125 return 0;
126 }
127
128 static int find_ifindex_from_pci_dev_port(sd_device *pci_dev, const char *dev_port) {
129 _cleanup_(sd_device_enumerator_unrefp) sd_device_enumerator *e = NULL;
130 sd_device *dev;
131 int ifindex, r;
132
133 assert(pci_dev);
134 assert(dev_port);
135
136 r = sd_device_enumerator_new(&e);
137 if (r < 0)
138 return r;
139
140 r = sd_device_enumerator_allow_uninitialized(e);
141 if (r < 0)
142 return r;
143
144 r = sd_device_enumerator_add_match_parent(e, pci_dev);
145 if (r < 0)
146 return r;
147
148 r = sd_device_enumerator_add_match_subsystem(e, "net", true);
149 if (r < 0)
150 return r;
151
152 r = sd_device_enumerator_add_match_sysattr(e, "dev_port", dev_port, true);
153 if (r < 0)
154 return r;
155
156 dev = sd_device_enumerator_get_device_first(e);
157 if (!dev)
158 return -ENODEV; /* no device found */
159
160 if (sd_device_enumerator_get_device_next(e))
161 return -ENXIO; /* multiple devices found */
162
163 r = sd_device_get_ifindex(dev, &ifindex);
164 if (r < 0)
165 return r;
166
167 assert(ifindex > 0);
168 return ifindex;
169 }
170
171 static int manager_update_sr_iov_ifindices(Manager *manager, int phys_port_ifindex, int virt_port_ifindex) {
172 Link *phys_link = NULL, *virt_link = NULL;
173 int r;
174
175 assert(manager);
176 assert(phys_port_ifindex > 0);
177 assert(virt_port_ifindex > 0);
178
179 /* This sets ifindices only when both interfaces are already managed by us. */
180
181 r = link_get_by_index(manager, phys_port_ifindex, &phys_link);
182 if (r < 0)
183 return r;
184
185 r = link_get_by_index(manager, virt_port_ifindex, &virt_link);
186 if (r < 0)
187 return r;
188
189 /* update VF ifindex in PF */
190 r = set_ensure_put(&phys_link->sr_iov_virt_port_ifindices, NULL, INT_TO_PTR(virt_port_ifindex));
191 if (r < 0)
192 return r;
193
194 log_link_debug(phys_link,
195 "Found SR-IOV VF port %s(%i).",
196 virt_link ? virt_link->ifname : "n/a", virt_port_ifindex);
197
198 /* update PF ifindex in VF */
199 if (virt_link->sr_iov_phys_port_ifindex > 0 && virt_link->sr_iov_phys_port_ifindex != phys_port_ifindex) {
200 Link *old_phys_link;
201
202 if (link_get_by_index(manager, virt_link->sr_iov_phys_port_ifindex, &old_phys_link) >= 0)
203 set_remove(old_phys_link->sr_iov_virt_port_ifindices, INT_TO_PTR(virt_port_ifindex));
204 }
205
206 virt_link->sr_iov_phys_port_ifindex = phys_port_ifindex;
207
208 log_link_debug(virt_link,
209 "Found SR-IOV PF port %s(%i).",
210 phys_link ? phys_link->ifname : "n/a", phys_port_ifindex);
211
212 return 0;
213 }
214
215 static int link_set_sr_iov_phys_port(Link *link, sd_device *pci_dev, const char *dev_port) {
216 _cleanup_(sd_device_unrefp) sd_device *pci_physfn_dev = NULL;
217 int r;
218
219 assert(link);
220 assert(link->manager);
221 assert(pci_dev);
222 assert(dev_port);
223
224 if (link->sr_iov_phys_port_ifindex > 0)
225 return 0;
226
227 r = sd_device_new_child(&pci_physfn_dev, pci_dev, "physfn");
228 if (r < 0)
229 return r;
230
231 r = find_ifindex_from_pci_dev_port(pci_physfn_dev, dev_port);
232 if (r < 0)
233 return r;
234
235 return manager_update_sr_iov_ifindices(link->manager, r, link->ifindex);
236 }
237
238 static int link_set_sr_iov_virt_ports(Link *link, sd_device *pci_dev, const char *dev_port) {
239 const char *name;
240 int r;
241
242 assert(link);
243 assert(link->manager);
244 assert(pci_dev);
245 assert(dev_port);
246
247 set_clear(link->sr_iov_virt_port_ifindices);
248
249 FOREACH_DEVICE_CHILD_WITH_SUFFIX(pci_dev, child, name) {
250 const char *n;
251
252 /* Accept name prefixed with "virtfn", but refuse "virtfn" itself. */
253 n = startswith(name, "virtfn");
254 if (isempty(n) || !in_charset(n, DIGITS))
255 continue;
256
257 r = find_ifindex_from_pci_dev_port(child, dev_port);
258 if (r < 0)
259 continue;
260
261 if (manager_update_sr_iov_ifindices(link->manager, link->ifindex, r) < 0)
262 continue;
263 }
264
265 return 0;
266 }
267
268 int link_set_sr_iov_ifindices(Link *link) {
269 const char *dev_port;
270 sd_device *pci_dev;
271 int r;
272
273 assert(link);
274
275 if (!link->dev)
276 return -ENODEV;
277
278 r = sd_device_get_parent_with_subsystem_devtype(link->dev, "pci", NULL, &pci_dev);
279 if (ERRNO_IS_NEG_DEVICE_ABSENT(r))
280 return 0;
281 if (r < 0)
282 return log_link_debug_errno(link, r, "Failed to get parent PCI device: %m");
283
284 /* This may return -EINVAL or -ENODEV, instead of -ENOENT, if the device has been removed or is being
285 * removed. Let's ignore the error codes here. */
286 r = device_get_sysattr_safe_string(link->dev, "dev_port", &dev_port);
287 if (ERRNO_IS_NEG_DEVICE_ABSENT(r) || r == -EINVAL)
288 return 0;
289 if (r < 0)
290 return log_link_debug_errno(link, r, "Failed to get 'dev_port' sysfs attribute: %m");
291
292 r = link_set_sr_iov_phys_port(link, pci_dev, dev_port);
293 if (r < 0 && !ERRNO_IS_DEVICE_ABSENT(r))
294 return log_link_debug_errno(link, r, "Failed to set SR-IOV physical port: %m");
295
296 r = link_set_sr_iov_virt_ports(link, pci_dev, dev_port);
297 if (r < 0 && !ERRNO_IS_DEVICE_ABSENT(r))
298 return log_link_debug_errno(link, r, "Failed to set SR-IOV virtual ports: %m");
299
300 return 0;
301 }
302
303 void link_clear_sr_iov_ifindices(Link *link) {
304 void *v;
305
306 assert(link);
307 assert(link->manager);
308
309 if (link->sr_iov_phys_port_ifindex > 0) {
310 Link *phys_link;
311
312 if (link_get_by_index(link->manager, link->sr_iov_phys_port_ifindex, &phys_link) >= 0)
313 set_remove(phys_link->sr_iov_virt_port_ifindices, INT_TO_PTR(link->ifindex));
314
315 link->sr_iov_phys_port_ifindex = 0;
316 }
317
318 while ((v = set_steal_first(link->sr_iov_virt_port_ifindices))) {
319 Link *virt_link;
320
321 if (link_get_by_index(link->manager, PTR_TO_INT(v), &virt_link) >= 0)
322 virt_link->sr_iov_phys_port_ifindex = 0;
323 }
324 }
325
326 bool check_ready_for_all_sr_iov_ports(
327 Link *link,
328 bool allow_unmanaged, /* for the main target */
329 bool (check_one)(Link *link, bool allow_unmanaged)) {
330
331 Link *phys_link;
332 void *v;
333
334 assert(link);
335 assert(link->manager);
336 assert(check_one);
337
338 /* Some drivers make VF ports become down when their PF port becomes down, and may fail to configure
339 * VF ports. Also, when a VF port becomes up/down, its PF port and other VF ports may become down.
340 * See issue #23315. */
341
342 /* First, check the main target. */
343 if (!check_one(link, allow_unmanaged))
344 return false;
345
346 /* If this is a VF port, then also check the PF port. */
347 if (link->sr_iov_phys_port_ifindex > 0) {
348 if (link_get_by_index(link->manager, link->sr_iov_phys_port_ifindex, &phys_link) < 0 ||
349 !check_one(phys_link, /* allow_unmanaged= */ true))
350 return false;
351 } else
352 phys_link = link;
353
354 /* Also check all VF ports. */
355 SET_FOREACH(v, phys_link->sr_iov_virt_port_ifindices) {
356 int ifindex = PTR_TO_INT(v);
357 Link *virt_link;
358
359 if (ifindex == link->ifindex)
360 continue; /* The main target link is a VF port, and its state is already checked. */
361
362 if (link_get_by_index(link->manager, ifindex, &virt_link) < 0)
363 return false;
364
365 if (!check_one(virt_link, /* allow_unmanaged= */ true))
366 return false;
367 }
368
369 return true;
370 }