xref: /openbmc/libmctp/core.c (revision a68185c4)
1 /* SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later */
2 
3 #include <assert.h>
4 #include <errno.h>
5 #include <stdarg.h>
6 #include <stddef.h>
7 #include <stdint.h>
8 #include <stdio.h>
9 #include <stdlib.h>
10 #include <string.h>
11 
12 #undef pr_fmt
13 #define pr_fmt(fmt) "core: " fmt
14 
15 #include "libmctp.h"
16 #include "libmctp-alloc.h"
17 #include "libmctp-log.h"
18 #include "libmctp-cmds.h"
19 #include "range.h"
20 
21 /* Internal data structures */
22 
23 enum mctp_bus_state {
24 	mctp_bus_state_constructed = 0,
25 	mctp_bus_state_tx_enabled,
26 	mctp_bus_state_tx_disabled,
27 };
28 
29 struct mctp_bus {
30 	mctp_eid_t eid;
31 	struct mctp_binding *binding;
32 	enum mctp_bus_state state;
33 
34 	struct mctp_pktbuf *tx_queue_head;
35 	struct mctp_pktbuf *tx_queue_tail;
36 
37 	/* todo: routing */
38 };
39 
40 struct mctp_msg_ctx {
41 	uint8_t src;
42 	uint8_t dest;
43 	uint8_t tag;
44 	uint8_t last_seq;
45 	void *buf;
46 	size_t buf_size;
47 	size_t buf_alloc_size;
48 	size_t fragment_size;
49 };
50 
51 struct mctp {
52 	int n_busses;
53 	struct mctp_bus *busses;
54 
55 	/* Message RX callback */
56 	mctp_rx_fn message_rx;
57 	void *message_rx_data;
58 
59 	/* Packet capture callback */
60 	mctp_capture_fn capture;
61 	void *capture_data;
62 
63 	/* Message reassembly.
64 	 * @todo: flexible context count
65 	 */
66 	struct mctp_msg_ctx msg_ctxs[16];
67 
68 	enum {
69 		ROUTE_ENDPOINT,
70 		ROUTE_BRIDGE,
71 	} route_policy;
72 	size_t max_message_size;
73 };
74 
75 #ifndef BUILD_ASSERT
76 #define BUILD_ASSERT(x)                                                        \
77 	do {                                                                   \
78 		(void)sizeof(char[0 - (!(x))]);                                \
79 	} while (0)
80 #endif
81 
82 #ifndef ARRAY_SIZE
83 #define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
84 #endif
85 
86 /* 64kb should be sufficient for a single message. Applications
87  * requiring higher sizes can override by setting max_message_size.*/
88 #ifndef MCTP_MAX_MESSAGE_SIZE
89 #define MCTP_MAX_MESSAGE_SIZE 65536
90 #endif
91 
92 static int mctp_message_tx_on_bus(struct mctp_bus *bus, mctp_eid_t src,
93 				  mctp_eid_t dest, bool tag_owner,
94 				  uint8_t msg_tag, void *msg, size_t msg_len);
95 
96 struct mctp_pktbuf *mctp_pktbuf_alloc(struct mctp_binding *binding, size_t len)
97 {
98 	struct mctp_pktbuf *buf;
99 	size_t size;
100 
101 	size = binding->pkt_size + binding->pkt_header + binding->pkt_trailer;
102 
103 	/* todo: pools */
104 	buf = __mctp_alloc(sizeof(*buf) + size);
105 
106 	buf->size = size;
107 	buf->start = binding->pkt_header;
108 	buf->end = buf->start + len;
109 	buf->mctp_hdr_off = buf->start;
110 	buf->next = NULL;
111 
112 	return buf;
113 }
114 
115 void mctp_pktbuf_free(struct mctp_pktbuf *pkt)
116 {
117 	__mctp_free(pkt);
118 }
119 
120 struct mctp_hdr *mctp_pktbuf_hdr(struct mctp_pktbuf *pkt)
121 {
122 	return (struct mctp_hdr *)(pkt->data + pkt->mctp_hdr_off);
123 }
124 
125 void *mctp_pktbuf_data(struct mctp_pktbuf *pkt)
126 {
127 	return pkt->data + pkt->mctp_hdr_off + sizeof(struct mctp_hdr);
128 }
129 
130 size_t mctp_pktbuf_size(struct mctp_pktbuf *pkt)
131 {
132 	return pkt->end - pkt->start;
133 }
134 
135 void *mctp_pktbuf_alloc_start(struct mctp_pktbuf *pkt, size_t size)
136 {
137 	assert(size <= pkt->start);
138 	pkt->start -= size;
139 	return pkt->data + pkt->start;
140 }
141 
142 void *mctp_pktbuf_alloc_end(struct mctp_pktbuf *pkt, size_t size)
143 {
144 	void *buf;
145 
146 	assert(size <= (pkt->size - pkt->end));
147 	buf = pkt->data + pkt->end;
148 	pkt->end += size;
149 	return buf;
150 }
151 
152 int mctp_pktbuf_push(struct mctp_pktbuf *pkt, void *data, size_t len)
153 {
154 	void *p;
155 
156 	if (pkt->end + len > pkt->size)
157 		return -1;
158 
159 	p = pkt->data + pkt->end;
160 
161 	pkt->end += len;
162 	memcpy(p, data, len);
163 
164 	return 0;
165 }
166 
167 void *mctp_pktbuf_pop(struct mctp_pktbuf *pkt, size_t len)
168 {
169 	if (len > mctp_pktbuf_size(pkt))
170 		return NULL;
171 
172 	pkt->end -= len;
173 	return pkt->data + pkt->end;
174 }
175 
176 /* Message reassembly */
177 static struct mctp_msg_ctx *mctp_msg_ctx_lookup(struct mctp *mctp, uint8_t src,
178 						uint8_t dest, uint8_t tag)
179 {
180 	unsigned int i;
181 
182 	/* @todo: better lookup, if we add support for more outstanding
183 	 * message contexts */
184 	for (i = 0; i < ARRAY_SIZE(mctp->msg_ctxs); i++) {
185 		struct mctp_msg_ctx *ctx = &mctp->msg_ctxs[i];
186 		if (ctx->src == src && ctx->dest == dest && ctx->tag == tag)
187 			return ctx;
188 	}
189 
190 	return NULL;
191 }
192 
193 static struct mctp_msg_ctx *mctp_msg_ctx_create(struct mctp *mctp, uint8_t src,
194 						uint8_t dest, uint8_t tag)
195 {
196 	struct mctp_msg_ctx *ctx = NULL;
197 	unsigned int i;
198 
199 	for (i = 0; i < ARRAY_SIZE(mctp->msg_ctxs); i++) {
200 		struct mctp_msg_ctx *tmp = &mctp->msg_ctxs[i];
201 		if (!tmp->src) {
202 			ctx = tmp;
203 			break;
204 		}
205 	}
206 
207 	if (!ctx)
208 		return NULL;
209 
210 	ctx->src = src;
211 	ctx->dest = dest;
212 	ctx->tag = tag;
213 	ctx->buf_size = 0;
214 
215 	return ctx;
216 }
217 
218 static void mctp_msg_ctx_drop(struct mctp_msg_ctx *ctx)
219 {
220 	ctx->src = 0;
221 }
222 
223 static void mctp_msg_ctx_reset(struct mctp_msg_ctx *ctx)
224 {
225 	ctx->buf_size = 0;
226 	ctx->fragment_size = 0;
227 }
228 
229 static int mctp_msg_ctx_add_pkt(struct mctp_msg_ctx *ctx,
230 				struct mctp_pktbuf *pkt, size_t max_size)
231 {
232 	size_t len;
233 
234 	len = mctp_pktbuf_size(pkt) - sizeof(struct mctp_hdr);
235 
236 	if (len + ctx->buf_size < ctx->buf_size) {
237 		return -1;
238 	}
239 
240 	if (ctx->buf_size + len > ctx->buf_alloc_size) {
241 		size_t new_alloc_size;
242 		void *lbuf;
243 
244 		/* @todo: finer-grained allocation */
245 		if (!ctx->buf_alloc_size) {
246 			new_alloc_size = MAX(len, 4096UL);
247 		} else {
248 			new_alloc_size = MAX(ctx->buf_alloc_size * 2,
249 					     len + ctx->buf_size);
250 		}
251 
252 		/* Don't allow heap to grow beyond a limit */
253 		if (new_alloc_size > max_size)
254 			return -1;
255 
256 		lbuf = __mctp_realloc(ctx->buf, new_alloc_size);
257 		if (lbuf) {
258 			ctx->buf = lbuf;
259 			ctx->buf_alloc_size = new_alloc_size;
260 		} else {
261 			__mctp_free(ctx->buf);
262 			return -1;
263 		}
264 	}
265 
266 	memcpy((uint8_t *)ctx->buf + ctx->buf_size, mctp_pktbuf_data(pkt), len);
267 	ctx->buf_size += len;
268 
269 	return 0;
270 }
271 
272 /* Core API functions */
273 struct mctp *mctp_init(void)
274 {
275 	struct mctp *mctp;
276 
277 	mctp = __mctp_alloc(sizeof(*mctp));
278 
279 	if (!mctp)
280 		return NULL;
281 
282 	memset(mctp, 0, sizeof(*mctp));
283 	mctp->max_message_size = MCTP_MAX_MESSAGE_SIZE;
284 
285 	return mctp;
286 }
287 
288 void mctp_set_max_message_size(struct mctp *mctp, size_t message_size)
289 {
290 	mctp->max_message_size = message_size;
291 }
292 
293 void mctp_set_capture_handler(struct mctp *mctp, mctp_capture_fn fn, void *user)
294 {
295 	mctp->capture = fn;
296 	mctp->capture_data = user;
297 }
298 
299 static void mctp_bus_destroy(struct mctp_bus *bus)
300 {
301 	while (bus->tx_queue_head) {
302 		struct mctp_pktbuf *curr = bus->tx_queue_head;
303 
304 		bus->tx_queue_head = curr->next;
305 		mctp_pktbuf_free(curr);
306 	}
307 }
308 
309 void mctp_destroy(struct mctp *mctp)
310 {
311 	size_t i;
312 
313 	/* Cleanup message assembly contexts */
314 	BUILD_ASSERT(ARRAY_SIZE(mctp->msg_ctxs) < SIZE_MAX);
315 	for (i = 0; i < ARRAY_SIZE(mctp->msg_ctxs); i++) {
316 		struct mctp_msg_ctx *tmp = &mctp->msg_ctxs[i];
317 		if (tmp->buf)
318 			__mctp_free(tmp->buf);
319 	}
320 
321 	while (mctp->n_busses--)
322 		mctp_bus_destroy(&mctp->busses[mctp->n_busses]);
323 
324 	__mctp_free(mctp->busses);
325 	__mctp_free(mctp);
326 }
327 
328 int mctp_set_rx_all(struct mctp *mctp, mctp_rx_fn fn, void *data)
329 {
330 	mctp->message_rx = fn;
331 	mctp->message_rx_data = data;
332 	return 0;
333 }
334 
335 static struct mctp_bus *find_bus_for_eid(struct mctp *mctp, mctp_eid_t dest
336 					 __attribute__((unused)))
337 {
338 	if (mctp->n_busses == 0)
339 		return NULL;
340 
341 	/* for now, just use the first bus. For full routing support,
342 	 * we will need a table of neighbours */
343 	return &mctp->busses[0];
344 }
345 
346 int mctp_register_bus(struct mctp *mctp, struct mctp_binding *binding,
347 		      mctp_eid_t eid)
348 {
349 	int rc = 0;
350 
351 	/* todo: multiple busses */
352 	assert(mctp->n_busses == 0);
353 	mctp->n_busses = 1;
354 
355 	mctp->busses = __mctp_alloc(sizeof(struct mctp_bus));
356 	if (!mctp->busses)
357 		return -ENOMEM;
358 
359 	memset(mctp->busses, 0, sizeof(struct mctp_bus));
360 	mctp->busses[0].binding = binding;
361 	mctp->busses[0].eid = eid;
362 	binding->bus = &mctp->busses[0];
363 	binding->mctp = mctp;
364 	mctp->route_policy = ROUTE_ENDPOINT;
365 
366 	if (binding->start) {
367 		rc = binding->start(binding);
368 		if (rc < 0) {
369 			mctp_prerr("Failed to start binding: %d", rc);
370 			binding->bus = NULL;
371 			__mctp_free(mctp->busses);
372 			mctp->busses = NULL;
373 			mctp->n_busses = 0;
374 		}
375 	}
376 
377 	return rc;
378 }
379 
380 void mctp_unregister_bus(struct mctp *mctp, struct mctp_binding *binding)
381 {
382 	/*
383 	 * We only support one bus right now; once the call completes we will
384 	 * have no more busses
385 	 */
386 	mctp->n_busses = 0;
387 	binding->mctp = NULL;
388 	binding->bus = NULL;
389 	free(mctp->busses);
390 }
391 
392 int mctp_bridge_busses(struct mctp *mctp, struct mctp_binding *b1,
393 		       struct mctp_binding *b2)
394 {
395 	int rc = 0;
396 
397 	assert(mctp->n_busses == 0);
398 	mctp->busses = __mctp_alloc(2 * sizeof(struct mctp_bus));
399 	if (!mctp->busses)
400 		return -ENOMEM;
401 	memset(mctp->busses, 0, 2 * sizeof(struct mctp_bus));
402 	mctp->n_busses = 2;
403 	mctp->busses[0].binding = b1;
404 	b1->bus = &mctp->busses[0];
405 	b1->mctp = mctp;
406 	mctp->busses[1].binding = b2;
407 	b2->bus = &mctp->busses[1];
408 	b2->mctp = mctp;
409 
410 	mctp->route_policy = ROUTE_BRIDGE;
411 
412 	if (b1->start) {
413 		rc = b1->start(b1);
414 		if (rc < 0) {
415 			mctp_prerr("Failed to start bridged bus %s: %d",
416 				   b1->name, rc);
417 			goto done;
418 		}
419 	}
420 
421 	if (b2->start) {
422 		rc = b2->start(b2);
423 		if (rc < 0) {
424 			mctp_prerr("Failed to start bridged bus %s: %d",
425 				   b2->name, rc);
426 			goto done;
427 		}
428 	}
429 
430 done:
431 	return rc;
432 }
433 
434 static inline bool mctp_ctrl_cmd_is_transport(struct mctp_ctrl_msg_hdr *hdr)
435 {
436 	return ((hdr->command_code >= MCTP_CTRL_CMD_FIRST_TRANSPORT) &&
437 		(hdr->command_code <= MCTP_CTRL_CMD_LAST_TRANSPORT));
438 }
439 
440 static bool mctp_ctrl_handle_msg(struct mctp_bus *bus, mctp_eid_t src,
441 				 uint8_t msg_tag, bool tag_owner, void *buffer,
442 				 size_t length)
443 {
444 	struct mctp_ctrl_msg_hdr *msg_hdr = buffer;
445 
446 	/*
447 	 * Control message is received. If a transport control message handler
448 	 * is provided, it will called. If there is no dedicated handler, this
449 	 * function returns false and data can be handled by the generic
450 	 * message handler. The transport control message handler will be
451 	 * provided with messages in the command range 0xF0 - 0xFF.
452 	 */
453 	if (mctp_ctrl_cmd_is_transport(msg_hdr)) {
454 		if (bus->binding->control_rx != NULL) {
455 			/* MCTP bus binding handler */
456 			bus->binding->control_rx(src, msg_tag, tag_owner,
457 						 bus->binding->control_rx_data,
458 						 buffer, length);
459 			return true;
460 		}
461 	}
462 
463 	/*
464 	 * Command was not handled, due to lack of specific callback.
465 	 * It will be passed to regular message_rx handler.
466 	 */
467 	return false;
468 }
469 
470 static inline bool mctp_rx_dest_is_local(struct mctp_bus *bus, mctp_eid_t dest)
471 {
472 	return dest == bus->eid || dest == MCTP_EID_NULL ||
473 	       dest == MCTP_EID_BROADCAST;
474 }
475 
476 static inline bool mctp_ctrl_cmd_is_request(struct mctp_ctrl_msg_hdr *hdr)
477 {
478 	return hdr->ic_msg_type == MCTP_CTRL_HDR_MSG_TYPE &&
479 	       hdr->rq_dgram_inst & MCTP_CTRL_HDR_FLAG_REQUEST;
480 }
481 
482 /*
483  * Receive the complete MCTP message and route it.
484  * Asserts:
485  *     'buf' is not NULL.
486  */
487 static void mctp_rx(struct mctp *mctp, struct mctp_bus *bus, mctp_eid_t src,
488 		    mctp_eid_t dest, bool tag_owner, uint8_t msg_tag, void *buf,
489 		    size_t len)
490 {
491 	assert(buf != NULL);
492 
493 	if (mctp->route_policy == ROUTE_ENDPOINT &&
494 	    mctp_rx_dest_is_local(bus, dest)) {
495 		/* Handle MCTP Control Messages: */
496 		if (len >= sizeof(struct mctp_ctrl_msg_hdr)) {
497 			struct mctp_ctrl_msg_hdr *msg_hdr = buf;
498 
499 			/*
500 			 * Identify if this is a control request message.
501 			 * See DSP0236 v1.3.0 sec. 11.5.
502 			 */
503 			if (mctp_ctrl_cmd_is_request(msg_hdr)) {
504 				bool handled;
505 				handled = mctp_ctrl_handle_msg(
506 					bus, src, msg_tag, tag_owner, buf, len);
507 				if (handled)
508 					return;
509 			}
510 		}
511 
512 		if (mctp->message_rx)
513 			mctp->message_rx(src, tag_owner, msg_tag,
514 					 mctp->message_rx_data, buf, len);
515 	}
516 
517 	if (mctp->route_policy == ROUTE_BRIDGE) {
518 		int i;
519 
520 		for (i = 0; i < mctp->n_busses; i++) {
521 			struct mctp_bus *dest_bus = &mctp->busses[i];
522 			if (dest_bus == bus)
523 				continue;
524 
525 			mctp_message_tx_on_bus(dest_bus, src, dest, tag_owner,
526 					       msg_tag, buf, len);
527 		}
528 	}
529 }
530 
531 void mctp_bus_rx(struct mctp_binding *binding, struct mctp_pktbuf *pkt)
532 {
533 	struct mctp_bus *bus = binding->bus;
534 	struct mctp *mctp = binding->mctp;
535 	uint8_t flags, exp_seq, seq, tag;
536 	struct mctp_msg_ctx *ctx;
537 	struct mctp_hdr *hdr;
538 	bool tag_owner;
539 	size_t len;
540 	void *p;
541 	int rc;
542 
543 	assert(bus);
544 
545 	/* Drop packet if it was smaller than mctp hdr size */
546 	if (mctp_pktbuf_size(pkt) <= sizeof(struct mctp_hdr))
547 		goto out;
548 
549 	if (mctp->capture)
550 		mctp->capture(pkt, mctp->capture_data);
551 
552 	hdr = mctp_pktbuf_hdr(pkt);
553 
554 	/* small optimisation: don't bother reassembly if we're going to
555 	 * drop the packet in mctp_rx anyway */
556 	if (mctp->route_policy == ROUTE_ENDPOINT && hdr->dest != bus->eid)
557 		goto out;
558 
559 	flags = hdr->flags_seq_tag & (MCTP_HDR_FLAG_SOM | MCTP_HDR_FLAG_EOM);
560 	tag = (hdr->flags_seq_tag >> MCTP_HDR_TAG_SHIFT) & MCTP_HDR_TAG_MASK;
561 	seq = (hdr->flags_seq_tag >> MCTP_HDR_SEQ_SHIFT) & MCTP_HDR_SEQ_MASK;
562 	tag_owner =
563 		(hdr->flags_seq_tag >> MCTP_HDR_TO_SHIFT) & MCTP_HDR_TO_MASK;
564 
565 	switch (flags) {
566 	case MCTP_HDR_FLAG_SOM | MCTP_HDR_FLAG_EOM:
567 		/* single-packet message - send straight up to rx function,
568 		 * no need to create a message context */
569 		len = pkt->end - pkt->mctp_hdr_off - sizeof(struct mctp_hdr);
570 		p = pkt->data + pkt->mctp_hdr_off + sizeof(struct mctp_hdr);
571 		mctp_rx(mctp, bus, hdr->src, hdr->dest, tag_owner, tag, p, len);
572 		break;
573 
574 	case MCTP_HDR_FLAG_SOM:
575 		/* start of a new message - start the new context for
576 		 * future message reception. If an existing context is
577 		 * already present, drop it. */
578 		ctx = mctp_msg_ctx_lookup(mctp, hdr->src, hdr->dest, tag);
579 		if (ctx) {
580 			mctp_msg_ctx_reset(ctx);
581 		} else {
582 			ctx = mctp_msg_ctx_create(mctp, hdr->src, hdr->dest,
583 						  tag);
584 			/* If context creation fails due to exhaution of contexts we
585 			* can support, drop the packet */
586 			if (!ctx) {
587 				mctp_prdebug("Context buffers exhausted.");
588 				goto out;
589 			}
590 		}
591 
592 		/* Save the fragment size, subsequent middle fragments
593 		 * should of the same size */
594 		ctx->fragment_size = mctp_pktbuf_size(pkt);
595 
596 		rc = mctp_msg_ctx_add_pkt(ctx, pkt, mctp->max_message_size);
597 		if (rc) {
598 			mctp_msg_ctx_drop(ctx);
599 		} else {
600 			ctx->last_seq = seq;
601 		}
602 
603 		break;
604 
605 	case MCTP_HDR_FLAG_EOM:
606 		ctx = mctp_msg_ctx_lookup(mctp, hdr->src, hdr->dest, tag);
607 		if (!ctx)
608 			goto out;
609 
610 		exp_seq = (ctx->last_seq + 1) % 4;
611 
612 		if (exp_seq != seq) {
613 			mctp_prdebug(
614 				"Sequence number %d does not match expected %d",
615 				seq, exp_seq);
616 			mctp_msg_ctx_drop(ctx);
617 			goto out;
618 		}
619 
620 		len = mctp_pktbuf_size(pkt);
621 
622 		if (len > ctx->fragment_size) {
623 			mctp_prdebug("Unexpected fragment size. Expected"
624 				     " less than %zu, received = %zu",
625 				     ctx->fragment_size, len);
626 			mctp_msg_ctx_drop(ctx);
627 			goto out;
628 		}
629 
630 		rc = mctp_msg_ctx_add_pkt(ctx, pkt, mctp->max_message_size);
631 		if (!rc)
632 			mctp_rx(mctp, bus, ctx->src, ctx->dest, tag_owner, tag,
633 				ctx->buf, ctx->buf_size);
634 
635 		mctp_msg_ctx_drop(ctx);
636 		break;
637 
638 	case 0:
639 		/* Neither SOM nor EOM */
640 		ctx = mctp_msg_ctx_lookup(mctp, hdr->src, hdr->dest, tag);
641 		if (!ctx)
642 			goto out;
643 
644 		exp_seq = (ctx->last_seq + 1) % 4;
645 		if (exp_seq != seq) {
646 			mctp_prdebug(
647 				"Sequence number %d does not match expected %d",
648 				seq, exp_seq);
649 			mctp_msg_ctx_drop(ctx);
650 			goto out;
651 		}
652 
653 		len = mctp_pktbuf_size(pkt);
654 
655 		if (len != ctx->fragment_size) {
656 			mctp_prdebug("Unexpected fragment size. Expected = %zu "
657 				     "received = %zu",
658 				     ctx->fragment_size, len);
659 			mctp_msg_ctx_drop(ctx);
660 			goto out;
661 		}
662 
663 		rc = mctp_msg_ctx_add_pkt(ctx, pkt, mctp->max_message_size);
664 		if (rc) {
665 			mctp_msg_ctx_drop(ctx);
666 			goto out;
667 		}
668 		ctx->last_seq = seq;
669 
670 		break;
671 	}
672 out:
673 	mctp_pktbuf_free(pkt);
674 }
675 
676 static int mctp_packet_tx(struct mctp_bus *bus, struct mctp_pktbuf *pkt)
677 {
678 	struct mctp *mctp = bus->binding->mctp;
679 
680 	if (bus->state != mctp_bus_state_tx_enabled)
681 		return -1;
682 
683 	if (mctp->capture)
684 		mctp->capture(pkt, mctp->capture_data);
685 
686 	return bus->binding->tx(bus->binding, pkt);
687 }
688 
689 static void mctp_send_tx_queue(struct mctp_bus *bus)
690 {
691 	struct mctp_pktbuf *pkt;
692 
693 	while ((pkt = bus->tx_queue_head)) {
694 		int rc;
695 
696 		rc = mctp_packet_tx(bus, pkt);
697 		switch (rc) {
698 		/* If transmission succeded, or */
699 		case 0:
700 		/* If the packet is somehow too large */
701 		case -EMSGSIZE:
702 			/* Drop the packet */
703 			bus->tx_queue_head = pkt->next;
704 			mctp_pktbuf_free(pkt);
705 			break;
706 
707 		/* If the binding was busy, or */
708 		case -EBUSY:
709 		/* Some other unknown error occurred */
710 		default:
711 			/* Make sure the tail pointer is consistent and retry later */
712 			goto cleanup_tail;
713 		};
714 	}
715 
716 cleanup_tail:
717 	if (!bus->tx_queue_head)
718 		bus->tx_queue_tail = NULL;
719 }
720 
721 void mctp_binding_set_tx_enabled(struct mctp_binding *binding, bool enable)
722 {
723 	struct mctp_bus *bus = binding->bus;
724 
725 	switch (bus->state) {
726 	case mctp_bus_state_constructed:
727 		if (!enable)
728 			return;
729 
730 		if (binding->pkt_size < MCTP_PACKET_SIZE(MCTP_BTU)) {
731 			mctp_prerr(
732 				"Cannot start %s binding with invalid MTU: %zu",
733 				binding->name,
734 				MCTP_BODY_SIZE(binding->pkt_size));
735 			return;
736 		}
737 
738 		bus->state = mctp_bus_state_tx_enabled;
739 		mctp_prinfo("%s binding started", binding->name);
740 		return;
741 	case mctp_bus_state_tx_enabled:
742 		if (enable)
743 			return;
744 
745 		bus->state = mctp_bus_state_tx_disabled;
746 		mctp_prdebug("%s binding Tx disabled", binding->name);
747 		return;
748 	case mctp_bus_state_tx_disabled:
749 		if (!enable)
750 			return;
751 
752 		bus->state = mctp_bus_state_tx_enabled;
753 		mctp_prdebug("%s binding Tx enabled", binding->name);
754 		mctp_send_tx_queue(bus);
755 		return;
756 	}
757 }
758 
759 static int mctp_message_tx_on_bus(struct mctp_bus *bus, mctp_eid_t src,
760 				  mctp_eid_t dest, bool tag_owner,
761 				  uint8_t msg_tag, void *msg, size_t msg_len)
762 {
763 	size_t max_payload_len, payload_len, p;
764 	struct mctp_pktbuf *pkt;
765 	struct mctp_hdr *hdr;
766 	int i;
767 
768 	if (bus->state == mctp_bus_state_constructed)
769 		return -ENXIO;
770 
771 	if ((msg_tag & MCTP_HDR_TAG_MASK) != msg_tag)
772 		return -EINVAL;
773 
774 	max_payload_len = MCTP_BODY_SIZE(bus->binding->pkt_size);
775 
776 	{
777 		const bool valid_mtu = max_payload_len >= MCTP_BTU;
778 		assert(valid_mtu);
779 		if (!valid_mtu)
780 			return -EINVAL;
781 	}
782 
783 	mctp_prdebug(
784 		"%s: Generating packets for transmission of %zu byte message from %hhu to %hhu",
785 		__func__, msg_len, src, dest);
786 
787 	/* queue up packets, each of max MCTP_MTU size */
788 	for (p = 0, i = 0; p < msg_len; i++) {
789 		payload_len = msg_len - p;
790 		if (payload_len > max_payload_len)
791 			payload_len = max_payload_len;
792 
793 		pkt = mctp_pktbuf_alloc(bus->binding,
794 					payload_len + sizeof(*hdr));
795 		hdr = mctp_pktbuf_hdr(pkt);
796 
797 		hdr->ver = bus->binding->version & 0xf;
798 		hdr->dest = dest;
799 		hdr->src = src;
800 		hdr->flags_seq_tag = (tag_owner << MCTP_HDR_TO_SHIFT) |
801 				     (msg_tag << MCTP_HDR_TAG_SHIFT);
802 
803 		if (i == 0)
804 			hdr->flags_seq_tag |= MCTP_HDR_FLAG_SOM;
805 		if (p + payload_len >= msg_len)
806 			hdr->flags_seq_tag |= MCTP_HDR_FLAG_EOM;
807 		hdr->flags_seq_tag |= (i & MCTP_HDR_SEQ_MASK)
808 				      << MCTP_HDR_SEQ_SHIFT;
809 
810 		memcpy(mctp_pktbuf_data(pkt), (uint8_t *)msg + p, payload_len);
811 
812 		/* add to tx queue */
813 		if (bus->tx_queue_tail)
814 			bus->tx_queue_tail->next = pkt;
815 		else
816 			bus->tx_queue_head = pkt;
817 		bus->tx_queue_tail = pkt;
818 
819 		p += payload_len;
820 	}
821 
822 	mctp_prdebug("%s: Enqueued %d packets", __func__, i);
823 
824 	mctp_send_tx_queue(bus);
825 
826 	return 0;
827 }
828 
829 int mctp_message_tx(struct mctp *mctp, mctp_eid_t eid, bool tag_owner,
830 		    uint8_t msg_tag, void *msg, size_t msg_len)
831 {
832 	struct mctp_bus *bus;
833 
834 	/* TODO: Protect against same tag being used across
835 	 * different callers */
836 	if ((msg_tag & MCTP_HDR_TAG_MASK) != msg_tag) {
837 		mctp_prerr("Incorrect message tag %u passed.", msg_tag);
838 		return -EINVAL;
839 	}
840 
841 	bus = find_bus_for_eid(mctp, eid);
842 	if (!bus)
843 		return 0;
844 
845 	return mctp_message_tx_on_bus(bus, bus->eid, eid, tag_owner, msg_tag,
846 				      msg, msg_len);
847 }
848