xref: /openbmc/linux/net/rxrpc/sendmsg.c (revision 726ccdba)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* AF_RXRPC sendmsg() implementation.
3  *
4  * Copyright (C) 2007, 2016 Red Hat, Inc. All Rights Reserved.
5  * Written by David Howells (dhowells@redhat.com)
6  */
7 
8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
9 
10 #include <linux/net.h>
11 #include <linux/gfp.h>
12 #include <linux/skbuff.h>
13 #include <linux/export.h>
14 #include <linux/sched/signal.h>
15 
16 #include <net/sock.h>
17 #include <net/af_rxrpc.h>
18 #include "ar-internal.h"
19 
20 /*
21  * Propose an abort to be made in the I/O thread.
22  */
23 bool rxrpc_propose_abort(struct rxrpc_call *call, s32 abort_code, int error,
24 			 enum rxrpc_abort_reason why)
25 {
26 	_enter("{%d},%d,%d,%u", call->debug_id, abort_code, error, why);
27 
28 	if (!call->send_abort && !rxrpc_call_is_complete(call)) {
29 		call->send_abort_why = why;
30 		call->send_abort_err = error;
31 		call->send_abort_seq = 0;
32 		/* Request abort locklessly vs rxrpc_input_call_event(). */
33 		smp_store_release(&call->send_abort, abort_code);
34 		rxrpc_poke_call(call, rxrpc_call_poke_abort);
35 		return true;
36 	}
37 
38 	return false;
39 }
40 
41 /*
42  * Wait for a call to become connected.  Interruption here doesn't cause the
43  * call to be aborted.
44  */
45 static int rxrpc_wait_to_be_connected(struct rxrpc_call *call, long *timeo)
46 {
47 	DECLARE_WAITQUEUE(myself, current);
48 	int ret = 0;
49 
50 	_enter("%d", call->debug_id);
51 
52 	if (rxrpc_call_state(call) != RXRPC_CALL_CLIENT_AWAIT_CONN)
53 		goto no_wait;
54 
55 	add_wait_queue_exclusive(&call->waitq, &myself);
56 
57 	for (;;) {
58 		switch (call->interruptibility) {
59 		case RXRPC_INTERRUPTIBLE:
60 		case RXRPC_PREINTERRUPTIBLE:
61 			set_current_state(TASK_INTERRUPTIBLE);
62 			break;
63 		case RXRPC_UNINTERRUPTIBLE:
64 		default:
65 			set_current_state(TASK_UNINTERRUPTIBLE);
66 			break;
67 		}
68 
69 		if (rxrpc_call_state(call) != RXRPC_CALL_CLIENT_AWAIT_CONN)
70 			break;
71 		if ((call->interruptibility == RXRPC_INTERRUPTIBLE ||
72 		     call->interruptibility == RXRPC_PREINTERRUPTIBLE) &&
73 		    signal_pending(current)) {
74 			ret = sock_intr_errno(*timeo);
75 			break;
76 		}
77 		*timeo = schedule_timeout(*timeo);
78 	}
79 
80 	remove_wait_queue(&call->waitq, &myself);
81 	__set_current_state(TASK_RUNNING);
82 
83 no_wait:
84 	if (ret == 0 && rxrpc_call_is_complete(call))
85 		ret = call->error;
86 
87 	_leave(" = %d", ret);
88 	return ret;
89 }
90 
91 /*
92  * Return true if there's sufficient Tx queue space.
93  */
94 static bool rxrpc_check_tx_space(struct rxrpc_call *call, rxrpc_seq_t *_tx_win)
95 {
96 	if (_tx_win)
97 		*_tx_win = call->tx_bottom;
98 	return call->tx_prepared - call->tx_bottom < 256;
99 }
100 
101 /*
102  * Wait for space to appear in the Tx queue or a signal to occur.
103  */
104 static int rxrpc_wait_for_tx_window_intr(struct rxrpc_sock *rx,
105 					 struct rxrpc_call *call,
106 					 long *timeo)
107 {
108 	for (;;) {
109 		set_current_state(TASK_INTERRUPTIBLE);
110 		if (rxrpc_check_tx_space(call, NULL))
111 			return 0;
112 
113 		if (rxrpc_call_is_complete(call))
114 			return call->error;
115 
116 		if (signal_pending(current))
117 			return sock_intr_errno(*timeo);
118 
119 		trace_rxrpc_txqueue(call, rxrpc_txqueue_wait);
120 		*timeo = schedule_timeout(*timeo);
121 	}
122 }
123 
124 /*
125  * Wait for space to appear in the Tx queue uninterruptibly, but with
126  * a timeout of 2*RTT if no progress was made and a signal occurred.
127  */
128 static int rxrpc_wait_for_tx_window_waitall(struct rxrpc_sock *rx,
129 					    struct rxrpc_call *call)
130 {
131 	rxrpc_seq_t tx_start, tx_win;
132 	signed long rtt, timeout;
133 
134 	rtt = READ_ONCE(call->peer->srtt_us) >> 3;
135 	rtt = usecs_to_jiffies(rtt) * 2;
136 	if (rtt < 2)
137 		rtt = 2;
138 
139 	timeout = rtt;
140 	tx_start = smp_load_acquire(&call->acks_hard_ack);
141 
142 	for (;;) {
143 		set_current_state(TASK_UNINTERRUPTIBLE);
144 
145 		if (rxrpc_check_tx_space(call, &tx_win))
146 			return 0;
147 
148 		if (rxrpc_call_is_complete(call))
149 			return call->error;
150 
151 		if (timeout == 0 &&
152 		    tx_win == tx_start && signal_pending(current))
153 			return -EINTR;
154 
155 		if (tx_win != tx_start) {
156 			timeout = rtt;
157 			tx_start = tx_win;
158 		}
159 
160 		trace_rxrpc_txqueue(call, rxrpc_txqueue_wait);
161 		timeout = schedule_timeout(timeout);
162 	}
163 }
164 
165 /*
166  * Wait for space to appear in the Tx queue uninterruptibly.
167  */
168 static int rxrpc_wait_for_tx_window_nonintr(struct rxrpc_sock *rx,
169 					    struct rxrpc_call *call,
170 					    long *timeo)
171 {
172 	for (;;) {
173 		set_current_state(TASK_UNINTERRUPTIBLE);
174 		if (rxrpc_check_tx_space(call, NULL))
175 			return 0;
176 
177 		if (rxrpc_call_is_complete(call))
178 			return call->error;
179 
180 		trace_rxrpc_txqueue(call, rxrpc_txqueue_wait);
181 		*timeo = schedule_timeout(*timeo);
182 	}
183 }
184 
185 /*
186  * wait for space to appear in the transmit/ACK window
187  * - caller holds the socket locked
188  */
189 static int rxrpc_wait_for_tx_window(struct rxrpc_sock *rx,
190 				    struct rxrpc_call *call,
191 				    long *timeo,
192 				    bool waitall)
193 {
194 	DECLARE_WAITQUEUE(myself, current);
195 	int ret;
196 
197 	_enter(",{%u,%u,%u,%u}",
198 	       call->tx_bottom, call->acks_hard_ack, call->tx_top, call->tx_winsize);
199 
200 	add_wait_queue(&call->waitq, &myself);
201 
202 	switch (call->interruptibility) {
203 	case RXRPC_INTERRUPTIBLE:
204 		if (waitall)
205 			ret = rxrpc_wait_for_tx_window_waitall(rx, call);
206 		else
207 			ret = rxrpc_wait_for_tx_window_intr(rx, call, timeo);
208 		break;
209 	case RXRPC_PREINTERRUPTIBLE:
210 	case RXRPC_UNINTERRUPTIBLE:
211 	default:
212 		ret = rxrpc_wait_for_tx_window_nonintr(rx, call, timeo);
213 		break;
214 	}
215 
216 	remove_wait_queue(&call->waitq, &myself);
217 	set_current_state(TASK_RUNNING);
218 	_leave(" = %d", ret);
219 	return ret;
220 }
221 
222 /*
223  * Notify the owner of the call that the transmit phase is ended and the last
224  * packet has been queued.
225  */
226 static void rxrpc_notify_end_tx(struct rxrpc_sock *rx, struct rxrpc_call *call,
227 				rxrpc_notify_end_tx_t notify_end_tx)
228 {
229 	if (notify_end_tx)
230 		notify_end_tx(&rx->sk, call, call->user_call_ID);
231 }
232 
233 /*
234  * Queue a DATA packet for transmission, set the resend timeout and send
235  * the packet immediately.  Returns the error from rxrpc_send_data_packet()
236  * in case the caller wants to do something with it.
237  */
238 static void rxrpc_queue_packet(struct rxrpc_sock *rx, struct rxrpc_call *call,
239 			       struct rxrpc_txbuf *txb,
240 			       rxrpc_notify_end_tx_t notify_end_tx)
241 {
242 	rxrpc_seq_t seq = txb->seq;
243 	bool last = test_bit(RXRPC_TXBUF_LAST, &txb->flags), poke;
244 
245 	rxrpc_inc_stat(call->rxnet, stat_tx_data);
246 
247 	ASSERTCMP(txb->seq, ==, call->tx_prepared + 1);
248 
249 	/* We have to set the timestamp before queueing as the retransmit
250 	 * algorithm can see the packet as soon as we queue it.
251 	 */
252 	txb->last_sent = ktime_get_real();
253 
254 	if (last)
255 		trace_rxrpc_txqueue(call, rxrpc_txqueue_queue_last);
256 	else
257 		trace_rxrpc_txqueue(call, rxrpc_txqueue_queue);
258 
259 	/* Add the packet to the call's output buffer */
260 	spin_lock(&call->tx_lock);
261 	poke = list_empty(&call->tx_sendmsg);
262 	list_add_tail(&txb->call_link, &call->tx_sendmsg);
263 	call->tx_prepared = seq;
264 	if (last)
265 		rxrpc_notify_end_tx(rx, call, notify_end_tx);
266 	spin_unlock(&call->tx_lock);
267 
268 	if (poke)
269 		rxrpc_poke_call(call, rxrpc_call_poke_start);
270 }
271 
272 /*
273  * send data through a socket
274  * - must be called in process context
275  * - The caller holds the call user access mutex, but not the socket lock.
276  */
277 static int rxrpc_send_data(struct rxrpc_sock *rx,
278 			   struct rxrpc_call *call,
279 			   struct msghdr *msg, size_t len,
280 			   rxrpc_notify_end_tx_t notify_end_tx,
281 			   bool *_dropped_lock)
282 {
283 	struct rxrpc_txbuf *txb;
284 	struct sock *sk = &rx->sk;
285 	enum rxrpc_call_state state;
286 	long timeo;
287 	bool more = msg->msg_flags & MSG_MORE;
288 	int ret, copied = 0;
289 
290 	timeo = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT);
291 
292 	ret = rxrpc_wait_to_be_connected(call, &timeo);
293 	if (ret < 0)
294 		return ret;
295 
296 	if (call->conn->state == RXRPC_CONN_CLIENT_UNSECURED) {
297 		ret = rxrpc_init_client_conn_security(call->conn);
298 		if (ret < 0)
299 			return ret;
300 	}
301 
302 	/* this should be in poll */
303 	sk_clear_bit(SOCKWQ_ASYNC_NOSPACE, sk);
304 
305 reload:
306 	ret = -EPIPE;
307 	if (sk->sk_shutdown & SEND_SHUTDOWN)
308 		goto maybe_error;
309 	state = rxrpc_call_state(call);
310 	ret = -ESHUTDOWN;
311 	if (state >= RXRPC_CALL_COMPLETE)
312 		goto maybe_error;
313 	ret = -EPROTO;
314 	if (state != RXRPC_CALL_CLIENT_SEND_REQUEST &&
315 	    state != RXRPC_CALL_SERVER_ACK_REQUEST &&
316 	    state != RXRPC_CALL_SERVER_SEND_REPLY) {
317 		/* Request phase complete for this client call */
318 		trace_rxrpc_abort(call->debug_id, rxrpc_sendmsg_late_send,
319 				  call->cid, call->call_id, call->rx_consumed,
320 				  0, -EPROTO);
321 		goto maybe_error;
322 	}
323 
324 	ret = -EMSGSIZE;
325 	if (call->tx_total_len != -1) {
326 		if (len - copied > call->tx_total_len)
327 			goto maybe_error;
328 		if (!more && len - copied != call->tx_total_len)
329 			goto maybe_error;
330 	}
331 
332 	txb = call->tx_pending;
333 	call->tx_pending = NULL;
334 	if (txb)
335 		rxrpc_see_txbuf(txb, rxrpc_txbuf_see_send_more);
336 
337 	do {
338 		if (!txb) {
339 			size_t remain, bufsize, chunk, offset;
340 
341 			_debug("alloc");
342 
343 			if (!rxrpc_check_tx_space(call, NULL))
344 				goto wait_for_space;
345 
346 			/* Work out the maximum size of a packet.  Assume that
347 			 * the security header is going to be in the padded
348 			 * region (enc blocksize), but the trailer is not.
349 			 */
350 			remain = more ? INT_MAX : msg_data_left(msg);
351 			ret = call->conn->security->how_much_data(call, remain,
352 								  &bufsize, &chunk, &offset);
353 			if (ret < 0)
354 				goto maybe_error;
355 
356 			_debug("SIZE: %zu/%zu @%zu", chunk, bufsize, offset);
357 
358 			/* create a buffer that we can retain until it's ACK'd */
359 			ret = -ENOMEM;
360 			txb = rxrpc_alloc_txbuf(call, RXRPC_PACKET_TYPE_DATA,
361 						GFP_KERNEL);
362 			if (!txb)
363 				goto maybe_error;
364 
365 			txb->offset = offset;
366 			txb->space -= offset;
367 			txb->space = min_t(size_t, chunk, txb->space);
368 		}
369 
370 		_debug("append");
371 
372 		/* append next segment of data to the current buffer */
373 		if (msg_data_left(msg) > 0) {
374 			size_t copy = min_t(size_t, txb->space, msg_data_left(msg));
375 
376 			_debug("add %zu", copy);
377 			if (!copy_from_iter_full(txb->data + txb->offset, copy,
378 						 &msg->msg_iter))
379 				goto efault;
380 			_debug("added");
381 			txb->space -= copy;
382 			txb->len += copy;
383 			txb->offset += copy;
384 			copied += copy;
385 			if (call->tx_total_len != -1)
386 				call->tx_total_len -= copy;
387 		}
388 
389 		/* check for the far side aborting the call or a network error
390 		 * occurring */
391 		if (rxrpc_call_is_complete(call))
392 			goto call_terminated;
393 
394 		/* add the packet to the send queue if it's now full */
395 		if (!txb->space ||
396 		    (msg_data_left(msg) == 0 && !more)) {
397 			if (msg_data_left(msg) == 0 && !more) {
398 				txb->wire.flags |= RXRPC_LAST_PACKET;
399 				__set_bit(RXRPC_TXBUF_LAST, &txb->flags);
400 			}
401 			else if (call->tx_top - call->acks_hard_ack <
402 				 call->tx_winsize)
403 				txb->wire.flags |= RXRPC_MORE_PACKETS;
404 
405 			ret = call->security->secure_packet(call, txb);
406 			if (ret < 0)
407 				goto out;
408 
409 			rxrpc_queue_packet(rx, call, txb, notify_end_tx);
410 			txb = NULL;
411 		}
412 	} while (msg_data_left(msg) > 0);
413 
414 success:
415 	ret = copied;
416 	if (rxrpc_call_is_complete(call) &&
417 	    call->error < 0)
418 		ret = call->error;
419 out:
420 	call->tx_pending = txb;
421 	_leave(" = %d", ret);
422 	return ret;
423 
424 call_terminated:
425 	rxrpc_put_txbuf(txb, rxrpc_txbuf_put_send_aborted);
426 	_leave(" = %d", call->error);
427 	return call->error;
428 
429 maybe_error:
430 	if (copied)
431 		goto success;
432 	goto out;
433 
434 efault:
435 	ret = -EFAULT;
436 	goto out;
437 
438 wait_for_space:
439 	ret = -EAGAIN;
440 	if (msg->msg_flags & MSG_DONTWAIT)
441 		goto maybe_error;
442 	mutex_unlock(&call->user_mutex);
443 	*_dropped_lock = true;
444 	ret = rxrpc_wait_for_tx_window(rx, call, &timeo,
445 				       msg->msg_flags & MSG_WAITALL);
446 	if (ret < 0)
447 		goto maybe_error;
448 	if (call->interruptibility == RXRPC_INTERRUPTIBLE) {
449 		if (mutex_lock_interruptible(&call->user_mutex) < 0) {
450 			ret = sock_intr_errno(timeo);
451 			goto maybe_error;
452 		}
453 	} else {
454 		mutex_lock(&call->user_mutex);
455 	}
456 	*_dropped_lock = false;
457 	goto reload;
458 }
459 
460 /*
461  * extract control messages from the sendmsg() control buffer
462  */
463 static int rxrpc_sendmsg_cmsg(struct msghdr *msg, struct rxrpc_send_params *p)
464 {
465 	struct cmsghdr *cmsg;
466 	bool got_user_ID = false;
467 	int len;
468 
469 	if (msg->msg_controllen == 0)
470 		return -EINVAL;
471 
472 	for_each_cmsghdr(cmsg, msg) {
473 		if (!CMSG_OK(msg, cmsg))
474 			return -EINVAL;
475 
476 		len = cmsg->cmsg_len - sizeof(struct cmsghdr);
477 		_debug("CMSG %d, %d, %d",
478 		       cmsg->cmsg_level, cmsg->cmsg_type, len);
479 
480 		if (cmsg->cmsg_level != SOL_RXRPC)
481 			continue;
482 
483 		switch (cmsg->cmsg_type) {
484 		case RXRPC_USER_CALL_ID:
485 			if (msg->msg_flags & MSG_CMSG_COMPAT) {
486 				if (len != sizeof(u32))
487 					return -EINVAL;
488 				p->call.user_call_ID = *(u32 *)CMSG_DATA(cmsg);
489 			} else {
490 				if (len != sizeof(unsigned long))
491 					return -EINVAL;
492 				p->call.user_call_ID = *(unsigned long *)
493 					CMSG_DATA(cmsg);
494 			}
495 			got_user_ID = true;
496 			break;
497 
498 		case RXRPC_ABORT:
499 			if (p->command != RXRPC_CMD_SEND_DATA)
500 				return -EINVAL;
501 			p->command = RXRPC_CMD_SEND_ABORT;
502 			if (len != sizeof(p->abort_code))
503 				return -EINVAL;
504 			p->abort_code = *(unsigned int *)CMSG_DATA(cmsg);
505 			if (p->abort_code == 0)
506 				return -EINVAL;
507 			break;
508 
509 		case RXRPC_CHARGE_ACCEPT:
510 			if (p->command != RXRPC_CMD_SEND_DATA)
511 				return -EINVAL;
512 			p->command = RXRPC_CMD_CHARGE_ACCEPT;
513 			if (len != 0)
514 				return -EINVAL;
515 			break;
516 
517 		case RXRPC_EXCLUSIVE_CALL:
518 			p->exclusive = true;
519 			if (len != 0)
520 				return -EINVAL;
521 			break;
522 
523 		case RXRPC_UPGRADE_SERVICE:
524 			p->upgrade = true;
525 			if (len != 0)
526 				return -EINVAL;
527 			break;
528 
529 		case RXRPC_TX_LENGTH:
530 			if (p->call.tx_total_len != -1 || len != sizeof(__s64))
531 				return -EINVAL;
532 			p->call.tx_total_len = *(__s64 *)CMSG_DATA(cmsg);
533 			if (p->call.tx_total_len < 0)
534 				return -EINVAL;
535 			break;
536 
537 		case RXRPC_SET_CALL_TIMEOUT:
538 			if (len & 3 || len < 4 || len > 12)
539 				return -EINVAL;
540 			memcpy(&p->call.timeouts, CMSG_DATA(cmsg), len);
541 			p->call.nr_timeouts = len / 4;
542 			if (p->call.timeouts.hard > INT_MAX / HZ)
543 				return -ERANGE;
544 			if (p->call.nr_timeouts >= 2 && p->call.timeouts.idle > 60 * 60 * 1000)
545 				return -ERANGE;
546 			if (p->call.nr_timeouts >= 3 && p->call.timeouts.normal > 60 * 60 * 1000)
547 				return -ERANGE;
548 			break;
549 
550 		default:
551 			return -EINVAL;
552 		}
553 	}
554 
555 	if (!got_user_ID)
556 		return -EINVAL;
557 	if (p->call.tx_total_len != -1 && p->command != RXRPC_CMD_SEND_DATA)
558 		return -EINVAL;
559 	_leave(" = 0");
560 	return 0;
561 }
562 
563 /*
564  * Create a new client call for sendmsg().
565  * - Called with the socket lock held, which it must release.
566  * - If it returns a call, the call's lock will need releasing by the caller.
567  */
568 static struct rxrpc_call *
569 rxrpc_new_client_call_for_sendmsg(struct rxrpc_sock *rx, struct msghdr *msg,
570 				  struct rxrpc_send_params *p)
571 	__releases(&rx->sk.sk_lock.slock)
572 	__acquires(&call->user_mutex)
573 {
574 	struct rxrpc_conn_parameters cp;
575 	struct rxrpc_call *call;
576 	struct key *key;
577 
578 	DECLARE_SOCKADDR(struct sockaddr_rxrpc *, srx, msg->msg_name);
579 
580 	_enter("");
581 
582 	if (!msg->msg_name) {
583 		release_sock(&rx->sk);
584 		return ERR_PTR(-EDESTADDRREQ);
585 	}
586 
587 	key = rx->key;
588 	if (key && !rx->key->payload.data[0])
589 		key = NULL;
590 
591 	memset(&cp, 0, sizeof(cp));
592 	cp.local		= rx->local;
593 	cp.key			= rx->key;
594 	cp.security_level	= rx->min_sec_level;
595 	cp.exclusive		= rx->exclusive | p->exclusive;
596 	cp.upgrade		= p->upgrade;
597 	cp.service_id		= srx->srx_service;
598 	call = rxrpc_new_client_call(rx, &cp, srx, &p->call, GFP_KERNEL,
599 				     atomic_inc_return(&rxrpc_debug_id));
600 	/* The socket is now unlocked */
601 
602 	_leave(" = %p\n", call);
603 	return call;
604 }
605 
606 /*
607  * send a message forming part of a client call through an RxRPC socket
608  * - caller holds the socket locked
609  * - the socket may be either a client socket or a server socket
610  */
611 int rxrpc_do_sendmsg(struct rxrpc_sock *rx, struct msghdr *msg, size_t len)
612 	__releases(&rx->sk.sk_lock.slock)
613 {
614 	struct rxrpc_call *call;
615 	unsigned long now, j;
616 	bool dropped_lock = false;
617 	int ret;
618 
619 	struct rxrpc_send_params p = {
620 		.call.tx_total_len	= -1,
621 		.call.user_call_ID	= 0,
622 		.call.nr_timeouts	= 0,
623 		.call.interruptibility	= RXRPC_INTERRUPTIBLE,
624 		.abort_code		= 0,
625 		.command		= RXRPC_CMD_SEND_DATA,
626 		.exclusive		= false,
627 		.upgrade		= false,
628 	};
629 
630 	_enter("");
631 
632 	ret = rxrpc_sendmsg_cmsg(msg, &p);
633 	if (ret < 0)
634 		goto error_release_sock;
635 
636 	if (p.command == RXRPC_CMD_CHARGE_ACCEPT) {
637 		ret = -EINVAL;
638 		if (rx->sk.sk_state != RXRPC_SERVER_LISTENING)
639 			goto error_release_sock;
640 		ret = rxrpc_user_charge_accept(rx, p.call.user_call_ID);
641 		goto error_release_sock;
642 	}
643 
644 	call = rxrpc_find_call_by_user_ID(rx, p.call.user_call_ID);
645 	if (!call) {
646 		ret = -EBADSLT;
647 		if (p.command != RXRPC_CMD_SEND_DATA)
648 			goto error_release_sock;
649 		call = rxrpc_new_client_call_for_sendmsg(rx, msg, &p);
650 		/* The socket is now unlocked... */
651 		if (IS_ERR(call))
652 			return PTR_ERR(call);
653 		/* ... and we have the call lock. */
654 		p.call.nr_timeouts = 0;
655 		ret = 0;
656 		if (rxrpc_call_is_complete(call))
657 			goto out_put_unlock;
658 	} else {
659 		switch (rxrpc_call_state(call)) {
660 		case RXRPC_CALL_CLIENT_AWAIT_CONN:
661 		case RXRPC_CALL_SERVER_SECURING:
662 			if (p.command == RXRPC_CMD_SEND_ABORT)
663 				break;
664 			fallthrough;
665 		case RXRPC_CALL_UNINITIALISED:
666 		case RXRPC_CALL_SERVER_PREALLOC:
667 			rxrpc_put_call(call, rxrpc_call_put_sendmsg);
668 			ret = -EBUSY;
669 			goto error_release_sock;
670 		default:
671 			break;
672 		}
673 
674 		ret = mutex_lock_interruptible(&call->user_mutex);
675 		release_sock(&rx->sk);
676 		if (ret < 0) {
677 			ret = -ERESTARTSYS;
678 			goto error_put;
679 		}
680 
681 		if (p.call.tx_total_len != -1) {
682 			ret = -EINVAL;
683 			if (call->tx_total_len != -1 ||
684 			    call->tx_pending ||
685 			    call->tx_top != 0)
686 				goto out_put_unlock;
687 			call->tx_total_len = p.call.tx_total_len;
688 		}
689 	}
690 
691 	switch (p.call.nr_timeouts) {
692 	case 3:
693 		j = msecs_to_jiffies(p.call.timeouts.normal);
694 		if (p.call.timeouts.normal > 0 && j == 0)
695 			j = 1;
696 		WRITE_ONCE(call->next_rx_timo, j);
697 		fallthrough;
698 	case 2:
699 		j = msecs_to_jiffies(p.call.timeouts.idle);
700 		if (p.call.timeouts.idle > 0 && j == 0)
701 			j = 1;
702 		WRITE_ONCE(call->next_req_timo, j);
703 		fallthrough;
704 	case 1:
705 		if (p.call.timeouts.hard > 0) {
706 			j = p.call.timeouts.hard * HZ;
707 			now = jiffies;
708 			j += now;
709 			WRITE_ONCE(call->expect_term_by, j);
710 			rxrpc_reduce_call_timer(call, j, now,
711 						rxrpc_timer_set_for_hard);
712 		}
713 		break;
714 	}
715 
716 	if (rxrpc_call_is_complete(call)) {
717 		/* it's too late for this call */
718 		ret = -ESHUTDOWN;
719 	} else if (p.command == RXRPC_CMD_SEND_ABORT) {
720 		rxrpc_propose_abort(call, p.abort_code, -ECONNABORTED,
721 				    rxrpc_abort_call_sendmsg);
722 		ret = 0;
723 	} else if (p.command != RXRPC_CMD_SEND_DATA) {
724 		ret = -EINVAL;
725 	} else {
726 		ret = rxrpc_send_data(rx, call, msg, len, NULL, &dropped_lock);
727 	}
728 
729 out_put_unlock:
730 	if (!dropped_lock)
731 		mutex_unlock(&call->user_mutex);
732 error_put:
733 	rxrpc_put_call(call, rxrpc_call_put_sendmsg);
734 	_leave(" = %d", ret);
735 	return ret;
736 
737 error_release_sock:
738 	release_sock(&rx->sk);
739 	return ret;
740 }
741 
742 /**
743  * rxrpc_kernel_send_data - Allow a kernel service to send data on a call
744  * @sock: The socket the call is on
745  * @call: The call to send data through
746  * @msg: The data to send
747  * @len: The amount of data to send
748  * @notify_end_tx: Notification that the last packet is queued.
749  *
750  * Allow a kernel service to send data on a call.  The call must be in an state
751  * appropriate to sending data.  No control data should be supplied in @msg,
752  * nor should an address be supplied.  MSG_MORE should be flagged if there's
753  * more data to come, otherwise this data will end the transmission phase.
754  */
755 int rxrpc_kernel_send_data(struct socket *sock, struct rxrpc_call *call,
756 			   struct msghdr *msg, size_t len,
757 			   rxrpc_notify_end_tx_t notify_end_tx)
758 {
759 	bool dropped_lock = false;
760 	int ret;
761 
762 	_enter("{%d},", call->debug_id);
763 
764 	ASSERTCMP(msg->msg_name, ==, NULL);
765 	ASSERTCMP(msg->msg_control, ==, NULL);
766 
767 	mutex_lock(&call->user_mutex);
768 
769 	ret = rxrpc_send_data(rxrpc_sk(sock->sk), call, msg, len,
770 			      notify_end_tx, &dropped_lock);
771 	if (ret == -ESHUTDOWN)
772 		ret = call->error;
773 
774 	if (!dropped_lock)
775 		mutex_unlock(&call->user_mutex);
776 	_leave(" = %d", ret);
777 	return ret;
778 }
779 EXPORT_SYMBOL(rxrpc_kernel_send_data);
780 
781 /**
782  * rxrpc_kernel_abort_call - Allow a kernel service to abort a call
783  * @sock: The socket the call is on
784  * @call: The call to be aborted
785  * @abort_code: The abort code to stick into the ABORT packet
786  * @error: Local error value
787  * @why: Indication as to why.
788  *
789  * Allow a kernel service to abort a call, if it's still in an abortable state
790  * and return true if the call was aborted, false if it was already complete.
791  */
792 bool rxrpc_kernel_abort_call(struct socket *sock, struct rxrpc_call *call,
793 			     u32 abort_code, int error, enum rxrpc_abort_reason why)
794 {
795 	bool aborted;
796 
797 	_enter("{%d},%d,%d,%u", call->debug_id, abort_code, error, why);
798 
799 	mutex_lock(&call->user_mutex);
800 	aborted = rxrpc_propose_abort(call, abort_code, error, why);
801 	mutex_unlock(&call->user_mutex);
802 	return aborted;
803 }
804 EXPORT_SYMBOL(rxrpc_kernel_abort_call);
805 
806 /**
807  * rxrpc_kernel_set_tx_length - Set the total Tx length on a call
808  * @sock: The socket the call is on
809  * @call: The call to be informed
810  * @tx_total_len: The amount of data to be transmitted for this call
811  *
812  * Allow a kernel service to set the total transmit length on a call.  This
813  * allows buffer-to-packet encrypt-and-copy to be performed.
814  *
815  * This function is primarily for use for setting the reply length since the
816  * request length can be set when beginning the call.
817  */
818 void rxrpc_kernel_set_tx_length(struct socket *sock, struct rxrpc_call *call,
819 				s64 tx_total_len)
820 {
821 	WARN_ON(call->tx_total_len != -1);
822 	call->tx_total_len = tx_total_len;
823 }
824 EXPORT_SYMBOL(rxrpc_kernel_set_tx_length);
825