Linux Audio

Check our new training course

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