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, what: 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(wq_head: &call->waitq, wq_entry: &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: *timeo); |
75 | break; |
76 | } |
77 | *timeo = schedule_timeout(timeout: *timeo); |
78 | } |
79 | |
80 | remove_wait_queue(wq_head: &call->waitq, wq_entry: &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: *timeo); |
118 | |
119 | trace_rxrpc_txqueue(call, why: rxrpc_txqueue_wait); |
120 | *timeo = schedule_timeout(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(u: 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: &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, why: 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, why: rxrpc_txqueue_wait); |
181 | *timeo = schedule_timeout(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(wq_head: &call->waitq, wq_entry: &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(wq_head: &call->waitq, wq_entry: &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, why: rxrpc_txqueue_queue_last); |
256 | else |
257 | trace_rxrpc_txqueue(call, why: rxrpc_txqueue_queue); |
258 | |
259 | /* Add the packet to the call's output buffer */ |
260 | spin_lock(lock: &call->tx_lock); |
261 | poke = list_empty(head: &call->tx_sendmsg); |
262 | list_add_tail(new: &txb->call_link, head: &call->tx_sendmsg); |
263 | call->tx_prepared = seq; |
264 | if (last) |
265 | rxrpc_notify_end_tx(rx, call, notify_end_tx); |
266 | spin_unlock(lock: &call->tx_lock); |
267 | |
268 | if (poke) |
269 | rxrpc_poke_call(call, what: 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, noblock: msg->msg_flags & MSG_DONTWAIT); |
291 | |
292 | ret = rxrpc_wait_to_be_connected(call, timeo: &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_nr: call->debug_id, why: rxrpc_sendmsg_late_send, |
319 | cid: call->cid, call_id: call->call_id, seq: call->rx_consumed, |
320 | abort_code: 0, error: -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, what: 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(addr: txb->data + txb->offset, bytes: copy, |
378 | i: &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, what: 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(lock: &call->user_mutex); |
443 | *_dropped_lock = true; |
444 | ret = rxrpc_wait_for_tx_window(rx, call, timeo: &timeo, |
445 | waitall: 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(sk: &rx->sk); |
584 | return ERR_PTR(error: -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(v: &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: &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: &p); |
650 | /* The socket is now unlocked... */ |
651 | if (IS_ERR(ptr: call)) |
652 | return PTR_ERR(ptr: 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(sk: &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(m: 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(m: 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, expire_at: j, now, |
711 | why: 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, abort_code: p.abort_code, error: -ECONNABORTED, |
721 | why: 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: &dropped_lock); |
727 | } |
728 | |
729 | out_put_unlock: |
730 | if (!dropped_lock) |
731 | mutex_unlock(lock: &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(sk: &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: &dropped_lock); |
771 | if (ret == -ESHUTDOWN) |
772 | ret = call->error; |
773 | |
774 | if (!dropped_lock) |
775 | mutex_unlock(lock: &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(lock: &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 | |