Debian Codegraph @

src/nvme/mi-mctp.c

raw
1 // SPDX-License-Identifier: LGPL-2.1-or-later
2 /*
3 * This file is part of libnvme.
4 * Copyright (c) 2021 Code Construct Pty Ltd
5 *
6 * Authors: Jeremy Kerr <[email protected]>
7 */
8
9 #include <errno.h>
10 #include <stdbool.h>
11 #include <stdio.h>
12 #include <stdlib.h>
13 #include <unistd.h>
14
15 #include <poll.h>
16 #include <fcntl.h>
17 #include <sys/socket.h>
18 #include <sys/types.h>
19 #include <sys/uio.h>
20
21 #if HAVE_LINUX_MCTP_H
22 #include <linux/mctp.h>
23 #else
24 #include "nvme/mi-mctp-compat.h"
25 #endif
26
27 #include <ccan/endian/endian.h>
28
29 #ifdef CONFIG_DBUS
30 #include <dbus/dbus.h>
31
32 #define MCTP_DBUS_PATH "/au/com/codeconstruct/mctp1"
33 #define MCTP_DBUS_IFACE "au.com.codeconstruct.MCTP1"
34 #define MCTP_DBUS_IFACE_ENDPOINT "xyz.openbmc_project.MCTP.Endpoint"
35 #endif
36
37 #include "private.h"
38 #include "log.h"
39 #include "mi.h"
40
41
42 #if !defined(AF_MCTP)
43 #define AF_MCTP 45
44 #endif
45
46 #if !defined(MCTP_TAG_PREALLOC)
47 /*Adding this here for users with older build MCTP header
48 *that require SIOCMCTPALLOC/DROP
49 */
50 #define MCTP_TAG_PREALLOC 0x10
51
52 #define SIOCMCTPALLOCTAG (SIOCPROTOPRIVATE + 0)
53 #define SIOCMCTPDROPTAG (SIOCPROTOPRIVATE + 1)
54
55 /* Deprecated: use mctp_ioc_tag_ctl2 / TAG2 ioctls instead, which defines the
56 * MCTP network ID as part of the allocated tag. Using this assumes the default
57 * net ID for allocated tags, which may not give correct behaviour on system
58 * with multiple networks configured.
59 */
60 struct mctp_ioc_tag_ctl {
61 mctp_eid_t peer_addr;
62
63 /* For SIOCMCTPALLOCTAG: must be passed as zero, kernel will
64 * populate with the allocated tag value. Returned tag value will
65 * always have TO and PREALLOC set.
66 *
67 * For SIOCMCTPDROPTAG: userspace provides tag value to drop, from
68 * a prior SIOCMCTPALLOCTAG call (and so must have TO and PREALLOC set).
69 */
70 __u8 tag;
71 __u16 flags;
72 };
73 #endif /* !MCTP_TAG_PREALLOC */
74
75 #define MCTP_TYPE_NVME 0x04
76 #define MCTP_TYPE_MIC 0x80
77
78 struct nvme_mi_transport_mctp {
79 int net;
80 __u8 eid;
81 int sd;
82 void *resp_buf;
83 size_t resp_buf_size;
84 int sd_aem;
85 void *resp_buf_aem;
86 size_t resp_buf_aem_size;
87 };
88
89 static int ioctl_tag(int sd, unsigned long req, struct mctp_ioc_tag_ctl *ctl)
90 {
91 return ioctl(sd, req, ctl);
92 }
93
94 static int nvme_mi_msg_socket(void)
95 {
96 return socket(AF_MCTP, SOCK_DGRAM, 0);
97 }
98
99 static int nvme_mi_aem_socket(__u8 eid, unsigned int network)
100 {
101 struct sockaddr_mctp local_addr = {0}, remote_addr = {0};
102 int sd, rc;
103
104 sd = socket(AF_MCTP, SOCK_DGRAM | SOCK_NONBLOCK, 0);
105 if (sd < 0)
106 return sd;
107
108 remote_addr.smctp_family = AF_MCTP;
109 remote_addr.smctp_network = network;
110 remote_addr.smctp_addr.s_addr = eid;
111 remote_addr.smctp_type = MCTP_TYPE_NVME;
112 /* connect() will specify a remote EID for the upcoming bind() */
113 rc = connect(sd, (struct sockaddr *)&remote_addr, sizeof(remote_addr));
114 if (rc)
115 goto err_close;
116
117 local_addr.smctp_family = AF_MCTP;
118 local_addr.smctp_network = network;
119 local_addr.smctp_addr.s_addr = MCTP_ADDR_ANY;
120 local_addr.smctp_type = MCTP_TYPE_NVME;
121
122 rc = bind(sd, (struct sockaddr *)&local_addr, sizeof(local_addr));
123 if (rc)
124 goto err_close;
125
126 return sd;
127
128 err_close:
129 close(sd);
130 return -1;
131 }
132
133 static struct __mi_mctp_socket_ops ops = {
134 nvme_mi_msg_socket,
135 nvme_mi_aem_socket,
136 sendmsg,
137 recvmsg,
138 poll,
139 ioctl_tag,
140 };
141
142 void __nvme_mi_mctp_set_ops(const struct __mi_mctp_socket_ops *newops)
143 {
144 ops = *newops;
145 }
146 static const struct nvme_mi_transport nvme_mi_transport_mctp;
147
148 static __u8 nvme_mi_mctp_tag_alloc(struct nvme_mi_ep *ep)
149 {
150 struct nvme_mi_transport_mctp *mctp;
151 struct mctp_ioc_tag_ctl ctl = { 0 };
152 static bool logged;
153 int rc;
154
155 mctp = ep->transport_data;
156
157 ctl.peer_addr = mctp->eid;
158
159 errno = 0;
160 rc = ops.ioctl_tag(mctp->sd, SIOCMCTPALLOCTAG, &ctl);
161 if (rc) {
162 if (!logged) {
163 /* not necessarily fatal, just means we can't handle
164 * "more processing required" messages */
165 nvme_msg(ep->root, LOG_INFO,
166 "System does not support explicit tag allocation\n");
167 logged = true;
168 }
169 return MCTP_TAG_OWNER;
170 }
171
172 return ctl.tag;
173 }
174
175 static void nvme_mi_mctp_tag_drop(struct nvme_mi_ep *ep, __u8 tag)
176 {
177 struct nvme_mi_transport_mctp *mctp;
178 struct mctp_ioc_tag_ctl ctl = { 0 };
179
180 mctp = ep->transport_data;
181
182 if (!(tag & MCTP_TAG_PREALLOC))
183 return;
184
185 ctl.peer_addr = mctp->eid;
186 ctl.tag = tag;
187
188 ops.ioctl_tag(mctp->sd, SIOCMCTPDROPTAG, &ctl);
189 }
190
191 struct nvme_mi_msg_resp_mpr {
192 struct nvme_mi_msg_hdr hdr;
193 __u8 status;
194 __u8 rsvd0;
195 __u16 mprt;
196 };
197
198 /* Check if this response was a More Processing Required response; if so,
199 * populate the worst-case expected processing time, given in milliseconds.
200 *
201 * buf is the incoming message data, including type byte, but excluding
202 * the MIC which has been extracted into the mic argument already.
203 */
204 static bool nvme_mi_mctp_resp_is_mpr(void *buf, size_t len,
205 __le32 mic, unsigned int *mpr_time)
206 {
207 struct nvme_mi_msg_resp_mpr *msg;
208 __u32 crc;
209
210 /* We need at least the minimal header */
211 if (len < sizeof(*msg))
212 return false;
213
214 msg = (struct nvme_mi_msg_resp_mpr *)buf;
215
216 if (msg->status != NVME_MI_RESP_MPR)
217 return false;
218
219 /* Devices may send a MPR response as a full-sized Admin response,
220 * rather than the minimal MI-only header. Allow this, but only if the
221 * type indicates admin, and the allocated response header is the
222 * correct size for an Admin response.
223 */
224 if (!(len == sizeof(*msg) ||
225 ((msg->hdr.nmp >> 3 & 0x0f) == NVME_MI_MT_ADMIN &&
226 len == sizeof(struct nvme_mi_admin_resp_hdr))))
227 return false;
228
229 /* Verify the MIC from the response. We're dealing with linear
230 * header data here, and need to preserve the resp pointer & size
231 * values, so can't use verify_resp_mic here.
232 */
233 crc = ~nvme_mi_crc32_update(0xffffffff, buf, len);
234 if (le32_to_cpu(mic) != crc)
235 return false;
236
237 if (mpr_time)
238 *mpr_time = cpu_to_le16(msg->mprt) * 100;
239
240 return true;
241 }
242
243 static int nvme_mi_mctp_aem_fd(struct nvme_mi_ep *ep)
244 {
245 struct nvme_mi_transport_mctp *mctp;
246
247 if (ep->transport != &nvme_mi_transport_mctp) {
248 errno = EINVAL;
249 return -1;
250 }
251
252 mctp = ep->transport_data;
253 return mctp->sd_aem;
254 }
255
256 static int nvme_mi_mctp_aem_purge(struct nvme_mi_ep *ep)
257 {
258 struct nvme_mi_transport_mctp *mctp = ep->transport_data;
259 struct msghdr msg = {0};
260 struct iovec iov;
261 char buffer;
262
263 iov.iov_base = &buffer;
264 iov.iov_len = sizeof(buffer);
265 msg.msg_iov = &iov;
266 msg.msg_iovlen = 1;
267
268 // Read until there is no more data
269 while (ops.recvmsg(mctp->sd_aem, &msg, MSG_TRUNC) > 0)
270 ;
271
272 return 0;
273 }
274
275
276 static int nvme_mi_mctp_aem_read(struct nvme_mi_ep *ep,
277 struct nvme_mi_resp *resp)
278 {
279 ssize_t len, resp_len, resp_hdr_len, resp_data_len;
280 struct sockaddr_mctp src_addr = { 0 };
281 struct nvme_mi_transport_mctp *mctp;
282 struct iovec resp_iov[1];
283 struct msghdr resp_msg;
284 int rc, errno_save;
285 __le32 mic;
286
287 if (ep->transport != &nvme_mi_transport_mctp) {
288 errno = EINVAL;
289 return -1;
290 }
291
292 /* we need enough space for at least a generic (/error) response */
293 if (resp->hdr_len < sizeof(struct nvme_mi_msg_hdr)) {
294 errno = EINVAL;
295 return -1;
296 }
297
298 mctp = ep->transport_data;
299
300 resp_len = resp->hdr_len + resp->data_len + sizeof(mic);
301 if (resp_len > mctp->resp_buf_aem_size) {
302 void *tmp = realloc(mctp->resp_buf_aem, resp_len);
303
304 if (!tmp) {
305 errno_save = errno;
306 nvme_msg(ep->root, LOG_ERR,
307 "Failure allocating response buffer: %m\n");
308 errno = errno_save;
309 rc = -1;
310 goto out;
311 }
312 mctp->resp_buf_aem = tmp;
313 mctp->resp_buf_aem_size = resp_len;
314 }
315
316 /* offset by one: the MCTP message type is excluded from the buffer */
317 resp_iov[0].iov_base = mctp->resp_buf_aem + 1;
318 resp_iov[0].iov_len = resp_len - 1;
319
320 memset(&resp_msg, 0, sizeof(resp_msg));
321 resp_msg.msg_iov = resp_iov;
322 resp_msg.msg_iovlen = 1;
323 resp_msg.msg_name = &src_addr;
324 resp_msg.msg_namelen = sizeof(src_addr);
325
326 rc = -1;
327 len = ops.recvmsg(mctp->sd_aem, &resp_msg, MSG_DONTWAIT);
328
329 if (len < 0) {
330 if (errno == EAGAIN)
331 goto out;
332
333 errno_save = errno;
334 nvme_msg(ep->root, LOG_ERR,
335 "Failure receiving MCTP message: %m\n");
336 errno = errno_save;
337 goto out;
338 }
339
340
341 if (len == 0) {
342 nvme_msg(ep->root, LOG_WARNING, "No data from MCTP endpoint\n");
343 errno = EIO;
344 goto out;
345 }
346
347 if (resp_msg.msg_namelen < sizeof(src_addr)) {
348 nvme_msg(ep->root, LOG_WARNING, "Unexpected src address length\n");
349 errno = EIO;
350 goto out;
351 }
352
353 if (mctp->eid != src_addr.smctp_addr.s_addr) {
354 //This is unexpected if the socket is bound to the endpoint
355 errno = EPROTO;
356 goto out;
357 }
358
359 /* Re-add the type byte, so we can work on aligned lengths from here */
360 ((uint8_t *)mctp->resp_buf_aem)[0] = MCTP_TYPE_NVME | MCTP_TYPE_MIC;
361 len += 1;
362
363 /* The smallest response data is 8 bytes: generic 4-byte message header
364 * plus four bytes of error data (excluding MIC). Ensure we have enough.
365 */
366 if (len < 8 + sizeof(mic)) {
367 nvme_msg(ep->root, LOG_ERR,
368 "Invalid MCTP response: too short (%zd bytes, needed %zd)\n",
369 len, 8 + sizeof(mic));
370 errno = EPROTO;
371 goto out;
372 }
373
374 /* Start unpacking the linear resp buffer into the split header + data
375 * + MIC.
376 */
377
378 /* MIC is always at the tail */
379 memcpy(&mic, mctp->resp_buf_aem + len - sizeof(mic), sizeof(mic));
380 len -= 4;
381
382 /* we expect resp->hdr_len bytes, but we may have less */
383 resp_hdr_len = resp->hdr_len;
384 if (resp_hdr_len > len)
385 resp_hdr_len = len;
386 memcpy(resp->hdr, mctp->resp_buf_aem, resp_hdr_len);
387 resp->hdr_len = resp_hdr_len;
388 len -= resp_hdr_len;
389
390 /* any remaining bytes are the data payload */
391 resp_data_len = resp->data_len;
392 if (resp_data_len > len)
393 resp_data_len = len;
394 memcpy(resp->data, mctp->resp_buf_aem + resp_hdr_len, resp_data_len);
395 resp->data_len = resp_data_len;
396
397 resp->mic = le32_to_cpu(mic);
398
399 rc = 0;
400
401 out:
402 return rc;
403 }
404
405 static int nvme_mi_mctp_submit(struct nvme_mi_ep *ep,
406 struct nvme_mi_req *req,
407 struct nvme_mi_resp *resp)
408 {
409 ssize_t len, resp_len, resp_hdr_len, resp_data_len;
410 struct nvme_mi_transport_mctp *mctp;
411 struct iovec req_iov[3], resp_iov[1];
412 struct msghdr req_msg, resp_msg;
413 int i, rc, errno_save, timeout;
414 struct sockaddr_mctp addr;
415 struct pollfd pollfds[1];
416 unsigned int mpr_time;
417 __le32 mic;
418 __u8 tag;
419
420 if (ep->transport != &nvme_mi_transport_mctp) {
421 errno = EINVAL;
422 return -1;
423 }
424
425 /* we need enough space for at least a generic (/error) response */
426 if (resp->hdr_len < sizeof(struct nvme_mi_msg_resp)) {
427 errno = EINVAL;
428 return -1;
429 }
430
431 mctp = ep->transport_data;
432 tag = nvme_mi_mctp_tag_alloc(ep);
433
434 memset(&addr, 0, sizeof(addr));
435 addr.smctp_family = AF_MCTP;
436 addr.smctp_network = mctp->net;
437 addr.smctp_addr.s_addr = mctp->eid;
438 addr.smctp_type = MCTP_TYPE_NVME | MCTP_TYPE_MIC;
439 addr.smctp_tag = tag;
440
441 i = 0;
442 req_iov[i].iov_base = ((__u8 *)req->hdr) + 1;
443 req_iov[i].iov_len = req->hdr_len - 1;
444 i++;
445
446 if (req->data_len) {
447 req_iov[i].iov_base = req->data;
448 req_iov[i].iov_len = req->data_len;
449 i++;
450 }
451
452 mic = cpu_to_le32(req->mic);
453 req_iov[i].iov_base = &mic;
454 req_iov[i].iov_len = sizeof(mic);
455 i++;
456
457 memset(&req_msg, 0, sizeof(req_msg));
458 req_msg.msg_name = &addr;
459 req_msg.msg_namelen = sizeof(addr);
460 req_msg.msg_iov = req_iov;
461 req_msg.msg_iovlen = i;
462
463 len = ops.sendmsg(mctp->sd, &req_msg, 0);
464 if (len < 0) {
465 errno_save = errno;
466 nvme_msg(ep->root, LOG_ERR,
467 "Failure sending MCTP message: %m\n");
468 errno = errno_save;
469 rc = -1;
470 goto out;
471 }
472
473 resp_len = resp->hdr_len + resp->data_len + sizeof(mic);
474 if (resp_len > mctp->resp_buf_size) {
475 void *tmp = realloc(mctp->resp_buf, resp_len);
476 if (!tmp) {
477 errno_save = errno;
478 nvme_msg(ep->root, LOG_ERR,
479 "Failure allocating response buffer: %m\n");
480 errno = errno_save;
481 rc = -1;
482 goto out;
483 }
484 mctp->resp_buf = tmp;
485 mctp->resp_buf_size = resp_len;
486 }
487
488 /* offset by one: the MCTP message type is excluded from the buffer */
489 resp_iov[0].iov_base = mctp->resp_buf + 1;
490 resp_iov[0].iov_len = resp_len - 1;
491
492 memset(&resp_msg, 0, sizeof(resp_msg));
493 resp_msg.msg_name = &addr;
494 resp_msg.msg_namelen = sizeof(addr);
495 resp_msg.msg_iov = resp_iov;
496 resp_msg.msg_iovlen = 1;
497
498 pollfds[0].fd = mctp->sd;
499 pollfds[0].events = POLLIN;
500 timeout = ep->timeout ?: -1;
501 retry:
502 rc = ops.poll(pollfds, 1, timeout);
503 if (rc < 0) {
504 if (errno == EINTR)
505 goto retry;
506 errno_save = errno;
507 nvme_msg(ep->root, LOG_ERR,
508 "Failed polling on MCTP socket: %m");
509 errno = errno_save;
510 goto out;
511 }
512
513 if (rc == 0) {
514 nvme_msg(ep->root, LOG_DEBUG, "Timeout on MCTP socket");
515 errno = ETIMEDOUT;
516 rc = -1;
517 goto out;
518 }
519
520 rc = -1;
521 len = ops.recvmsg(mctp->sd, &resp_msg, MSG_DONTWAIT);
522
523 if (len < 0) {
524 errno_save = errno;
525 nvme_msg(ep->root, LOG_ERR,
526 "Failure receiving MCTP message: %m\n");
527 errno = errno_save;
528 goto out;
529 }
530
531
532 if (len == 0) {
533 nvme_msg(ep->root, LOG_WARNING, "No data from MCTP endpoint\n");
534 errno = EIO;
535 goto out;
536 }
537
538 /* Re-add the type byte, so we can work on aligned lengths from here */
539 ((uint8_t *)mctp->resp_buf)[0] = MCTP_TYPE_NVME | MCTP_TYPE_MIC;
540 len += 1;
541
542 /* The smallest response data is 8 bytes: generic 4-byte message header
543 * plus four bytes of error data (excluding MIC). Ensure we have enough.
544 */
545 if (len < 8 + sizeof(mic)) {
546 nvme_msg(ep->root, LOG_ERR,
547 "Invalid MCTP response: too short (%zd bytes, needed %zd)\n",
548 len, 8 + sizeof(mic));
549 errno = EPROTO;
550 goto out;
551 }
552
553 /* Start unpacking the linear resp buffer into the split header + data
554 * + MIC. We check for a MPR response before fully unpacking, as we'll
555 * need to preserve the resp layout if we need to retry the receive.
556 */
557
558 /* MIC is always at the tail */
559 memcpy(&mic, mctp->resp_buf + len - sizeof(mic), sizeof(mic));
560 len -= 4;
561
562 /* Check for a More Processing Required response. This is a slight
563 * layering violation, as we're pre-checking the MIC and inspecting
564 * header fields. However, we need to do this in the transport in order
565 * to keep the tag allocated and retry the recvmsg
566 */
567 if (nvme_mi_mctp_resp_is_mpr(mctp->resp_buf, len, mic, &mpr_time)) {
568 nvme_msg(ep->root, LOG_DEBUG,
569 "Received More Processing Required, waiting for response\n");
570
571 /* if the controller hasn't set MPRT, fall back to our command/
572 * response timeout, or the largest possible MPRT if none set */
573 if (!mpr_time)
574 mpr_time = ep->timeout ?: 0xffff;
575
576 /* clamp to the endpoint max */
577 if (ep->mprt_max && mpr_time > ep->mprt_max)
578 mpr_time = ep->mprt_max;
579
580 timeout = mpr_time;
581 goto retry;
582 }
583
584 /* we expect resp->hdr_len bytes, but we may have less */
585 resp_hdr_len = resp->hdr_len;
586 if (resp_hdr_len > len)
587 resp_hdr_len = len;
588 memcpy(resp->hdr, mctp->resp_buf, resp_hdr_len);
589 resp->hdr_len = resp_hdr_len;
590 len -= resp_hdr_len;
591
592 /* any remaining bytes are the data payload */
593 resp_data_len = resp->data_len;
594 if (resp_data_len > len)
595 resp_data_len = len;
596 memcpy(resp->data, mctp->resp_buf + resp_hdr_len, resp_data_len);
597 resp->data_len = resp_data_len;
598
599 resp->mic = le32_to_cpu(mic);
600
601 rc = 0;
602
603 out:
604 nvme_mi_mctp_tag_drop(ep, tag);
605
606 return rc;
607 }
608
609 static void nvme_mi_mctp_close(struct nvme_mi_ep *ep)
610 {
611 struct nvme_mi_transport_mctp *mctp;
612
613 if (ep->transport != &nvme_mi_transport_mctp)
614 return;
615
616 mctp = ep->transport_data;
617 close(mctp->sd);
618 close(mctp->sd_aem);
619 free(ep->aem_ctx);
620 free(mctp->resp_buf);
621 free(mctp->resp_buf_aem);
622 free(ep->transport_data);
623 }
624
625 static int nvme_mi_mctp_desc_ep(struct nvme_mi_ep *ep, char *buf, size_t len)
626 {
627 struct nvme_mi_transport_mctp *mctp;
628
629 if (ep->transport != &nvme_mi_transport_mctp) {
630 errno = EINVAL;
631 return -1;
632 }
633
634 mctp = ep->transport_data;
635
636 snprintf(buf, len, "net %d eid %d", mctp->net, mctp->eid);
637
638 return 0;
639 }
640
641 static const struct nvme_mi_transport nvme_mi_transport_mctp = {
642 .name = "mctp",
643 .mic_enabled = true,
644 .submit = nvme_mi_mctp_submit,
645 .close = nvme_mi_mctp_close,
646 .desc_ep = nvme_mi_mctp_desc_ep,
647 .aem_read = nvme_mi_mctp_aem_read,
648 .aem_fd = nvme_mi_mctp_aem_fd,
649 .aem_purge = nvme_mi_mctp_aem_purge,
650 };
651
652 int nvme_mi_aem_open(nvme_mi_ep_t ep)
653 {
654 struct nvme_mi_transport_mctp *mctp;
655
656 if (ep->transport != &nvme_mi_transport_mctp) {
657 errno = EINVAL;
658 return -1;
659 }
660
661 mctp = ep->transport_data;
662
663 //This doesn't have to be done multiple times
664 if (mctp->sd_aem >= 0)
665 return 0;
666
667 mctp->sd_aem = ops.aem_socket(mctp->eid, mctp->net);
668
669 if (mctp->sd_aem < 0)
670 return -1;
671
672 return 0;
673 }
674
675 nvme_mi_ep_t nvme_mi_open_mctp(nvme_root_t root, unsigned int netid, __u8 eid)
676 {
677 struct nvme_mi_transport_mctp *mctp;
678 struct nvme_mi_ep *ep;
679 int errno_save;
680
681 ep = nvme_mi_init_ep(root);
682 if (!ep)
683 return NULL;
684
685 mctp = malloc(sizeof(*mctp));
686 if (!mctp) {
687 errno_save = errno;
688 goto err_close_ep;
689 }
690
691 memset(mctp, 0, sizeof(*mctp));
692 mctp->sd = -1;
693 mctp->sd_aem = -1;
694
695 mctp->resp_buf_size = 4096;
696 mctp->resp_buf = malloc(mctp->resp_buf_size);
697 if (!mctp->resp_buf) {
698 errno_save = errno;
699 goto err_free_mctp;
700 }
701
702 mctp->resp_buf_aem_size = 4096;
703 mctp->resp_buf_aem = malloc(mctp->resp_buf_aem_size);
704 if (!mctp->resp_buf_aem) {
705 errno_save = errno;
706 goto err_free_rspbuf;
707 }
708
709 mctp->net = netid;
710 mctp->eid = eid;
711
712 mctp->sd = ops.msg_socket();
713 if (mctp->sd < 0) {
714 errno_save = errno;
715 goto err_free_aem_rspbuf;
716 }
717
718 ep->transport = &nvme_mi_transport_mctp;
719 ep->transport_data = mctp;
720
721 /* Assuming an i2c transport at 100kHz, smallest MTU (64+4). Given
722 * a worst-case clock stretch, and largest-sized packets, we can
723 * expect up to 1.6s per command/response pair. Allowing for a
724 * retry or two (handled by lower layers), 5s is a reasonable timeout.
725 */
726 ep->timeout = 5000;
727
728 return ep;
729
730 err_free_aem_rspbuf:
731 free(mctp->resp_buf_aem);
732 err_free_rspbuf:
733 free(mctp->resp_buf);
734 err_free_mctp:
735 free(mctp);
736 err_close_ep:
737 /* the ep->transport is not set yet, so this will not call back
738 * into nvme_mi_mctp_close() */
739 nvme_mi_close(ep);
740 errno = errno_save;
741 return NULL;
742 }
743
744 #ifdef CONFIG_DBUS
745
746 static int nvme_mi_mctp_add(nvme_root_t root, unsigned int netid, __u8 eid)
747 {
748 nvme_mi_ep_t ep = NULL;
749
750 /* ensure we don't already have an endpoint with the same net/eid. if
751 * we do, just skip, no need to re-add. */
752 list_for_each(&root->endpoints, ep, root_entry) {
753 if (ep->transport != &nvme_mi_transport_mctp) {
754 continue;
755 }
756 const struct nvme_mi_transport_mctp *t = ep->transport_data;
757 if (t->eid == eid && t->net == netid)
758 return 0;
759 }
760
761 ep = nvme_mi_open_mctp(root, netid, eid);
762 if (!ep)
763 return -1;
764
765 return 0;
766 }
767
768 static bool dbus_object_is_type(DBusMessageIter *obj, int type)
769 {
770 return dbus_message_iter_get_arg_type(obj) == type;
771 }
772
773 static bool dbus_object_is_dict(DBusMessageIter *obj)
774 {
775 return dbus_object_is_type(obj, DBUS_TYPE_ARRAY) &&
776 dbus_message_iter_get_element_type(obj) == DBUS_TYPE_DICT_ENTRY;
777 }
778
779 static int read_variant_basic(DBusMessageIter *var, int type, void *val)
780 {
781 if (!dbus_object_is_type(var, type))
782 return -1;
783
784 dbus_message_iter_get_basic(var, val);
785
786 return 0;
787 }
788
789 static bool has_message_type(DBusMessageIter *prop, uint8_t type)
790 {
791 DBusMessageIter inner;
792 uint8_t *types;
793 int i, n;
794
795 if (!dbus_object_is_type(prop, DBUS_TYPE_ARRAY) ||
796 dbus_message_iter_get_element_type(prop) != DBUS_TYPE_BYTE)
797 return false;
798
799 dbus_message_iter_recurse(prop, &inner);
800
801 dbus_message_iter_get_fixed_array(&inner, &types, &n);
802
803 for (i = 0; i < n; i++) {
804 if (types[i] == type)
805 return true;
806 }
807
808 return false;
809 }
810
811 static int handle_mctp_endpoint(nvme_root_t root, const char* objpath,
812 DBusMessageIter *props)
813 {
814 bool have_eid = false, have_net = false, have_nvmemi = false;
815 mctp_eid_t eid;
816 int net;
817 int rc = 0;
818
819 /* for each property */
820 for (;;) {
821 DBusMessageIter prop, val;
822 const char *propname;
823
824 dbus_message_iter_recurse(props, &prop);
825
826 if (!dbus_object_is_type(&prop, DBUS_TYPE_STRING)) {
827 nvme_msg(root, LOG_ERR,
828 "error unmashalling object (propname)\n");
829 return -1;
830 }
831
832 dbus_message_iter_get_basic(&prop, &propname);
833
834 dbus_message_iter_next(&prop);
835
836 if (!dbus_object_is_type(&prop, DBUS_TYPE_VARIANT)) {
837 nvme_msg(root, LOG_ERR,
838 "error unmashalling object (propval)\n");
839 return -1;
840 }
841
842 dbus_message_iter_recurse(&prop, &val);
843
844 if (!strcmp(propname, "EID")) {
845 rc = read_variant_basic(&val, DBUS_TYPE_BYTE, &eid);
846 have_eid = true;
847
848 } else if (!strcmp(propname, "NetworkId")) {
849 rc = read_variant_basic(&val, DBUS_TYPE_INT32, &net);
850 have_net = true;
851
852 } else if (!strcmp(propname, "SupportedMessageTypes")) {
853 have_nvmemi = has_message_type(&val, MCTP_TYPE_NVME);
854 }
855
856 if (rc)
857 return rc;
858
859 if (!dbus_message_iter_next(props))
860 break;
861 }
862
863 if (have_nvmemi) {
864 if (!(have_eid && have_net)) {
865 nvme_msg(root, LOG_ERR,
866 "Missing property for %s\n", objpath);
867 errno = ENOENT;
868 return -1;
869 }
870 rc = nvme_mi_mctp_add(root, net, eid);
871 if (rc < 0) {
872 int errno_save = errno;
873 nvme_msg(root, LOG_ERR,
874 "Error adding net %d eid %d: %m\n", net, eid);
875 errno = errno_save;
876 }
877 } else {
878 /* Ignore other endpoints */
879 rc = 0;
880 }
881 return rc;
882 }
883
884 /* obj is an array of (object path, interfaces) dict entries - ie., dbus type
885 * a{oa{sa{sv}}}
886 */
887 static int handle_mctp_obj(nvme_root_t root, DBusMessageIter *obj)
888 {
889 const char *objpath = NULL;
890 DBusMessageIter intfs;
891
892 if (!dbus_object_is_type(obj, DBUS_TYPE_OBJECT_PATH)) {
893 nvme_msg(root, LOG_ERR, "error unmashalling object (path)\n");
894 return -1;
895 }
896
897 dbus_message_iter_get_basic(obj, &objpath);
898
899 dbus_message_iter_next(obj);
900
901 if (!dbus_object_is_dict(obj)) {
902 nvme_msg(root, LOG_ERR, "error unmashalling object (intfs)\n");
903 return -1;
904 }
905
906 dbus_message_iter_recurse(obj, &intfs);
907
908 /* for each interface */
909 for (;;) {
910 DBusMessageIter props, intf;
911 const char *intfname;
912
913 dbus_message_iter_recurse(&intfs, &intf);
914
915 if (!dbus_object_is_type(&intf, DBUS_TYPE_STRING)) {
916 nvme_msg(root, LOG_ERR,
917 "error unmashalling object (intf)\n");
918 return -1;
919 }
920
921 dbus_message_iter_get_basic(&intf, &intfname);
922
923 if (strcmp(intfname, MCTP_DBUS_IFACE_ENDPOINT)) {
924 if (!dbus_message_iter_next(&intfs))
925 break;
926 continue;
927 }
928
929 dbus_message_iter_next(&intf);
930
931 if (!dbus_object_is_dict(&intf)) {
932 nvme_msg(root, LOG_ERR,
933 "error unmarshalling object (props)\n");
934 return -1;
935 }
936
937 dbus_message_iter_recurse(&intf, &props);
938 return handle_mctp_endpoint(root, objpath, &props);
939 }
940
941 return 0;
942 }
943
944 nvme_root_t nvme_mi_scan_mctp(void)
945 {
946 DBusMessage *msg, *resp = NULL;
947 DBusConnection *bus = NULL;
948 DBusMessageIter args, objs;
949 int errno_save, rc = -1;
950 nvme_root_t root;
951 dbus_bool_t drc;
952 DBusError berr;
953
954 root = nvme_mi_create_root(NULL, DEFAULT_LOGLEVEL);
955 if (!root) {
956 errno = ENOMEM;
957 return NULL;
958 }
959
960 dbus_error_init(&berr);
961
962 bus = dbus_bus_get(DBUS_BUS_SYSTEM, &berr);
963 if (!bus) {
964 nvme_msg(root, LOG_ERR, "Failed connecting to D-Bus: %s (%s)\n",
965 berr.message, berr.name);
966 goto out;
967 }
968
969 msg = dbus_message_new_method_call(MCTP_DBUS_IFACE,
970 MCTP_DBUS_PATH,
971 "org.freedesktop.DBus.ObjectManager",
972 "GetManagedObjects");
973 if (!msg) {
974 nvme_msg(root, LOG_ERR, "Failed creating call message\n");
975 goto out;
976 }
977
978 resp = dbus_connection_send_with_reply_and_block(bus, msg,
979 DBUS_TIMEOUT_USE_DEFAULT,
980 &berr);
981 dbus_message_unref(msg);
982 if (!resp) {
983 nvme_msg(root, LOG_ERR, "Failed querying MCTP D-Bus: %s (%s)\n",
984 berr.message, berr.name);
985 goto out;
986 }
987
988 /* argument container */
989 drc = dbus_message_iter_init(resp, &args);
990 if (!drc) {
991 nvme_msg(root, LOG_ERR, "can't read dbus reply args\n");
992 goto out;
993 }
994
995 if (!dbus_object_is_dict(&args)) {
996 nvme_msg(root, LOG_ERR, "error unmashalling args\n");
997 goto out;
998 }
999
1000 /* objects container */
1001 dbus_message_iter_recurse(&args, &objs);
1002
1003 rc = 0;
1004
1005 for (;;) {
1006 DBusMessageIter ent;
1007
1008 dbus_message_iter_recurse(&objs, &ent);
1009
1010 rc = handle_mctp_obj(root, &ent);
1011 if (rc)
1012 break;
1013
1014 if (!dbus_message_iter_next(&objs))
1015 break;
1016 }
1017
1018 out:
1019 errno_save = errno;
1020 if (resp)
1021 dbus_message_unref(resp);
1022 if (bus)
1023 dbus_connection_unref(bus);
1024 dbus_error_free(&berr);
1025
1026 if (rc < 0) {
1027 if (root) {
1028 nvme_mi_free_root(root);
1029 }
1030 errno = errno_save;
1031 root = NULL;
1032 }
1033 return root;
1034 }
1035
1036 #else /* CONFIG_DBUS */
1037
1038 nvme_root_t nvme_mi_scan_mctp(void)
1039 {
1040 return NULL;
1041 }
1042
1043 #endif /* CONFIG_DBUS */