]>
git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blob - net/rxrpc/output.c
1 /* RxRPC packet transmission
3 * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
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.
12 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
14 #include <linux/net.h>
15 #include <linux/gfp.h>
16 #include <linux/skbuff.h>
17 #include <linux/export.h>
19 #include <net/af_rxrpc.h>
20 #include "ar-internal.h"
22 struct rxrpc_pkt_buffer
{
23 struct rxrpc_wire_header whdr
;
26 struct rxrpc_ackpacket ack
;
32 struct rxrpc_ackinfo ackinfo
;
36 * Fill out an ACK packet.
38 static size_t rxrpc_fill_out_ack(struct rxrpc_call
*call
,
39 struct rxrpc_pkt_buffer
*pkt
)
41 rxrpc_seq_t hard_ack
, top
, seq
;
46 /* Barrier against rxrpc_input_data(). */
47 hard_ack
= READ_ONCE(call
->rx_hard_ack
);
48 top
= smp_load_acquire(&call
->rx_top
);
50 pkt
->ack
.bufferSpace
= htons(8);
51 pkt
->ack
.maxSkew
= htons(call
->ackr_skew
);
52 pkt
->ack
.firstPacket
= htonl(hard_ack
+ 1);
53 pkt
->ack
.previousPacket
= htonl(call
->ackr_prev_seq
);
54 pkt
->ack
.serial
= htonl(call
->ackr_serial
);
55 pkt
->ack
.reason
= call
->ackr_reason
;
56 pkt
->ack
.nAcks
= top
- hard_ack
;
58 if (after(top
, hard_ack
)) {
61 ix
= seq
& RXRPC_RXTX_BUFF_MASK
;
62 if (call
->rxtx_buffer
[ix
])
63 *ackp
++ = RXRPC_ACK_TYPE_ACK
;
65 *ackp
++ = RXRPC_ACK_TYPE_NACK
;
67 } while (before_eq(seq
, top
));
70 mtu
= call
->conn
->params
.peer
->if_mtu
;
71 mtu
-= call
->conn
->params
.peer
->hdrsize
;
72 jmax
= (call
->nr_jumbo_bad
> 3) ? 1 : rxrpc_rx_jumbo_max
;
73 pkt
->ackinfo
.rxMTU
= htonl(rxrpc_rx_mtu
);
74 pkt
->ackinfo
.maxMTU
= htonl(mtu
);
75 pkt
->ackinfo
.rwind
= htonl(call
->rx_winsize
);
76 pkt
->ackinfo
.jumbo_max
= htonl(jmax
);
81 return top
- hard_ack
+ 3;
85 * Send an ACK or ABORT call packet.
87 int rxrpc_send_call_packet(struct rxrpc_call
*call
, u8 type
)
89 struct rxrpc_connection
*conn
= NULL
;
90 struct rxrpc_pkt_buffer
*pkt
;
93 rxrpc_serial_t serial
;
98 _enter("%u,%s", call
->debug_id
, rxrpc_pkts
[type
]);
100 spin_lock_bh(&call
->lock
);
102 conn
= rxrpc_get_connection_maybe(call
->conn
);
103 spin_unlock_bh(&call
->lock
);
107 pkt
= kzalloc(sizeof(*pkt
), GFP_KERNEL
);
109 rxrpc_put_connection(conn
);
113 serial
= atomic_inc_return(&conn
->serial
);
115 msg
.msg_name
= &call
->peer
->srx
.transport
;
116 msg
.msg_namelen
= call
->peer
->srx
.transport_len
;
117 msg
.msg_control
= NULL
;
118 msg
.msg_controllen
= 0;
121 pkt
->whdr
.epoch
= htonl(conn
->proto
.epoch
);
122 pkt
->whdr
.cid
= htonl(call
->cid
);
123 pkt
->whdr
.callNumber
= htonl(call
->call_id
);
125 pkt
->whdr
.serial
= htonl(serial
);
126 pkt
->whdr
.type
= type
;
127 pkt
->whdr
.flags
= conn
->out_clientflag
;
128 pkt
->whdr
.userStatus
= 0;
129 pkt
->whdr
.securityIndex
= call
->security_ix
;
131 pkt
->whdr
.serviceId
= htons(call
->service_id
);
133 iov
[0].iov_base
= pkt
;
134 iov
[0].iov_len
= sizeof(pkt
->whdr
);
135 len
= sizeof(pkt
->whdr
);
138 case RXRPC_PACKET_TYPE_ACK
:
139 spin_lock_bh(&call
->lock
);
140 if (!call
->ackr_reason
) {
141 spin_unlock_bh(&call
->lock
);
145 n
= rxrpc_fill_out_ack(call
, pkt
);
146 call
->ackr_reason
= 0;
148 spin_unlock_bh(&call
->lock
);
150 _proto("Tx ACK %%%u { m=%hu f=#%u p=#%u s=%%%u r=%s n=%u }",
152 ntohs(pkt
->ack
.maxSkew
),
153 ntohl(pkt
->ack
.firstPacket
),
154 ntohl(pkt
->ack
.previousPacket
),
155 ntohl(pkt
->ack
.serial
),
156 rxrpc_acks(pkt
->ack
.reason
),
159 iov
[0].iov_len
+= sizeof(pkt
->ack
) + n
;
160 iov
[1].iov_base
= &pkt
->ackinfo
;
161 iov
[1].iov_len
= sizeof(pkt
->ackinfo
);
162 len
+= sizeof(pkt
->ack
) + n
+ sizeof(pkt
->ackinfo
);
166 case RXRPC_PACKET_TYPE_ABORT
:
167 abort_code
= call
->abort_code
;
168 pkt
->abort_code
= htonl(abort_code
);
169 _proto("Tx ABORT %%%u { %d }", serial
, abort_code
);
170 iov
[0].iov_len
+= sizeof(pkt
->abort_code
);
171 len
+= sizeof(pkt
->abort_code
);
181 ret
= kernel_sendmsg(conn
->params
.local
->socket
,
182 &msg
, iov
, ioc
, len
);
184 if (ret
< 0 && call
->state
< RXRPC_CALL_COMPLETE
) {
185 switch (pkt
->whdr
.type
) {
186 case RXRPC_PACKET_TYPE_ACK
:
187 rxrpc_propose_ACK(call
, pkt
->ack
.reason
,
188 ntohs(pkt
->ack
.maxSkew
),
189 ntohl(pkt
->ack
.serial
),
192 case RXRPC_PACKET_TYPE_ABORT
:
198 rxrpc_put_connection(conn
);
204 * send a packet through the transport endpoint
206 int rxrpc_send_data_packet(struct rxrpc_connection
*conn
, struct sk_buff
*skb
)
212 _enter(",{%d}", skb
->len
);
214 iov
[0].iov_base
= skb
->head
;
215 iov
[0].iov_len
= skb
->len
;
217 msg
.msg_name
= &conn
->params
.peer
->srx
.transport
;
218 msg
.msg_namelen
= conn
->params
.peer
->srx
.transport_len
;
219 msg
.msg_control
= NULL
;
220 msg
.msg_controllen
= 0;
223 /* send the packet with the don't fragment bit set if we currently
224 * think it's small enough */
225 if (skb
->len
- sizeof(struct rxrpc_wire_header
) < conn
->params
.peer
->maxdata
) {
226 down_read(&conn
->params
.local
->defrag_sem
);
227 /* send the packet by UDP
228 * - returns -EMSGSIZE if UDP would have to fragment the packet
229 * to go out of the interface
230 * - in which case, we'll have processed the ICMP error
231 * message and update the peer record
233 ret
= kernel_sendmsg(conn
->params
.local
->socket
, &msg
, iov
, 1,
236 up_read(&conn
->params
.local
->defrag_sem
);
237 if (ret
== -EMSGSIZE
)
238 goto send_fragmentable
;
240 _leave(" = %d [%u]", ret
, conn
->params
.peer
->maxdata
);
245 /* attempt to send this message with fragmentation enabled */
246 _debug("send fragment");
248 down_write(&conn
->params
.local
->defrag_sem
);
250 switch (conn
->params
.local
->srx
.transport
.family
) {
252 opt
= IP_PMTUDISC_DONT
;
253 ret
= kernel_setsockopt(conn
->params
.local
->socket
,
254 SOL_IP
, IP_MTU_DISCOVER
,
255 (char *)&opt
, sizeof(opt
));
257 ret
= kernel_sendmsg(conn
->params
.local
->socket
, &msg
, iov
, 1,
260 opt
= IP_PMTUDISC_DO
;
261 kernel_setsockopt(conn
->params
.local
->socket
, SOL_IP
,
263 (char *)&opt
, sizeof(opt
));
267 #ifdef CONFIG_AF_RXRPC_IPV6
269 opt
= IPV6_PMTUDISC_DONT
;
270 ret
= kernel_setsockopt(conn
->params
.local
->socket
,
271 SOL_IPV6
, IPV6_MTU_DISCOVER
,
272 (char *)&opt
, sizeof(opt
));
274 ret
= kernel_sendmsg(conn
->params
.local
->socket
, &msg
,
275 iov
, 1, iov
[0].iov_len
);
277 opt
= IPV6_PMTUDISC_DO
;
278 kernel_setsockopt(conn
->params
.local
->socket
,
279 SOL_IPV6
, IPV6_MTU_DISCOVER
,
280 (char *)&opt
, sizeof(opt
));
286 up_write(&conn
->params
.local
->defrag_sem
);
287 _leave(" = %d [frag %u]", ret
, conn
->params
.peer
->maxdata
);
292 * reject packets through the local endpoint
294 void rxrpc_reject_packets(struct rxrpc_local
*local
)
296 struct sockaddr_rxrpc srx
;
297 struct rxrpc_skb_priv
*sp
;
298 struct rxrpc_wire_header whdr
;
305 _enter("%d", local
->debug_id
);
307 iov
[0].iov_base
= &whdr
;
308 iov
[0].iov_len
= sizeof(whdr
);
309 iov
[1].iov_base
= &code
;
310 iov
[1].iov_len
= sizeof(code
);
311 size
= sizeof(whdr
) + sizeof(code
);
313 msg
.msg_name
= &srx
.transport
;
314 msg
.msg_control
= NULL
;
315 msg
.msg_controllen
= 0;
318 memset(&whdr
, 0, sizeof(whdr
));
319 whdr
.type
= RXRPC_PACKET_TYPE_ABORT
;
321 while ((skb
= skb_dequeue(&local
->reject_queue
))) {
325 if (rxrpc_extract_addr_from_skb(&srx
, skb
) == 0) {
326 msg
.msg_namelen
= srx
.transport_len
;
328 code
= htonl(skb
->priority
);
330 whdr
.epoch
= htonl(sp
->hdr
.epoch
);
331 whdr
.cid
= htonl(sp
->hdr
.cid
);
332 whdr
.callNumber
= htonl(sp
->hdr
.callNumber
);
333 whdr
.serviceId
= htons(sp
->hdr
.serviceId
);
334 whdr
.flags
= sp
->hdr
.flags
;
335 whdr
.flags
^= RXRPC_CLIENT_INITIATED
;
336 whdr
.flags
&= RXRPC_CLIENT_INITIATED
;
338 kernel_sendmsg(local
->socket
, &msg
, iov
, 2, size
);