Loading...
1/* RxRPC recvmsg() implementation
2 *
3 * Copyright (C) 2007 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 License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 */
11
12#include <linux/net.h>
13#include <linux/skbuff.h>
14#include <linux/export.h>
15#include <net/sock.h>
16#include <net/af_rxrpc.h>
17#include "ar-internal.h"
18
19/*
20 * removal a call's user ID from the socket tree to make the user ID available
21 * again and so that it won't be seen again in association with that call
22 */
23void rxrpc_remove_user_ID(struct rxrpc_sock *rx, struct rxrpc_call *call)
24{
25 _debug("RELEASE CALL %d", call->debug_id);
26
27 if (test_bit(RXRPC_CALL_HAS_USERID, &call->flags)) {
28 write_lock_bh(&rx->call_lock);
29 rb_erase(&call->sock_node, &call->socket->calls);
30 clear_bit(RXRPC_CALL_HAS_USERID, &call->flags);
31 write_unlock_bh(&rx->call_lock);
32 }
33
34 read_lock_bh(&call->state_lock);
35 if (!test_bit(RXRPC_CALL_RELEASED, &call->flags) &&
36 !test_and_set_bit(RXRPC_CALL_RELEASE, &call->events))
37 rxrpc_queue_call(call);
38 read_unlock_bh(&call->state_lock);
39}
40
41/*
42 * receive a message from an RxRPC socket
43 * - we need to be careful about two or more threads calling recvmsg
44 * simultaneously
45 */
46int rxrpc_recvmsg(struct kiocb *iocb, struct socket *sock,
47 struct msghdr *msg, size_t len, int flags)
48{
49 struct rxrpc_skb_priv *sp;
50 struct rxrpc_call *call = NULL, *continue_call = NULL;
51 struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
52 struct sk_buff *skb;
53 long timeo;
54 int copy, ret, ullen, offset, copied = 0;
55 u32 abort_code;
56
57 DEFINE_WAIT(wait);
58
59 _enter(",,,%zu,%d", len, flags);
60
61 if (flags & (MSG_OOB | MSG_TRUNC))
62 return -EOPNOTSUPP;
63
64 ullen = msg->msg_flags & MSG_CMSG_COMPAT ? 4 : sizeof(unsigned long);
65
66 timeo = sock_rcvtimeo(&rx->sk, flags & MSG_DONTWAIT);
67 msg->msg_flags |= MSG_MORE;
68
69 lock_sock(&rx->sk);
70
71 for (;;) {
72 /* return immediately if a client socket has no outstanding
73 * calls */
74 if (RB_EMPTY_ROOT(&rx->calls)) {
75 if (copied)
76 goto out;
77 if (rx->sk.sk_state != RXRPC_SERVER_LISTENING) {
78 release_sock(&rx->sk);
79 if (continue_call)
80 rxrpc_put_call(continue_call);
81 return -ENODATA;
82 }
83 }
84
85 /* get the next message on the Rx queue */
86 skb = skb_peek(&rx->sk.sk_receive_queue);
87 if (!skb) {
88 /* nothing remains on the queue */
89 if (copied &&
90 (msg->msg_flags & MSG_PEEK || timeo == 0))
91 goto out;
92
93 /* wait for a message to turn up */
94 release_sock(&rx->sk);
95 prepare_to_wait_exclusive(sk_sleep(&rx->sk), &wait,
96 TASK_INTERRUPTIBLE);
97 ret = sock_error(&rx->sk);
98 if (ret)
99 goto wait_error;
100
101 if (skb_queue_empty(&rx->sk.sk_receive_queue)) {
102 if (signal_pending(current))
103 goto wait_interrupted;
104 timeo = schedule_timeout(timeo);
105 }
106 finish_wait(sk_sleep(&rx->sk), &wait);
107 lock_sock(&rx->sk);
108 continue;
109 }
110
111 peek_next_packet:
112 sp = rxrpc_skb(skb);
113 call = sp->call;
114 ASSERT(call != NULL);
115
116 _debug("next pkt %s", rxrpc_pkts[sp->hdr.type]);
117
118 /* make sure we wait for the state to be updated in this call */
119 spin_lock_bh(&call->lock);
120 spin_unlock_bh(&call->lock);
121
122 if (test_bit(RXRPC_CALL_RELEASED, &call->flags)) {
123 _debug("packet from released call");
124 if (skb_dequeue(&rx->sk.sk_receive_queue) != skb)
125 BUG();
126 rxrpc_free_skb(skb);
127 continue;
128 }
129
130 /* determine whether to continue last data receive */
131 if (continue_call) {
132 _debug("maybe cont");
133 if (call != continue_call ||
134 skb->mark != RXRPC_SKB_MARK_DATA) {
135 release_sock(&rx->sk);
136 rxrpc_put_call(continue_call);
137 _leave(" = %d [noncont]", copied);
138 return copied;
139 }
140 }
141
142 rxrpc_get_call(call);
143
144 /* copy the peer address and timestamp */
145 if (!continue_call) {
146 if (msg->msg_name) {
147 size_t len =
148 sizeof(call->conn->trans->peer->srx);
149 memcpy(msg->msg_name,
150 &call->conn->trans->peer->srx, len);
151 msg->msg_namelen = len;
152 }
153 sock_recv_ts_and_drops(msg, &rx->sk, skb);
154 }
155
156 /* receive the message */
157 if (skb->mark != RXRPC_SKB_MARK_DATA)
158 goto receive_non_data_message;
159
160 _debug("recvmsg DATA #%u { %d, %d }",
161 ntohl(sp->hdr.seq), skb->len, sp->offset);
162
163 if (!continue_call) {
164 /* only set the control data once per recvmsg() */
165 ret = put_cmsg(msg, SOL_RXRPC, RXRPC_USER_CALL_ID,
166 ullen, &call->user_call_ID);
167 if (ret < 0)
168 goto copy_error;
169 ASSERT(test_bit(RXRPC_CALL_HAS_USERID, &call->flags));
170 }
171
172 ASSERTCMP(ntohl(sp->hdr.seq), >=, call->rx_data_recv);
173 ASSERTCMP(ntohl(sp->hdr.seq), <=, call->rx_data_recv + 1);
174 call->rx_data_recv = ntohl(sp->hdr.seq);
175
176 ASSERTCMP(ntohl(sp->hdr.seq), >, call->rx_data_eaten);
177
178 offset = sp->offset;
179 copy = skb->len - offset;
180 if (copy > len - copied)
181 copy = len - copied;
182
183 ret = skb_copy_datagram_iovec(skb, offset, msg->msg_iov, copy);
184
185 if (ret < 0)
186 goto copy_error;
187
188 /* handle piecemeal consumption of data packets */
189 _debug("copied %d+%d", copy, copied);
190
191 offset += copy;
192 copied += copy;
193
194 if (!(flags & MSG_PEEK))
195 sp->offset = offset;
196
197 if (sp->offset < skb->len) {
198 _debug("buffer full");
199 ASSERTCMP(copied, ==, len);
200 break;
201 }
202
203 /* we transferred the whole data packet */
204 if (sp->hdr.flags & RXRPC_LAST_PACKET) {
205 _debug("last");
206 if (call->conn->out_clientflag) {
207 /* last byte of reply received */
208 ret = copied;
209 goto terminal_message;
210 }
211
212 /* last bit of request received */
213 if (!(flags & MSG_PEEK)) {
214 _debug("eat packet");
215 if (skb_dequeue(&rx->sk.sk_receive_queue) !=
216 skb)
217 BUG();
218 rxrpc_free_skb(skb);
219 }
220 msg->msg_flags &= ~MSG_MORE;
221 break;
222 }
223
224 /* move on to the next data message */
225 _debug("next");
226 if (!continue_call)
227 continue_call = sp->call;
228 else
229 rxrpc_put_call(call);
230 call = NULL;
231
232 if (flags & MSG_PEEK) {
233 _debug("peek next");
234 skb = skb->next;
235 if (skb == (struct sk_buff *) &rx->sk.sk_receive_queue)
236 break;
237 goto peek_next_packet;
238 }
239
240 _debug("eat packet");
241 if (skb_dequeue(&rx->sk.sk_receive_queue) != skb)
242 BUG();
243 rxrpc_free_skb(skb);
244 }
245
246 /* end of non-terminal data packet reception for the moment */
247 _debug("end rcv data");
248out:
249 release_sock(&rx->sk);
250 if (call)
251 rxrpc_put_call(call);
252 if (continue_call)
253 rxrpc_put_call(continue_call);
254 _leave(" = %d [data]", copied);
255 return copied;
256
257 /* handle non-DATA messages such as aborts, incoming connections and
258 * final ACKs */
259receive_non_data_message:
260 _debug("non-data");
261
262 if (skb->mark == RXRPC_SKB_MARK_NEW_CALL) {
263 _debug("RECV NEW CALL");
264 ret = put_cmsg(msg, SOL_RXRPC, RXRPC_NEW_CALL, 0, &abort_code);
265 if (ret < 0)
266 goto copy_error;
267 if (!(flags & MSG_PEEK)) {
268 if (skb_dequeue(&rx->sk.sk_receive_queue) != skb)
269 BUG();
270 rxrpc_free_skb(skb);
271 }
272 goto out;
273 }
274
275 ret = put_cmsg(msg, SOL_RXRPC, RXRPC_USER_CALL_ID,
276 ullen, &call->user_call_ID);
277 if (ret < 0)
278 goto copy_error;
279 ASSERT(test_bit(RXRPC_CALL_HAS_USERID, &call->flags));
280
281 switch (skb->mark) {
282 case RXRPC_SKB_MARK_DATA:
283 BUG();
284 case RXRPC_SKB_MARK_FINAL_ACK:
285 ret = put_cmsg(msg, SOL_RXRPC, RXRPC_ACK, 0, &abort_code);
286 break;
287 case RXRPC_SKB_MARK_BUSY:
288 ret = put_cmsg(msg, SOL_RXRPC, RXRPC_BUSY, 0, &abort_code);
289 break;
290 case RXRPC_SKB_MARK_REMOTE_ABORT:
291 abort_code = call->abort_code;
292 ret = put_cmsg(msg, SOL_RXRPC, RXRPC_ABORT, 4, &abort_code);
293 break;
294 case RXRPC_SKB_MARK_NET_ERROR:
295 _debug("RECV NET ERROR %d", sp->error);
296 abort_code = sp->error;
297 ret = put_cmsg(msg, SOL_RXRPC, RXRPC_NET_ERROR, 4, &abort_code);
298 break;
299 case RXRPC_SKB_MARK_LOCAL_ERROR:
300 _debug("RECV LOCAL ERROR %d", sp->error);
301 abort_code = sp->error;
302 ret = put_cmsg(msg, SOL_RXRPC, RXRPC_LOCAL_ERROR, 4,
303 &abort_code);
304 break;
305 default:
306 BUG();
307 break;
308 }
309
310 if (ret < 0)
311 goto copy_error;
312
313terminal_message:
314 _debug("terminal");
315 msg->msg_flags &= ~MSG_MORE;
316 msg->msg_flags |= MSG_EOR;
317
318 if (!(flags & MSG_PEEK)) {
319 _net("free terminal skb %p", skb);
320 if (skb_dequeue(&rx->sk.sk_receive_queue) != skb)
321 BUG();
322 rxrpc_free_skb(skb);
323 rxrpc_remove_user_ID(rx, call);
324 }
325
326 release_sock(&rx->sk);
327 rxrpc_put_call(call);
328 if (continue_call)
329 rxrpc_put_call(continue_call);
330 _leave(" = %d", ret);
331 return ret;
332
333copy_error:
334 _debug("copy error");
335 release_sock(&rx->sk);
336 rxrpc_put_call(call);
337 if (continue_call)
338 rxrpc_put_call(continue_call);
339 _leave(" = %d", ret);
340 return ret;
341
342wait_interrupted:
343 ret = sock_intr_errno(timeo);
344wait_error:
345 finish_wait(sk_sleep(&rx->sk), &wait);
346 if (continue_call)
347 rxrpc_put_call(continue_call);
348 if (copied)
349 copied = ret;
350 _leave(" = %d [waitfail %d]", copied, ret);
351 return copied;
352
353}
354
355/**
356 * rxrpc_kernel_data_delivered - Record delivery of data message
357 * @skb: Message holding data
358 *
359 * Record the delivery of a data message. This permits RxRPC to keep its
360 * tracking correct. The socket buffer will be deleted.
361 */
362void rxrpc_kernel_data_delivered(struct sk_buff *skb)
363{
364 struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
365 struct rxrpc_call *call = sp->call;
366
367 ASSERTCMP(ntohl(sp->hdr.seq), >=, call->rx_data_recv);
368 ASSERTCMP(ntohl(sp->hdr.seq), <=, call->rx_data_recv + 1);
369 call->rx_data_recv = ntohl(sp->hdr.seq);
370
371 ASSERTCMP(ntohl(sp->hdr.seq), >, call->rx_data_eaten);
372 rxrpc_free_skb(skb);
373}
374
375EXPORT_SYMBOL(rxrpc_kernel_data_delivered);
376
377/**
378 * rxrpc_kernel_is_data_last - Determine if data message is last one
379 * @skb: Message holding data
380 *
381 * Determine if data message is last one for the parent call.
382 */
383bool rxrpc_kernel_is_data_last(struct sk_buff *skb)
384{
385 struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
386
387 ASSERTCMP(skb->mark, ==, RXRPC_SKB_MARK_DATA);
388
389 return sp->hdr.flags & RXRPC_LAST_PACKET;
390}
391
392EXPORT_SYMBOL(rxrpc_kernel_is_data_last);
393
394/**
395 * rxrpc_kernel_get_abort_code - Get the abort code from an RxRPC abort message
396 * @skb: Message indicating an abort
397 *
398 * Get the abort code from an RxRPC abort message.
399 */
400u32 rxrpc_kernel_get_abort_code(struct sk_buff *skb)
401{
402 struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
403
404 ASSERTCMP(skb->mark, ==, RXRPC_SKB_MARK_REMOTE_ABORT);
405
406 return sp->call->abort_code;
407}
408
409EXPORT_SYMBOL(rxrpc_kernel_get_abort_code);
410
411/**
412 * rxrpc_kernel_get_error - Get the error number from an RxRPC error message
413 * @skb: Message indicating an error
414 *
415 * Get the error number from an RxRPC error message.
416 */
417int rxrpc_kernel_get_error_number(struct sk_buff *skb)
418{
419 struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
420
421 return sp->error;
422}
423
424EXPORT_SYMBOL(rxrpc_kernel_get_error_number);
1/* RxRPC recvmsg() implementation
2 *
3 * Copyright (C) 2007 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 License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 */
11
12#include <linux/net.h>
13#include <linux/skbuff.h>
14#include <net/sock.h>
15#include <net/af_rxrpc.h>
16#include "ar-internal.h"
17
18/*
19 * removal a call's user ID from the socket tree to make the user ID available
20 * again and so that it won't be seen again in association with that call
21 */
22void rxrpc_remove_user_ID(struct rxrpc_sock *rx, struct rxrpc_call *call)
23{
24 _debug("RELEASE CALL %d", call->debug_id);
25
26 if (test_bit(RXRPC_CALL_HAS_USERID, &call->flags)) {
27 write_lock_bh(&rx->call_lock);
28 rb_erase(&call->sock_node, &call->socket->calls);
29 clear_bit(RXRPC_CALL_HAS_USERID, &call->flags);
30 write_unlock_bh(&rx->call_lock);
31 }
32
33 read_lock_bh(&call->state_lock);
34 if (!test_bit(RXRPC_CALL_RELEASED, &call->flags) &&
35 !test_and_set_bit(RXRPC_CALL_RELEASE, &call->events))
36 rxrpc_queue_call(call);
37 read_unlock_bh(&call->state_lock);
38}
39
40/*
41 * receive a message from an RxRPC socket
42 * - we need to be careful about two or more threads calling recvmsg
43 * simultaneously
44 */
45int rxrpc_recvmsg(struct kiocb *iocb, struct socket *sock,
46 struct msghdr *msg, size_t len, int flags)
47{
48 struct rxrpc_skb_priv *sp;
49 struct rxrpc_call *call = NULL, *continue_call = NULL;
50 struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
51 struct sk_buff *skb;
52 long timeo;
53 int copy, ret, ullen, offset, copied = 0;
54 u32 abort_code;
55
56 DEFINE_WAIT(wait);
57
58 _enter(",,,%zu,%d", len, flags);
59
60 if (flags & (MSG_OOB | MSG_TRUNC))
61 return -EOPNOTSUPP;
62
63 ullen = msg->msg_flags & MSG_CMSG_COMPAT ? 4 : sizeof(unsigned long);
64
65 timeo = sock_rcvtimeo(&rx->sk, flags & MSG_DONTWAIT);
66 msg->msg_flags |= MSG_MORE;
67
68 lock_sock(&rx->sk);
69
70 for (;;) {
71 /* return immediately if a client socket has no outstanding
72 * calls */
73 if (RB_EMPTY_ROOT(&rx->calls)) {
74 if (copied)
75 goto out;
76 if (rx->sk.sk_state != RXRPC_SERVER_LISTENING) {
77 release_sock(&rx->sk);
78 if (continue_call)
79 rxrpc_put_call(continue_call);
80 return -ENODATA;
81 }
82 }
83
84 /* get the next message on the Rx queue */
85 skb = skb_peek(&rx->sk.sk_receive_queue);
86 if (!skb) {
87 /* nothing remains on the queue */
88 if (copied &&
89 (msg->msg_flags & MSG_PEEK || timeo == 0))
90 goto out;
91
92 /* wait for a message to turn up */
93 release_sock(&rx->sk);
94 prepare_to_wait_exclusive(sk_sleep(&rx->sk), &wait,
95 TASK_INTERRUPTIBLE);
96 ret = sock_error(&rx->sk);
97 if (ret)
98 goto wait_error;
99
100 if (skb_queue_empty(&rx->sk.sk_receive_queue)) {
101 if (signal_pending(current))
102 goto wait_interrupted;
103 timeo = schedule_timeout(timeo);
104 }
105 finish_wait(sk_sleep(&rx->sk), &wait);
106 lock_sock(&rx->sk);
107 continue;
108 }
109
110 peek_next_packet:
111 sp = rxrpc_skb(skb);
112 call = sp->call;
113 ASSERT(call != NULL);
114
115 _debug("next pkt %s", rxrpc_pkts[sp->hdr.type]);
116
117 /* make sure we wait for the state to be updated in this call */
118 spin_lock_bh(&call->lock);
119 spin_unlock_bh(&call->lock);
120
121 if (test_bit(RXRPC_CALL_RELEASED, &call->flags)) {
122 _debug("packet from released call");
123 if (skb_dequeue(&rx->sk.sk_receive_queue) != skb)
124 BUG();
125 rxrpc_free_skb(skb);
126 continue;
127 }
128
129 /* determine whether to continue last data receive */
130 if (continue_call) {
131 _debug("maybe cont");
132 if (call != continue_call ||
133 skb->mark != RXRPC_SKB_MARK_DATA) {
134 release_sock(&rx->sk);
135 rxrpc_put_call(continue_call);
136 _leave(" = %d [noncont]", copied);
137 return copied;
138 }
139 }
140
141 rxrpc_get_call(call);
142
143 /* copy the peer address and timestamp */
144 if (!continue_call) {
145 if (msg->msg_name && msg->msg_namelen > 0)
146 memcpy(msg->msg_name,
147 &call->conn->trans->peer->srx,
148 sizeof(call->conn->trans->peer->srx));
149 sock_recv_ts_and_drops(msg, &rx->sk, skb);
150 }
151
152 /* receive the message */
153 if (skb->mark != RXRPC_SKB_MARK_DATA)
154 goto receive_non_data_message;
155
156 _debug("recvmsg DATA #%u { %d, %d }",
157 ntohl(sp->hdr.seq), skb->len, sp->offset);
158
159 if (!continue_call) {
160 /* only set the control data once per recvmsg() */
161 ret = put_cmsg(msg, SOL_RXRPC, RXRPC_USER_CALL_ID,
162 ullen, &call->user_call_ID);
163 if (ret < 0)
164 goto copy_error;
165 ASSERT(test_bit(RXRPC_CALL_HAS_USERID, &call->flags));
166 }
167
168 ASSERTCMP(ntohl(sp->hdr.seq), >=, call->rx_data_recv);
169 ASSERTCMP(ntohl(sp->hdr.seq), <=, call->rx_data_recv + 1);
170 call->rx_data_recv = ntohl(sp->hdr.seq);
171
172 ASSERTCMP(ntohl(sp->hdr.seq), >, call->rx_data_eaten);
173
174 offset = sp->offset;
175 copy = skb->len - offset;
176 if (copy > len - copied)
177 copy = len - copied;
178
179 if (skb->ip_summed == CHECKSUM_UNNECESSARY) {
180 ret = skb_copy_datagram_iovec(skb, offset,
181 msg->msg_iov, copy);
182 } else {
183 ret = skb_copy_and_csum_datagram_iovec(skb, offset,
184 msg->msg_iov);
185 if (ret == -EINVAL)
186 goto csum_copy_error;
187 }
188
189 if (ret < 0)
190 goto copy_error;
191
192 /* handle piecemeal consumption of data packets */
193 _debug("copied %d+%d", copy, copied);
194
195 offset += copy;
196 copied += copy;
197
198 if (!(flags & MSG_PEEK))
199 sp->offset = offset;
200
201 if (sp->offset < skb->len) {
202 _debug("buffer full");
203 ASSERTCMP(copied, ==, len);
204 break;
205 }
206
207 /* we transferred the whole data packet */
208 if (sp->hdr.flags & RXRPC_LAST_PACKET) {
209 _debug("last");
210 if (call->conn->out_clientflag) {
211 /* last byte of reply received */
212 ret = copied;
213 goto terminal_message;
214 }
215
216 /* last bit of request received */
217 if (!(flags & MSG_PEEK)) {
218 _debug("eat packet");
219 if (skb_dequeue(&rx->sk.sk_receive_queue) !=
220 skb)
221 BUG();
222 rxrpc_free_skb(skb);
223 }
224 msg->msg_flags &= ~MSG_MORE;
225 break;
226 }
227
228 /* move on to the next data message */
229 _debug("next");
230 if (!continue_call)
231 continue_call = sp->call;
232 else
233 rxrpc_put_call(call);
234 call = NULL;
235
236 if (flags & MSG_PEEK) {
237 _debug("peek next");
238 skb = skb->next;
239 if (skb == (struct sk_buff *) &rx->sk.sk_receive_queue)
240 break;
241 goto peek_next_packet;
242 }
243
244 _debug("eat packet");
245 if (skb_dequeue(&rx->sk.sk_receive_queue) != skb)
246 BUG();
247 rxrpc_free_skb(skb);
248 }
249
250 /* end of non-terminal data packet reception for the moment */
251 _debug("end rcv data");
252out:
253 release_sock(&rx->sk);
254 if (call)
255 rxrpc_put_call(call);
256 if (continue_call)
257 rxrpc_put_call(continue_call);
258 _leave(" = %d [data]", copied);
259 return copied;
260
261 /* handle non-DATA messages such as aborts, incoming connections and
262 * final ACKs */
263receive_non_data_message:
264 _debug("non-data");
265
266 if (skb->mark == RXRPC_SKB_MARK_NEW_CALL) {
267 _debug("RECV NEW CALL");
268 ret = put_cmsg(msg, SOL_RXRPC, RXRPC_NEW_CALL, 0, &abort_code);
269 if (ret < 0)
270 goto copy_error;
271 if (!(flags & MSG_PEEK)) {
272 if (skb_dequeue(&rx->sk.sk_receive_queue) != skb)
273 BUG();
274 rxrpc_free_skb(skb);
275 }
276 goto out;
277 }
278
279 ret = put_cmsg(msg, SOL_RXRPC, RXRPC_USER_CALL_ID,
280 ullen, &call->user_call_ID);
281 if (ret < 0)
282 goto copy_error;
283 ASSERT(test_bit(RXRPC_CALL_HAS_USERID, &call->flags));
284
285 switch (skb->mark) {
286 case RXRPC_SKB_MARK_DATA:
287 BUG();
288 case RXRPC_SKB_MARK_FINAL_ACK:
289 ret = put_cmsg(msg, SOL_RXRPC, RXRPC_ACK, 0, &abort_code);
290 break;
291 case RXRPC_SKB_MARK_BUSY:
292 ret = put_cmsg(msg, SOL_RXRPC, RXRPC_BUSY, 0, &abort_code);
293 break;
294 case RXRPC_SKB_MARK_REMOTE_ABORT:
295 abort_code = call->abort_code;
296 ret = put_cmsg(msg, SOL_RXRPC, RXRPC_ABORT, 4, &abort_code);
297 break;
298 case RXRPC_SKB_MARK_NET_ERROR:
299 _debug("RECV NET ERROR %d", sp->error);
300 abort_code = sp->error;
301 ret = put_cmsg(msg, SOL_RXRPC, RXRPC_NET_ERROR, 4, &abort_code);
302 break;
303 case RXRPC_SKB_MARK_LOCAL_ERROR:
304 _debug("RECV LOCAL ERROR %d", sp->error);
305 abort_code = sp->error;
306 ret = put_cmsg(msg, SOL_RXRPC, RXRPC_LOCAL_ERROR, 4,
307 &abort_code);
308 break;
309 default:
310 BUG();
311 break;
312 }
313
314 if (ret < 0)
315 goto copy_error;
316
317terminal_message:
318 _debug("terminal");
319 msg->msg_flags &= ~MSG_MORE;
320 msg->msg_flags |= MSG_EOR;
321
322 if (!(flags & MSG_PEEK)) {
323 _net("free terminal skb %p", skb);
324 if (skb_dequeue(&rx->sk.sk_receive_queue) != skb)
325 BUG();
326 rxrpc_free_skb(skb);
327 rxrpc_remove_user_ID(rx, call);
328 }
329
330 release_sock(&rx->sk);
331 rxrpc_put_call(call);
332 if (continue_call)
333 rxrpc_put_call(continue_call);
334 _leave(" = %d", ret);
335 return ret;
336
337copy_error:
338 _debug("copy error");
339 release_sock(&rx->sk);
340 rxrpc_put_call(call);
341 if (continue_call)
342 rxrpc_put_call(continue_call);
343 _leave(" = %d", ret);
344 return ret;
345
346csum_copy_error:
347 _debug("csum error");
348 release_sock(&rx->sk);
349 if (continue_call)
350 rxrpc_put_call(continue_call);
351 rxrpc_kill_skb(skb);
352 skb_kill_datagram(&rx->sk, skb, flags);
353 rxrpc_put_call(call);
354 return -EAGAIN;
355
356wait_interrupted:
357 ret = sock_intr_errno(timeo);
358wait_error:
359 finish_wait(sk_sleep(&rx->sk), &wait);
360 if (continue_call)
361 rxrpc_put_call(continue_call);
362 if (copied)
363 copied = ret;
364 _leave(" = %d [waitfail %d]", copied, ret);
365 return copied;
366
367}
368
369/**
370 * rxrpc_kernel_data_delivered - Record delivery of data message
371 * @skb: Message holding data
372 *
373 * Record the delivery of a data message. This permits RxRPC to keep its
374 * tracking correct. The socket buffer will be deleted.
375 */
376void rxrpc_kernel_data_delivered(struct sk_buff *skb)
377{
378 struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
379 struct rxrpc_call *call = sp->call;
380
381 ASSERTCMP(ntohl(sp->hdr.seq), >=, call->rx_data_recv);
382 ASSERTCMP(ntohl(sp->hdr.seq), <=, call->rx_data_recv + 1);
383 call->rx_data_recv = ntohl(sp->hdr.seq);
384
385 ASSERTCMP(ntohl(sp->hdr.seq), >, call->rx_data_eaten);
386 rxrpc_free_skb(skb);
387}
388
389EXPORT_SYMBOL(rxrpc_kernel_data_delivered);
390
391/**
392 * rxrpc_kernel_is_data_last - Determine if data message is last one
393 * @skb: Message holding data
394 *
395 * Determine if data message is last one for the parent call.
396 */
397bool rxrpc_kernel_is_data_last(struct sk_buff *skb)
398{
399 struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
400
401 ASSERTCMP(skb->mark, ==, RXRPC_SKB_MARK_DATA);
402
403 return sp->hdr.flags & RXRPC_LAST_PACKET;
404}
405
406EXPORT_SYMBOL(rxrpc_kernel_is_data_last);
407
408/**
409 * rxrpc_kernel_get_abort_code - Get the abort code from an RxRPC abort message
410 * @skb: Message indicating an abort
411 *
412 * Get the abort code from an RxRPC abort message.
413 */
414u32 rxrpc_kernel_get_abort_code(struct sk_buff *skb)
415{
416 struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
417
418 ASSERTCMP(skb->mark, ==, RXRPC_SKB_MARK_REMOTE_ABORT);
419
420 return sp->call->abort_code;
421}
422
423EXPORT_SYMBOL(rxrpc_kernel_get_abort_code);
424
425/**
426 * rxrpc_kernel_get_error - Get the error number from an RxRPC error message
427 * @skb: Message indicating an error
428 *
429 * Get the error number from an RxRPC error message.
430 */
431int rxrpc_kernel_get_error_number(struct sk_buff *skb)
432{
433 struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
434
435 return sp->error;
436}
437
438EXPORT_SYMBOL(rxrpc_kernel_get_error_number);