?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
writeback: split writeback_inodes_wb
[linux-2.6/next.git] / net / rxrpc / ar-output.c
blob5f22e263eda748ffdbe06f802626588a70776004
1 /* RxRPC packet transmission
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/gfp.h>
14 #include <linux/skbuff.h>
15 #include <linux/circ_buf.h>
16 #include <net/sock.h>
17 #include <net/af_rxrpc.h>
18 #include "ar-internal.h"
19
20 int rxrpc_resend_timeout = 4;
21
22 static int rxrpc_send_data(struct kiocb *iocb,
23 struct rxrpc_sock *rx,
24 struct rxrpc_call *call,
25 struct msghdr *msg, size_t len);
26
27 /*
28 * extract control messages from the sendmsg() control buffer
29 */
30 static int rxrpc_sendmsg_cmsg(struct rxrpc_sock *rx, struct msghdr *msg,
31 unsigned long *user_call_ID,
32 enum rxrpc_command *command,
33 u32 *abort_code,
34 bool server)
35 {
36 struct cmsghdr *cmsg;
37 int len;
38
39 *command = RXRPC_CMD_SEND_DATA;
40
41 if (msg->msg_controllen == 0)
42 return -EINVAL;
43
44 for (cmsg = CMSG_FIRSTHDR(msg); cmsg; cmsg = CMSG_NXTHDR(msg, cmsg)) {
45 if (!CMSG_OK(msg, cmsg))
46 return -EINVAL;
47
48 len = cmsg->cmsg_len - CMSG_ALIGN(sizeof(struct cmsghdr));
49 _debug("CMSG %d, %d, %d",
50 cmsg->cmsg_level, cmsg->cmsg_type, len);
51
52 if (cmsg->cmsg_level != SOL_RXRPC)
53 continue;
54
55 switch (cmsg->cmsg_type) {
56 case RXRPC_USER_CALL_ID:
57 if (msg->msg_flags & MSG_CMSG_COMPAT) {
58 if (len != sizeof(u32))
59 return -EINVAL;
60 *user_call_ID = *(u32 *) CMSG_DATA(cmsg);
61 } else {
62 if (len != sizeof(unsigned long))
63 return -EINVAL;
64 *user_call_ID = *(unsigned long *)
65 CMSG_DATA(cmsg);
66 }
67 _debug("User Call ID %lx", *user_call_ID);
68 break;
69
70 case RXRPC_ABORT:
71 if (*command != RXRPC_CMD_SEND_DATA)
72 return -EINVAL;
73 *command = RXRPC_CMD_SEND_ABORT;
74 if (len != sizeof(*abort_code))
75 return -EINVAL;
76 *abort_code = *(unsigned int *) CMSG_DATA(cmsg);
77 _debug("Abort %x", *abort_code);
78 if (*abort_code == 0)
79 return -EINVAL;
80 break;
81
82 case RXRPC_ACCEPT:
83 if (*command != RXRPC_CMD_SEND_DATA)
84 return -EINVAL;
85 *command = RXRPC_CMD_ACCEPT;
86 if (len != 0)
87 return -EINVAL;
88 if (!server)
89 return -EISCONN;
90 break;
91
92 default:
93 return -EINVAL;
94 }
95 }
96
97 _leave(" = 0");
98 return 0;
99 }
100
101 /*
102 * abort a call, sending an ABORT packet to the peer
103 */
104 static void rxrpc_send_abort(struct rxrpc_call *call, u32 abort_code)
105 {
106 write_lock_bh(&call->state_lock);
107
108 if (call->state <= RXRPC_CALL_COMPLETE) {
109 call->state = RXRPC_CALL_LOCALLY_ABORTED;
110 call->abort_code = abort_code;
111 set_bit(RXRPC_CALL_ABORT, &call->events);
112 del_timer_sync(&call->resend_timer);
113 del_timer_sync(&call->ack_timer);
114 clear_bit(RXRPC_CALL_RESEND_TIMER, &call->events);
115 clear_bit(RXRPC_CALL_ACK, &call->events);
116 clear_bit(RXRPC_CALL_RUN_RTIMER, &call->flags);
117 rxrpc_queue_call(call);
118 }
119
120 write_unlock_bh(&call->state_lock);
121 }
122
123 /*
124 * send a message forming part of a client call through an RxRPC socket
125 * - caller holds the socket locked
126 * - the socket may be either a client socket or a server socket
127 */
128 int rxrpc_client_sendmsg(struct kiocb *iocb, struct rxrpc_sock *rx,
129 struct rxrpc_transport *trans, struct msghdr *msg,
130 size_t len)
131 {
132 struct rxrpc_conn_bundle *bundle;
133 enum rxrpc_command cmd;
134 struct rxrpc_call *call;
135 unsigned long user_call_ID = 0;
136 struct key *key;
137 __be16 service_id;
138 u32 abort_code = 0;
139 int ret;
140
141 _enter("");
142
143 ASSERT(trans != NULL);
144
145 ret = rxrpc_sendmsg_cmsg(rx, msg, &user_call_ID, &cmd, &abort_code,
146 false);
147 if (ret < 0)
148 return ret;
149
150 bundle = NULL;
151 if (trans) {
152 service_id = rx->service_id;
153 if (msg->msg_name) {
154 struct sockaddr_rxrpc *srx =
155 (struct sockaddr_rxrpc *) msg->msg_name;
156 service_id = htons(srx->srx_service);
157 }
158 key = rx->key;
159 if (key && !rx->key->payload.data)
160 key = NULL;
161 bundle = rxrpc_get_bundle(rx, trans, key, service_id,
162 GFP_KERNEL);
163 if (IS_ERR(bundle))
164 return PTR_ERR(bundle);
165 }
166
167 call = rxrpc_get_client_call(rx, trans, bundle, user_call_ID,
168 abort_code == 0, GFP_KERNEL);
169 if (trans)
170 rxrpc_put_bundle(trans, bundle);
171 if (IS_ERR(call)) {
172 _leave(" = %ld", PTR_ERR(call));
173 return PTR_ERR(call);
174 }
175
176 _debug("CALL %d USR %lx ST %d on CONN %p",
177 call->debug_id, call->user_call_ID, call->state, call->conn);
178
179 if (call->state >= RXRPC_CALL_COMPLETE) {
180 /* it's too late for this call */
181 ret = -ESHUTDOWN;
182 } else if (cmd == RXRPC_CMD_SEND_ABORT) {
183 rxrpc_send_abort(call, abort_code);
184 } else if (cmd != RXRPC_CMD_SEND_DATA) {
185 ret = -EINVAL;
186 } else if (call->state != RXRPC_CALL_CLIENT_SEND_REQUEST) {
187 /* request phase complete for this client call */
188 ret = -EPROTO;
189 } else {
190 ret = rxrpc_send_data(iocb, rx, call, msg, len);
191 }
192
193 rxrpc_put_call(call);
194 _leave(" = %d", ret);
195 return ret;
196 }
197
198 /**
199 * rxrpc_kernel_send_data - Allow a kernel service to send data on a call
200 * @call: The call to send data through
201 * @msg: The data to send
202 * @len: The amount of data to send
203 *
204 * Allow a kernel service to send data on a call. The call must be in an state
205 * appropriate to sending data. No control data should be supplied in @msg,
206 * nor should an address be supplied. MSG_MORE should be flagged if there's
207 * more data to come, otherwise this data will end the transmission phase.
208 */
209 int rxrpc_kernel_send_data(struct rxrpc_call *call, struct msghdr *msg,
210 size_t len)
211 {
212 int ret;
213
214 _enter("{%d,%s},", call->debug_id, rxrpc_call_states[call->state]);
215
216 ASSERTCMP(msg->msg_name, ==, NULL);
217 ASSERTCMP(msg->msg_control, ==, NULL);
218
219 lock_sock(&call->socket->sk);
220
221 _debug("CALL %d USR %lx ST %d on CONN %p",
222 call->debug_id, call->user_call_ID, call->state, call->conn);
223
224 if (call->state >= RXRPC_CALL_COMPLETE) {
225 ret = -ESHUTDOWN; /* it's too late for this call */
226 } else if (call->state != RXRPC_CALL_CLIENT_SEND_REQUEST &&
227 call->state != RXRPC_CALL_SERVER_ACK_REQUEST &&
228 call->state != RXRPC_CALL_SERVER_SEND_REPLY) {
229 ret = -EPROTO; /* request phase complete for this client call */
230 } else {
231 mm_segment_t oldfs = get_fs();
232 set_fs(KERNEL_DS);
233 ret = rxrpc_send_data(NULL, call->socket, call, msg, len);
234 set_fs(oldfs);
235 }
236
237 release_sock(&call->socket->sk);
238 _leave(" = %d", ret);
239 return ret;
240 }
241
242 EXPORT_SYMBOL(rxrpc_kernel_send_data);
243
244 /*
245 * rxrpc_kernel_abort_call - Allow a kernel service to abort a call
246 * @call: The call to be aborted
247 * @abort_code: The abort code to stick into the ABORT packet
248 *
249 * Allow a kernel service to abort a call, if it's still in an abortable state.
250 */
251 void rxrpc_kernel_abort_call(struct rxrpc_call *call, u32 abort_code)
252 {
253 _enter("{%d},%d", call->debug_id, abort_code);
254
255 lock_sock(&call->socket->sk);
256
257 _debug("CALL %d USR %lx ST %d on CONN %p",
258 call->debug_id, call->user_call_ID, call->state, call->conn);
259
260 if (call->state < RXRPC_CALL_COMPLETE)
261 rxrpc_send_abort(call, abort_code);
262
263 release_sock(&call->socket->sk);
264 _leave("");
265 }
266
267 EXPORT_SYMBOL(rxrpc_kernel_abort_call);
268
269 /*
270 * send a message through a server socket
271 * - caller holds the socket locked
272 */
273 int rxrpc_server_sendmsg(struct kiocb *iocb, struct rxrpc_sock *rx,
274 struct msghdr *msg, size_t len)
275 {
276 enum rxrpc_command cmd;
277 struct rxrpc_call *call;
278 unsigned long user_call_ID = 0;
279 u32 abort_code = 0;
280 int ret;
281
282 _enter("");
283
284 ret = rxrpc_sendmsg_cmsg(rx, msg, &user_call_ID, &cmd, &abort_code,
285 true);
286 if (ret < 0)
287 return ret;
288
289 if (cmd == RXRPC_CMD_ACCEPT) {
290 call = rxrpc_accept_call(rx, user_call_ID);
291 if (IS_ERR(call))
292 return PTR_ERR(call);
293 rxrpc_put_call(call);
294 return 0;
295 }
296
297 call = rxrpc_find_server_call(rx, user_call_ID);
298 if (!call)
299 return -EBADSLT;
300 if (call->state >= RXRPC_CALL_COMPLETE) {
301 ret = -ESHUTDOWN;
302 goto out;
303 }
304
305 switch (cmd) {
306 case RXRPC_CMD_SEND_DATA:
307 if (call->state != RXRPC_CALL_CLIENT_SEND_REQUEST &&
308 call->state != RXRPC_CALL_SERVER_ACK_REQUEST &&
309 call->state != RXRPC_CALL_SERVER_SEND_REPLY) {
310 /* Tx phase not yet begun for this call */
311 ret = -EPROTO;
312 break;
313 }
314
315 ret = rxrpc_send_data(iocb, rx, call, msg, len);
316 break;
317
318 case RXRPC_CMD_SEND_ABORT:
319 rxrpc_send_abort(call, abort_code);
320 break;
321 default:
322 BUG();
323 }
324
325 out:
326 rxrpc_put_call(call);
327 _leave(" = %d", ret);
328 return ret;
329 }
330
331 /*
332 * send a packet through the transport endpoint
333 */
334 int rxrpc_send_packet(struct rxrpc_transport *trans, struct sk_buff *skb)
335 {
336 struct kvec iov[1];
337 struct msghdr msg;
338 int ret, opt;
339
340 _enter(",{%d}", skb->len);
341
342 iov[0].iov_base = skb->head;
343 iov[0].iov_len = skb->len;
344
345 msg.msg_name = &trans->peer->srx.transport.sin;
346 msg.msg_namelen = sizeof(trans->peer->srx.transport.sin);
347 msg.msg_control = NULL;
348 msg.msg_controllen = 0;
349 msg.msg_flags = 0;
350
351 /* send the packet with the don't fragment bit set if we currently
352 * think it's small enough */
353 if (skb->len - sizeof(struct rxrpc_header) < trans->peer->maxdata) {
354 down_read(&trans->local->defrag_sem);
355 /* send the packet by UDP
356 * - returns -EMSGSIZE if UDP would have to fragment the packet
357 * to go out of the interface
358 * - in which case, we'll have processed the ICMP error
359 * message and update the peer record
360 */
361 ret = kernel_sendmsg(trans->local->socket, &msg, iov, 1,
362 iov[0].iov_len);
363
364 up_read(&trans->local->defrag_sem);
365 if (ret == -EMSGSIZE)
366 goto send_fragmentable;
367
368 _leave(" = %d [%u]", ret, trans->peer->maxdata);
369 return ret;
370 }
371
372 send_fragmentable:
373 /* attempt to send this message with fragmentation enabled */
374 _debug("send fragment");
375
376 down_write(&trans->local->defrag_sem);
377 opt = IP_PMTUDISC_DONT;
378 ret = kernel_setsockopt(trans->local->socket, SOL_IP, IP_MTU_DISCOVER,
379 (char *) &opt, sizeof(opt));
380 if (ret == 0) {
381 ret = kernel_sendmsg(trans->local->socket, &msg, iov, 1,
382 iov[0].iov_len);
383
384 opt = IP_PMTUDISC_DO;
385 kernel_setsockopt(trans->local->socket, SOL_IP,
386 IP_MTU_DISCOVER, (char *) &opt, sizeof(opt));
387 }
388
389 up_write(&trans->local->defrag_sem);
390 _leave(" = %d [frag %u]", ret, trans->peer->maxdata);
391 return ret;
392 }
393
394 /*
395 * wait for space to appear in the transmit/ACK window
396 * - caller holds the socket locked
397 */
398 static int rxrpc_wait_for_tx_window(struct rxrpc_sock *rx,
399 struct rxrpc_call *call,
400 long *timeo)
401 {
402 DECLARE_WAITQUEUE(myself, current);
403 int ret;
404
405 _enter(",{%d},%ld",
406 CIRC_SPACE(call->acks_head, call->acks_tail, call->acks_winsz),
407 *timeo);
408
409 add_wait_queue(&call->tx_waitq, &myself);
410
411 for (;;) {
412 set_current_state(TASK_INTERRUPTIBLE);
413 ret = 0;
414 if (CIRC_SPACE(call->acks_head, call->acks_tail,
415 call->acks_winsz) > 0)
416 break;
417 if (signal_pending(current)) {
418 ret = sock_intr_errno(*timeo);
419 break;
420 }
421
422 release_sock(&rx->sk);
423 *timeo = schedule_timeout(*timeo);
424 lock_sock(&rx->sk);
425 }
426
427 remove_wait_queue(&call->tx_waitq, &myself);
428 set_current_state(TASK_RUNNING);
429 _leave(" = %d", ret);
430 return ret;
431 }
432
433 /*
434 * attempt to schedule an instant Tx resend
435 */
436 static inline void rxrpc_instant_resend(struct rxrpc_call *call)
437 {
438 read_lock_bh(&call->state_lock);
439 if (try_to_del_timer_sync(&call->resend_timer) >= 0) {
440 clear_bit(RXRPC_CALL_RUN_RTIMER, &call->flags);
441 if (call->state < RXRPC_CALL_COMPLETE &&
442 !test_and_set_bit(RXRPC_CALL_RESEND_TIMER, &call->events))
443 rxrpc_queue_call(call);
444 }
445 read_unlock_bh(&call->state_lock);
446 }
447
448 /*
449 * queue a packet for transmission, set the resend timer and attempt
450 * to send the packet immediately
451 */
452 static void rxrpc_queue_packet(struct rxrpc_call *call, struct sk_buff *skb,
453 bool last)
454 {
455 struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
456 int ret;
457
458 _net("queue skb %p [%d]", skb, call->acks_head);
459
460 ASSERT(call->acks_window != NULL);
461 call->acks_window[call->acks_head] = (unsigned long) skb;
462 smp_wmb();
463 call->acks_head = (call->acks_head + 1) & (call->acks_winsz - 1);
464
465 if (last || call->state == RXRPC_CALL_SERVER_ACK_REQUEST) {
466 _debug("________awaiting reply/ACK__________");
467 write_lock_bh(&call->state_lock);
468 switch (call->state) {
469 case RXRPC_CALL_CLIENT_SEND_REQUEST:
470 call->state = RXRPC_CALL_CLIENT_AWAIT_REPLY;
471 break;
472 case RXRPC_CALL_SERVER_ACK_REQUEST:
473 call->state = RXRPC_CALL_SERVER_SEND_REPLY;
474 if (!last)
475 break;
476 case RXRPC_CALL_SERVER_SEND_REPLY:
477 call->state = RXRPC_CALL_SERVER_AWAIT_ACK;
478 break;
479 default:
480 break;
481 }
482 write_unlock_bh(&call->state_lock);
483 }
484
485 _proto("Tx DATA %%%u { #%u }",
486 ntohl(sp->hdr.serial), ntohl(sp->hdr.seq));
487
488 sp->need_resend = 0;
489 sp->resend_at = jiffies + rxrpc_resend_timeout * HZ;
490 if (!test_and_set_bit(RXRPC_CALL_RUN_RTIMER, &call->flags)) {
491 _debug("run timer");
492 call->resend_timer.expires = sp->resend_at;
493 add_timer(&call->resend_timer);
494 }
495
496 /* attempt to cancel the rx-ACK timer, deferring reply transmission if
497 * we're ACK'ing the request phase of an incoming call */
498 ret = -EAGAIN;
499 if (try_to_del_timer_sync(&call->ack_timer) >= 0) {
500 /* the packet may be freed by rxrpc_process_call() before this
501 * returns */
502 ret = rxrpc_send_packet(call->conn->trans, skb);
503 _net("sent skb %p", skb);
504 } else {
505 _debug("failed to delete ACK timer");
506 }
507
508 if (ret < 0) {
509 _debug("need instant resend %d", ret);
510 sp->need_resend = 1;
511 rxrpc_instant_resend(call);
512 }
513
514 _leave("");
515 }
516
517 /*
518 * send data through a socket
519 * - must be called in process context
520 * - caller holds the socket locked
521 */
522 static int rxrpc_send_data(struct kiocb *iocb,
523 struct rxrpc_sock *rx,
524 struct rxrpc_call *call,
525 struct msghdr *msg, size_t len)
526 {
527 struct rxrpc_skb_priv *sp;
528 unsigned char __user *from;
529 struct sk_buff *skb;
530 struct iovec *iov;
531 struct sock *sk = &rx->sk;
532 long timeo;
533 bool more;
534 int ret, ioc, segment, copied;
535
536 _enter(",,,{%zu},%zu", msg->msg_iovlen, len);
537
538 timeo = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT);
539
540 /* this should be in poll */
541 clear_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
542
543 if (sk->sk_err || (sk->sk_shutdown & SEND_SHUTDOWN))
544 return -EPIPE;
545
546 iov = msg->msg_iov;
547 ioc = msg->msg_iovlen - 1;
548 from = iov->iov_base;
549 segment = iov->iov_len;
550 iov++;
551 more = msg->msg_flags & MSG_MORE;
552
553 skb = call->tx_pending;
554 call->tx_pending = NULL;
555
556 copied = 0;
557 do {
558 int copy;
559
560 if (segment > len)
561 segment = len;
562
563 _debug("SEGMENT %d @%p", segment, from);
564
565 if (!skb) {
566 size_t size, chunk, max, space;
567
568 _debug("alloc");
569
570 if (CIRC_SPACE(call->acks_head, call->acks_tail,
571 call->acks_winsz) <= 0) {
572 ret = -EAGAIN;
573 if (msg->msg_flags & MSG_DONTWAIT)
574 goto maybe_error;
575 ret = rxrpc_wait_for_tx_window(rx, call,
576 &timeo);
577 if (ret < 0)
578 goto maybe_error;
579 }
580
581 max = call->conn->trans->peer->maxdata;
582 max -= call->conn->security_size;
583 max &= ~(call->conn->size_align - 1UL);
584
585 chunk = max;
586 if (chunk > len && !more)
587 chunk = len;
588
589 space = chunk + call->conn->size_align;
590 space &= ~(call->conn->size_align - 1UL);
591
592 size = space + call->conn->header_size;
593
594 _debug("SIZE: %zu/%zu/%zu", chunk, space, size);
595
596 /* create a buffer that we can retain until it's ACK'd */
597 skb = sock_alloc_send_skb(
598 sk, size, msg->msg_flags & MSG_DONTWAIT, &ret);
599 if (!skb)
600 goto maybe_error;
601
602 rxrpc_new_skb(skb);
603
604 _debug("ALLOC SEND %p", skb);
605
606 ASSERTCMP(skb->mark, ==, 0);
607
608 _debug("HS: %u", call->conn->header_size);
609 skb_reserve(skb, call->conn->header_size);
610 skb->len += call->conn->header_size;
611
612 sp = rxrpc_skb(skb);
613 sp->remain = chunk;
614 if (sp->remain > skb_tailroom(skb))
615 sp->remain = skb_tailroom(skb);
616
617 _net("skb: hr %d, tr %d, hl %d, rm %d",
618 skb_headroom(skb),
619 skb_tailroom(skb),
620 skb_headlen(skb),
621 sp->remain);
622
623 skb->ip_summed = CHECKSUM_UNNECESSARY;
624 }
625
626 _debug("append");
627 sp = rxrpc_skb(skb);
628
629 /* append next segment of data to the current buffer */
630 copy = skb_tailroom(skb);
631 ASSERTCMP(copy, >, 0);
632 if (copy > segment)
633 copy = segment;
634 if (copy > sp->remain)
635 copy = sp->remain;
636
637 _debug("add");
638 ret = skb_add_data(skb, from, copy);
639 _debug("added");
640 if (ret < 0)
641 goto efault;
642 sp->remain -= copy;
643 skb->mark += copy;
644 copied += copy;
645
646 len -= copy;
647 segment -= copy;
648 from += copy;
649 while (segment == 0 && ioc > 0) {
650 from = iov->iov_base;
651 segment = iov->iov_len;
652 iov++;
653 ioc--;
654 }
655 if (len == 0) {
656 segment = 0;
657 ioc = 0;
658 }
659
660 /* check for the far side aborting the call or a network error
661 * occurring */
662 if (call->state > RXRPC_CALL_COMPLETE)
663 goto call_aborted;
664
665 /* add the packet to the send queue if it's now full */
666 if (sp->remain <= 0 || (segment == 0 && !more)) {
667 struct rxrpc_connection *conn = call->conn;
668 size_t pad;
669
670 /* pad out if we're using security */
671 if (conn->security) {
672 pad = conn->security_size + skb->mark;
673 pad = conn->size_align - pad;
674 pad &= conn->size_align - 1;
675 _debug("pad %zu", pad);
676 if (pad)
677 memset(skb_put(skb, pad), 0, pad);
678 }
679
680 sp->hdr.epoch = conn->epoch;
681 sp->hdr.cid = call->cid;
682 sp->hdr.callNumber = call->call_id;
683 sp->hdr.seq =
684 htonl(atomic_inc_return(&call->sequence));
685 sp->hdr.serial =
686 htonl(atomic_inc_return(&conn->serial));
687 sp->hdr.type = RXRPC_PACKET_TYPE_DATA;
688 sp->hdr.userStatus = 0;
689 sp->hdr.securityIndex = conn->security_ix;
690 sp->hdr._rsvd = 0;
691 sp->hdr.serviceId = conn->service_id;
692
693 sp->hdr.flags = conn->out_clientflag;
694 if (len == 0 && !more)
695 sp->hdr.flags |= RXRPC_LAST_PACKET;
696 else if (CIRC_SPACE(call->acks_head, call->acks_tail,
697 call->acks_winsz) > 1)
698 sp->hdr.flags |= RXRPC_MORE_PACKETS;
699
700 ret = rxrpc_secure_packet(
701 call, skb, skb->mark,
702 skb->head + sizeof(struct rxrpc_header));
703 if (ret < 0)
704 goto out;
705
706 memcpy(skb->head, &sp->hdr,
707 sizeof(struct rxrpc_header));
708 rxrpc_queue_packet(call, skb, segment == 0 && !more);
709 skb = NULL;
710 }
711
712 } while (segment > 0);
713
714 success:
715 ret = copied;
716 out:
717 call->tx_pending = skb;
718 _leave(" = %d", ret);
719 return ret;
720
721 call_aborted:
722 rxrpc_free_skb(skb);
723 if (call->state == RXRPC_CALL_NETWORK_ERROR)
724 ret = call->conn->trans->peer->net_error;
725 else
726 ret = -ECONNABORTED;
727 _leave(" = %d", ret);
728 return ret;
729
730 maybe_error:
731 if (copied)
732 goto success;
733 goto out;
734
735 efault:
736 ret = -EFAULT;
737 goto out;
738 }
linux-next