recvmsg.c 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /* RxRPC recvmsg() implementation
  3. *
  4. * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
  5. * Written by David Howells (dhowells@redhat.com)
  6. */
  7. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  8. #include <linux/net.h>
  9. #include <linux/skbuff.h>
  10. #include <linux/export.h>
  11. #include <linux/sched/signal.h>
  12. #include <net/sock.h>
  13. #include <net/af_rxrpc.h>
  14. #include "ar-internal.h"
  15. /*
  16. * Post a call for attention by the socket or kernel service. Further
  17. * notifications are suppressed by putting recvmsg_link on a dummy queue.
  18. */
  19. void rxrpc_notify_socket(struct rxrpc_call *call)
  20. {
  21. struct rxrpc_sock *rx;
  22. struct sock *sk;
  23. _enter("%d", call->debug_id);
  24. if (!list_empty(&call->recvmsg_link))
  25. return;
  26. rcu_read_lock();
  27. rx = rcu_dereference(call->socket);
  28. sk = &rx->sk;
  29. if (rx && sk->sk_state < RXRPC_CLOSE) {
  30. if (call->notify_rx) {
  31. spin_lock_bh(&call->notify_lock);
  32. call->notify_rx(sk, call, call->user_call_ID);
  33. spin_unlock_bh(&call->notify_lock);
  34. } else {
  35. write_lock_bh(&rx->recvmsg_lock);
  36. if (list_empty(&call->recvmsg_link)) {
  37. rxrpc_get_call(call, rxrpc_call_got);
  38. list_add_tail(&call->recvmsg_link, &rx->recvmsg_q);
  39. }
  40. write_unlock_bh(&rx->recvmsg_lock);
  41. if (!sock_flag(sk, SOCK_DEAD)) {
  42. _debug("call %ps", sk->sk_data_ready);
  43. sk->sk_data_ready(sk);
  44. }
  45. }
  46. }
  47. rcu_read_unlock();
  48. _leave("");
  49. }
  50. /*
  51. * Transition a call to the complete state.
  52. */
  53. bool __rxrpc_set_call_completion(struct rxrpc_call *call,
  54. enum rxrpc_call_completion compl,
  55. u32 abort_code,
  56. int error)
  57. {
  58. if (call->state < RXRPC_CALL_COMPLETE) {
  59. call->abort_code = abort_code;
  60. call->error = error;
  61. call->completion = compl,
  62. call->state = RXRPC_CALL_COMPLETE;
  63. trace_rxrpc_call_complete(call);
  64. wake_up(&call->waitq);
  65. rxrpc_notify_socket(call);
  66. return true;
  67. }
  68. return false;
  69. }
  70. bool rxrpc_set_call_completion(struct rxrpc_call *call,
  71. enum rxrpc_call_completion compl,
  72. u32 abort_code,
  73. int error)
  74. {
  75. bool ret = false;
  76. if (call->state < RXRPC_CALL_COMPLETE) {
  77. write_lock_bh(&call->state_lock);
  78. ret = __rxrpc_set_call_completion(call, compl, abort_code, error);
  79. write_unlock_bh(&call->state_lock);
  80. }
  81. return ret;
  82. }
  83. /*
  84. * Record that a call successfully completed.
  85. */
  86. bool __rxrpc_call_completed(struct rxrpc_call *call)
  87. {
  88. return __rxrpc_set_call_completion(call, RXRPC_CALL_SUCCEEDED, 0, 0);
  89. }
  90. bool rxrpc_call_completed(struct rxrpc_call *call)
  91. {
  92. bool ret = false;
  93. if (call->state < RXRPC_CALL_COMPLETE) {
  94. write_lock_bh(&call->state_lock);
  95. ret = __rxrpc_call_completed(call);
  96. write_unlock_bh(&call->state_lock);
  97. }
  98. return ret;
  99. }
  100. /*
  101. * Record that a call is locally aborted.
  102. */
  103. bool __rxrpc_abort_call(const char *why, struct rxrpc_call *call,
  104. rxrpc_seq_t seq, u32 abort_code, int error)
  105. {
  106. trace_rxrpc_abort(call->debug_id, why, call->cid, call->call_id, seq,
  107. abort_code, error);
  108. return __rxrpc_set_call_completion(call, RXRPC_CALL_LOCALLY_ABORTED,
  109. abort_code, error);
  110. }
  111. bool rxrpc_abort_call(const char *why, struct rxrpc_call *call,
  112. rxrpc_seq_t seq, u32 abort_code, int error)
  113. {
  114. bool ret;
  115. write_lock_bh(&call->state_lock);
  116. ret = __rxrpc_abort_call(why, call, seq, abort_code, error);
  117. write_unlock_bh(&call->state_lock);
  118. return ret;
  119. }
  120. /*
  121. * Pass a call terminating message to userspace.
  122. */
  123. static int rxrpc_recvmsg_term(struct rxrpc_call *call, struct msghdr *msg)
  124. {
  125. u32 tmp = 0;
  126. int ret;
  127. switch (call->completion) {
  128. case RXRPC_CALL_SUCCEEDED:
  129. ret = 0;
  130. if (rxrpc_is_service_call(call))
  131. ret = put_cmsg(msg, SOL_RXRPC, RXRPC_ACK, 0, &tmp);
  132. break;
  133. case RXRPC_CALL_REMOTELY_ABORTED:
  134. tmp = call->abort_code;
  135. ret = put_cmsg(msg, SOL_RXRPC, RXRPC_ABORT, 4, &tmp);
  136. break;
  137. case RXRPC_CALL_LOCALLY_ABORTED:
  138. tmp = call->abort_code;
  139. ret = put_cmsg(msg, SOL_RXRPC, RXRPC_ABORT, 4, &tmp);
  140. break;
  141. case RXRPC_CALL_NETWORK_ERROR:
  142. tmp = -call->error;
  143. ret = put_cmsg(msg, SOL_RXRPC, RXRPC_NET_ERROR, 4, &tmp);
  144. break;
  145. case RXRPC_CALL_LOCAL_ERROR:
  146. tmp = -call->error;
  147. ret = put_cmsg(msg, SOL_RXRPC, RXRPC_LOCAL_ERROR, 4, &tmp);
  148. break;
  149. default:
  150. pr_err("Invalid terminal call state %u\n", call->state);
  151. BUG();
  152. break;
  153. }
  154. trace_rxrpc_recvmsg(call, rxrpc_recvmsg_terminal, call->rx_hard_ack,
  155. call->rx_pkt_offset, call->rx_pkt_len, ret);
  156. return ret;
  157. }
  158. /*
  159. * End the packet reception phase.
  160. */
  161. static void rxrpc_end_rx_phase(struct rxrpc_call *call, rxrpc_serial_t serial)
  162. {
  163. _enter("%d,%s", call->debug_id, rxrpc_call_states[call->state]);
  164. trace_rxrpc_receive(call, rxrpc_receive_end, 0, call->rx_top);
  165. ASSERTCMP(call->rx_hard_ack, ==, call->rx_top);
  166. if (call->state == RXRPC_CALL_CLIENT_RECV_REPLY) {
  167. rxrpc_propose_ACK(call, RXRPC_ACK_IDLE, serial, false, true,
  168. rxrpc_propose_ack_terminal_ack);
  169. //rxrpc_send_ack_packet(call, false, NULL);
  170. }
  171. write_lock_bh(&call->state_lock);
  172. switch (call->state) {
  173. case RXRPC_CALL_CLIENT_RECV_REPLY:
  174. __rxrpc_call_completed(call);
  175. write_unlock_bh(&call->state_lock);
  176. break;
  177. case RXRPC_CALL_SERVER_RECV_REQUEST:
  178. call->tx_phase = true;
  179. call->state = RXRPC_CALL_SERVER_ACK_REQUEST;
  180. call->expect_req_by = jiffies + MAX_JIFFY_OFFSET;
  181. write_unlock_bh(&call->state_lock);
  182. rxrpc_propose_ACK(call, RXRPC_ACK_DELAY, serial, false, true,
  183. rxrpc_propose_ack_processing_op);
  184. break;
  185. default:
  186. write_unlock_bh(&call->state_lock);
  187. break;
  188. }
  189. }
  190. /*
  191. * Discard a packet we've used up and advance the Rx window by one.
  192. */
  193. static void rxrpc_rotate_rx_window(struct rxrpc_call *call)
  194. {
  195. struct rxrpc_skb_priv *sp;
  196. struct sk_buff *skb;
  197. rxrpc_serial_t serial;
  198. rxrpc_seq_t hard_ack, top;
  199. bool last = false;
  200. u8 subpacket;
  201. int ix;
  202. _enter("%d", call->debug_id);
  203. hard_ack = call->rx_hard_ack;
  204. top = smp_load_acquire(&call->rx_top);
  205. ASSERT(before(hard_ack, top));
  206. hard_ack++;
  207. ix = hard_ack & RXRPC_RXTX_BUFF_MASK;
  208. skb = call->rxtx_buffer[ix];
  209. rxrpc_see_skb(skb, rxrpc_skb_rotated);
  210. sp = rxrpc_skb(skb);
  211. subpacket = call->rxtx_annotations[ix] & RXRPC_RX_ANNO_SUBPACKET;
  212. serial = sp->hdr.serial + subpacket;
  213. if (subpacket == sp->nr_subpackets - 1 &&
  214. sp->rx_flags & RXRPC_SKB_INCL_LAST)
  215. last = true;
  216. call->rxtx_buffer[ix] = NULL;
  217. call->rxtx_annotations[ix] = 0;
  218. /* Barrier against rxrpc_input_data(). */
  219. smp_store_release(&call->rx_hard_ack, hard_ack);
  220. rxrpc_free_skb(skb, rxrpc_skb_freed);
  221. trace_rxrpc_receive(call, rxrpc_receive_rotate, serial, hard_ack);
  222. if (last) {
  223. rxrpc_end_rx_phase(call, serial);
  224. } else {
  225. /* Check to see if there's an ACK that needs sending. */
  226. if (after_eq(hard_ack, call->ackr_consumed + 2) ||
  227. after_eq(top, call->ackr_seen + 2) ||
  228. (hard_ack == top && after(hard_ack, call->ackr_consumed)))
  229. rxrpc_propose_ACK(call, RXRPC_ACK_DELAY, serial,
  230. true, true,
  231. rxrpc_propose_ack_rotate_rx);
  232. if (call->ackr_reason && call->ackr_reason != RXRPC_ACK_DELAY)
  233. rxrpc_send_ack_packet(call, false, NULL);
  234. }
  235. }
  236. /*
  237. * Decrypt and verify a (sub)packet. The packet's length may be changed due to
  238. * padding, but if this is the case, the packet length will be resident in the
  239. * socket buffer. Note that we can't modify the master skb info as the skb may
  240. * be the home to multiple subpackets.
  241. */
  242. static int rxrpc_verify_packet(struct rxrpc_call *call, struct sk_buff *skb,
  243. u8 annotation,
  244. unsigned int offset, unsigned int len)
  245. {
  246. struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
  247. rxrpc_seq_t seq = sp->hdr.seq;
  248. u16 cksum = sp->hdr.cksum;
  249. u8 subpacket = annotation & RXRPC_RX_ANNO_SUBPACKET;
  250. _enter("");
  251. /* For all but the head jumbo subpacket, the security checksum is in a
  252. * jumbo header immediately prior to the data.
  253. */
  254. if (subpacket > 0) {
  255. __be16 tmp;
  256. if (skb_copy_bits(skb, offset - 2, &tmp, 2) < 0)
  257. BUG();
  258. cksum = ntohs(tmp);
  259. seq += subpacket;
  260. }
  261. return call->security->verify_packet(call, skb, offset, len,
  262. seq, cksum);
  263. }
  264. /*
  265. * Locate the data within a packet. This is complicated by:
  266. *
  267. * (1) An skb may contain a jumbo packet - so we have to find the appropriate
  268. * subpacket.
  269. *
  270. * (2) The (sub)packets may be encrypted and, if so, the encrypted portion
  271. * contains an extra header which includes the true length of the data,
  272. * excluding any encrypted padding.
  273. */
  274. static int rxrpc_locate_data(struct rxrpc_call *call, struct sk_buff *skb,
  275. u8 *_annotation,
  276. unsigned int *_offset, unsigned int *_len,
  277. bool *_last)
  278. {
  279. struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
  280. unsigned int offset = sizeof(struct rxrpc_wire_header);
  281. unsigned int len;
  282. bool last = false;
  283. int ret;
  284. u8 annotation = *_annotation;
  285. u8 subpacket = annotation & RXRPC_RX_ANNO_SUBPACKET;
  286. /* Locate the subpacket */
  287. offset += subpacket * RXRPC_JUMBO_SUBPKTLEN;
  288. len = skb->len - offset;
  289. if (subpacket < sp->nr_subpackets - 1)
  290. len = RXRPC_JUMBO_DATALEN;
  291. else if (sp->rx_flags & RXRPC_SKB_INCL_LAST)
  292. last = true;
  293. if (!(annotation & RXRPC_RX_ANNO_VERIFIED)) {
  294. ret = rxrpc_verify_packet(call, skb, annotation, offset, len);
  295. if (ret < 0)
  296. return ret;
  297. *_annotation |= RXRPC_RX_ANNO_VERIFIED;
  298. }
  299. *_offset = offset;
  300. *_len = len;
  301. *_last = last;
  302. call->security->locate_data(call, skb, _offset, _len);
  303. return 0;
  304. }
  305. /*
  306. * Deliver messages to a call. This keeps processing packets until the buffer
  307. * is filled and we find either more DATA (returns 0) or the end of the DATA
  308. * (returns 1). If more packets are required, it returns -EAGAIN.
  309. */
  310. static int rxrpc_recvmsg_data(struct socket *sock, struct rxrpc_call *call,
  311. struct msghdr *msg, struct iov_iter *iter,
  312. size_t len, int flags, size_t *_offset)
  313. {
  314. struct rxrpc_skb_priv *sp;
  315. struct sk_buff *skb;
  316. rxrpc_serial_t serial;
  317. rxrpc_seq_t hard_ack, top, seq;
  318. size_t remain;
  319. bool rx_pkt_last;
  320. unsigned int rx_pkt_offset, rx_pkt_len;
  321. int ix, copy, ret = -EAGAIN, ret2;
  322. if (test_and_clear_bit(RXRPC_CALL_RX_UNDERRUN, &call->flags) &&
  323. call->ackr_reason)
  324. rxrpc_send_ack_packet(call, false, NULL);
  325. rx_pkt_offset = call->rx_pkt_offset;
  326. rx_pkt_len = call->rx_pkt_len;
  327. rx_pkt_last = call->rx_pkt_last;
  328. if (call->state >= RXRPC_CALL_SERVER_ACK_REQUEST) {
  329. seq = call->rx_hard_ack;
  330. ret = 1;
  331. goto done;
  332. }
  333. /* Barriers against rxrpc_input_data(). */
  334. hard_ack = call->rx_hard_ack;
  335. seq = hard_ack + 1;
  336. while (top = smp_load_acquire(&call->rx_top),
  337. before_eq(seq, top)
  338. ) {
  339. ix = seq & RXRPC_RXTX_BUFF_MASK;
  340. skb = call->rxtx_buffer[ix];
  341. if (!skb) {
  342. trace_rxrpc_recvmsg(call, rxrpc_recvmsg_hole, seq,
  343. rx_pkt_offset, rx_pkt_len, 0);
  344. break;
  345. }
  346. smp_rmb();
  347. rxrpc_see_skb(skb, rxrpc_skb_seen);
  348. sp = rxrpc_skb(skb);
  349. if (!(flags & MSG_PEEK)) {
  350. serial = sp->hdr.serial;
  351. serial += call->rxtx_annotations[ix] & RXRPC_RX_ANNO_SUBPACKET;
  352. trace_rxrpc_receive(call, rxrpc_receive_front,
  353. serial, seq);
  354. }
  355. if (msg)
  356. sock_recv_timestamp(msg, sock->sk, skb);
  357. if (rx_pkt_offset == 0) {
  358. ret2 = rxrpc_locate_data(call, skb,
  359. &call->rxtx_annotations[ix],
  360. &rx_pkt_offset, &rx_pkt_len,
  361. &rx_pkt_last);
  362. trace_rxrpc_recvmsg(call, rxrpc_recvmsg_next, seq,
  363. rx_pkt_offset, rx_pkt_len, ret2);
  364. if (ret2 < 0) {
  365. ret = ret2;
  366. goto out;
  367. }
  368. } else {
  369. trace_rxrpc_recvmsg(call, rxrpc_recvmsg_cont, seq,
  370. rx_pkt_offset, rx_pkt_len, 0);
  371. }
  372. /* We have to handle short, empty and used-up DATA packets. */
  373. remain = len - *_offset;
  374. copy = rx_pkt_len;
  375. if (copy > remain)
  376. copy = remain;
  377. if (copy > 0) {
  378. ret2 = skb_copy_datagram_iter(skb, rx_pkt_offset, iter,
  379. copy);
  380. if (ret2 < 0) {
  381. ret = ret2;
  382. goto out;
  383. }
  384. /* handle piecemeal consumption of data packets */
  385. rx_pkt_offset += copy;
  386. rx_pkt_len -= copy;
  387. *_offset += copy;
  388. }
  389. if (rx_pkt_len > 0) {
  390. trace_rxrpc_recvmsg(call, rxrpc_recvmsg_full, seq,
  391. rx_pkt_offset, rx_pkt_len, 0);
  392. ASSERTCMP(*_offset, ==, len);
  393. ret = 0;
  394. break;
  395. }
  396. /* The whole packet has been transferred. */
  397. if (!(flags & MSG_PEEK))
  398. rxrpc_rotate_rx_window(call);
  399. rx_pkt_offset = 0;
  400. rx_pkt_len = 0;
  401. if (rx_pkt_last) {
  402. ASSERTCMP(seq, ==, READ_ONCE(call->rx_top));
  403. ret = 1;
  404. goto out;
  405. }
  406. seq++;
  407. }
  408. out:
  409. if (!(flags & MSG_PEEK)) {
  410. call->rx_pkt_offset = rx_pkt_offset;
  411. call->rx_pkt_len = rx_pkt_len;
  412. call->rx_pkt_last = rx_pkt_last;
  413. }
  414. done:
  415. trace_rxrpc_recvmsg(call, rxrpc_recvmsg_data_return, seq,
  416. rx_pkt_offset, rx_pkt_len, ret);
  417. if (ret == -EAGAIN)
  418. set_bit(RXRPC_CALL_RX_UNDERRUN, &call->flags);
  419. return ret;
  420. }
  421. /*
  422. * Receive a message from an RxRPC socket
  423. * - we need to be careful about two or more threads calling recvmsg
  424. * simultaneously
  425. */
  426. int rxrpc_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
  427. int flags)
  428. {
  429. struct rxrpc_call *call;
  430. struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
  431. struct list_head *l;
  432. size_t copied = 0;
  433. long timeo;
  434. int ret;
  435. DEFINE_WAIT(wait);
  436. trace_rxrpc_recvmsg(NULL, rxrpc_recvmsg_enter, 0, 0, 0, 0);
  437. if (flags & (MSG_OOB | MSG_TRUNC))
  438. return -EOPNOTSUPP;
  439. timeo = sock_rcvtimeo(&rx->sk, flags & MSG_DONTWAIT);
  440. try_again:
  441. lock_sock(&rx->sk);
  442. /* Return immediately if a client socket has no outstanding calls */
  443. if (RB_EMPTY_ROOT(&rx->calls) &&
  444. list_empty(&rx->recvmsg_q) &&
  445. rx->sk.sk_state != RXRPC_SERVER_LISTENING) {
  446. release_sock(&rx->sk);
  447. return -EAGAIN;
  448. }
  449. if (list_empty(&rx->recvmsg_q)) {
  450. ret = -EWOULDBLOCK;
  451. if (timeo == 0) {
  452. call = NULL;
  453. goto error_no_call;
  454. }
  455. release_sock(&rx->sk);
  456. /* Wait for something to happen */
  457. prepare_to_wait_exclusive(sk_sleep(&rx->sk), &wait,
  458. TASK_INTERRUPTIBLE);
  459. ret = sock_error(&rx->sk);
  460. if (ret)
  461. goto wait_error;
  462. if (list_empty(&rx->recvmsg_q)) {
  463. if (signal_pending(current))
  464. goto wait_interrupted;
  465. trace_rxrpc_recvmsg(NULL, rxrpc_recvmsg_wait,
  466. 0, 0, 0, 0);
  467. timeo = schedule_timeout(timeo);
  468. }
  469. finish_wait(sk_sleep(&rx->sk), &wait);
  470. goto try_again;
  471. }
  472. /* Find the next call and dequeue it if we're not just peeking. If we
  473. * do dequeue it, that comes with a ref that we will need to release.
  474. */
  475. write_lock_bh(&rx->recvmsg_lock);
  476. l = rx->recvmsg_q.next;
  477. call = list_entry(l, struct rxrpc_call, recvmsg_link);
  478. if (!(flags & MSG_PEEK))
  479. list_del_init(&call->recvmsg_link);
  480. else
  481. rxrpc_get_call(call, rxrpc_call_got);
  482. write_unlock_bh(&rx->recvmsg_lock);
  483. trace_rxrpc_recvmsg(call, rxrpc_recvmsg_dequeue, 0, 0, 0, 0);
  484. /* We're going to drop the socket lock, so we need to lock the call
  485. * against interference by sendmsg.
  486. */
  487. if (!mutex_trylock(&call->user_mutex)) {
  488. ret = -EWOULDBLOCK;
  489. if (flags & MSG_DONTWAIT)
  490. goto error_requeue_call;
  491. ret = -ERESTARTSYS;
  492. if (mutex_lock_interruptible(&call->user_mutex) < 0)
  493. goto error_requeue_call;
  494. }
  495. release_sock(&rx->sk);
  496. if (test_bit(RXRPC_CALL_RELEASED, &call->flags))
  497. BUG();
  498. if (test_bit(RXRPC_CALL_HAS_USERID, &call->flags)) {
  499. if (flags & MSG_CMSG_COMPAT) {
  500. unsigned int id32 = call->user_call_ID;
  501. ret = put_cmsg(msg, SOL_RXRPC, RXRPC_USER_CALL_ID,
  502. sizeof(unsigned int), &id32);
  503. } else {
  504. unsigned long idl = call->user_call_ID;
  505. ret = put_cmsg(msg, SOL_RXRPC, RXRPC_USER_CALL_ID,
  506. sizeof(unsigned long), &idl);
  507. }
  508. if (ret < 0)
  509. goto error_unlock_call;
  510. }
  511. if (msg->msg_name && call->peer) {
  512. struct sockaddr_rxrpc *srx = msg->msg_name;
  513. size_t len = sizeof(call->peer->srx);
  514. memcpy(msg->msg_name, &call->peer->srx, len);
  515. srx->srx_service = call->service_id;
  516. msg->msg_namelen = len;
  517. }
  518. switch (READ_ONCE(call->state)) {
  519. case RXRPC_CALL_CLIENT_RECV_REPLY:
  520. case RXRPC_CALL_SERVER_RECV_REQUEST:
  521. case RXRPC_CALL_SERVER_ACK_REQUEST:
  522. ret = rxrpc_recvmsg_data(sock, call, msg, &msg->msg_iter, len,
  523. flags, &copied);
  524. if (ret == -EAGAIN)
  525. ret = 0;
  526. if (after(call->rx_top, call->rx_hard_ack) &&
  527. call->rxtx_buffer[(call->rx_hard_ack + 1) & RXRPC_RXTX_BUFF_MASK])
  528. rxrpc_notify_socket(call);
  529. break;
  530. default:
  531. ret = 0;
  532. break;
  533. }
  534. if (ret < 0)
  535. goto error_unlock_call;
  536. if (call->state == RXRPC_CALL_COMPLETE) {
  537. ret = rxrpc_recvmsg_term(call, msg);
  538. if (ret < 0)
  539. goto error_unlock_call;
  540. if (!(flags & MSG_PEEK))
  541. rxrpc_release_call(rx, call);
  542. msg->msg_flags |= MSG_EOR;
  543. ret = 1;
  544. }
  545. if (ret == 0)
  546. msg->msg_flags |= MSG_MORE;
  547. else
  548. msg->msg_flags &= ~MSG_MORE;
  549. ret = copied;
  550. error_unlock_call:
  551. mutex_unlock(&call->user_mutex);
  552. rxrpc_put_call(call, rxrpc_call_put);
  553. trace_rxrpc_recvmsg(call, rxrpc_recvmsg_return, 0, 0, 0, ret);
  554. return ret;
  555. error_requeue_call:
  556. if (!(flags & MSG_PEEK)) {
  557. write_lock_bh(&rx->recvmsg_lock);
  558. list_add(&call->recvmsg_link, &rx->recvmsg_q);
  559. write_unlock_bh(&rx->recvmsg_lock);
  560. trace_rxrpc_recvmsg(call, rxrpc_recvmsg_requeue, 0, 0, 0, 0);
  561. } else {
  562. rxrpc_put_call(call, rxrpc_call_put);
  563. }
  564. error_no_call:
  565. release_sock(&rx->sk);
  566. error_trace:
  567. trace_rxrpc_recvmsg(call, rxrpc_recvmsg_return, 0, 0, 0, ret);
  568. return ret;
  569. wait_interrupted:
  570. ret = sock_intr_errno(timeo);
  571. wait_error:
  572. finish_wait(sk_sleep(&rx->sk), &wait);
  573. call = NULL;
  574. goto error_trace;
  575. }
  576. /**
  577. * rxrpc_kernel_recv_data - Allow a kernel service to receive data/info
  578. * @sock: The socket that the call exists on
  579. * @call: The call to send data through
  580. * @iter: The buffer to receive into
  581. * @want_more: True if more data is expected to be read
  582. * @_abort: Where the abort code is stored if -ECONNABORTED is returned
  583. * @_service: Where to store the actual service ID (may be upgraded)
  584. *
  585. * Allow a kernel service to receive data and pick up information about the
  586. * state of a call. Returns 0 if got what was asked for and there's more
  587. * available, 1 if we got what was asked for and we're at the end of the data
  588. * and -EAGAIN if we need more data.
  589. *
  590. * Note that we may return -EAGAIN to drain empty packets at the end of the
  591. * data, even if we've already copied over the requested data.
  592. *
  593. * *_abort should also be initialised to 0.
  594. */
  595. int rxrpc_kernel_recv_data(struct socket *sock, struct rxrpc_call *call,
  596. struct iov_iter *iter,
  597. bool want_more, u32 *_abort, u16 *_service)
  598. {
  599. size_t offset = 0;
  600. int ret;
  601. _enter("{%d,%s},%zu,%d",
  602. call->debug_id, rxrpc_call_states[call->state],
  603. iov_iter_count(iter), want_more);
  604. ASSERTCMP(call->state, !=, RXRPC_CALL_SERVER_SECURING);
  605. mutex_lock(&call->user_mutex);
  606. switch (READ_ONCE(call->state)) {
  607. case RXRPC_CALL_CLIENT_RECV_REPLY:
  608. case RXRPC_CALL_SERVER_RECV_REQUEST:
  609. case RXRPC_CALL_SERVER_ACK_REQUEST:
  610. ret = rxrpc_recvmsg_data(sock, call, NULL, iter,
  611. iov_iter_count(iter), 0,
  612. &offset);
  613. if (ret < 0)
  614. goto out;
  615. /* We can only reach here with a partially full buffer if we
  616. * have reached the end of the data. We must otherwise have a
  617. * full buffer or have been given -EAGAIN.
  618. */
  619. if (ret == 1) {
  620. if (iov_iter_count(iter) > 0)
  621. goto short_data;
  622. if (!want_more)
  623. goto read_phase_complete;
  624. ret = 0;
  625. goto out;
  626. }
  627. if (!want_more)
  628. goto excess_data;
  629. goto out;
  630. case RXRPC_CALL_COMPLETE:
  631. goto call_complete;
  632. default:
  633. ret = -EINPROGRESS;
  634. goto out;
  635. }
  636. read_phase_complete:
  637. ret = 1;
  638. out:
  639. switch (call->ackr_reason) {
  640. case RXRPC_ACK_IDLE:
  641. break;
  642. case RXRPC_ACK_DELAY:
  643. if (ret != -EAGAIN)
  644. break;
  645. fallthrough;
  646. default:
  647. rxrpc_send_ack_packet(call, false, NULL);
  648. }
  649. if (_service)
  650. *_service = call->service_id;
  651. mutex_unlock(&call->user_mutex);
  652. _leave(" = %d [%zu,%d]", ret, iov_iter_count(iter), *_abort);
  653. return ret;
  654. short_data:
  655. trace_rxrpc_rx_eproto(call, 0, tracepoint_string("short_data"));
  656. ret = -EBADMSG;
  657. goto out;
  658. excess_data:
  659. trace_rxrpc_rx_eproto(call, 0, tracepoint_string("excess_data"));
  660. ret = -EMSGSIZE;
  661. goto out;
  662. call_complete:
  663. *_abort = call->abort_code;
  664. ret = call->error;
  665. if (call->completion == RXRPC_CALL_SUCCEEDED) {
  666. ret = 1;
  667. if (iov_iter_count(iter) > 0)
  668. ret = -ECONNRESET;
  669. }
  670. goto out;
  671. }
  672. EXPORT_SYMBOL(rxrpc_kernel_recv_data);
  673. /**
  674. * rxrpc_kernel_get_reply_time - Get timestamp on first reply packet
  675. * @sock: The socket that the call exists on
  676. * @call: The call to query
  677. * @_ts: Where to put the timestamp
  678. *
  679. * Retrieve the timestamp from the first DATA packet of the reply if it is
  680. * in the ring. Returns true if successful, false if not.
  681. */
  682. bool rxrpc_kernel_get_reply_time(struct socket *sock, struct rxrpc_call *call,
  683. ktime_t *_ts)
  684. {
  685. struct sk_buff *skb;
  686. rxrpc_seq_t hard_ack, top, seq;
  687. bool success = false;
  688. mutex_lock(&call->user_mutex);
  689. if (READ_ONCE(call->state) != RXRPC_CALL_CLIENT_RECV_REPLY)
  690. goto out;
  691. hard_ack = call->rx_hard_ack;
  692. if (hard_ack != 0)
  693. goto out;
  694. seq = hard_ack + 1;
  695. top = smp_load_acquire(&call->rx_top);
  696. if (after(seq, top))
  697. goto out;
  698. skb = call->rxtx_buffer[seq & RXRPC_RXTX_BUFF_MASK];
  699. if (!skb)
  700. goto out;
  701. *_ts = skb_get_ktime(skb);
  702. success = true;
  703. out:
  704. mutex_unlock(&call->user_mutex);
  705. return success;
  706. }
  707. EXPORT_SYMBOL(rxrpc_kernel_get_reply_time);