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>
18 #include <linux/udp.h>
21 #include <net/af_rxrpc.h>
22 #include "ar-internal.h"
24 struct rxrpc_pkt_buffer
{
25 struct rxrpc_wire_header whdr
;
28 struct rxrpc_ackpacket ack
;
34 struct rxrpc_ackinfo ackinfo
;
38 * Fill out an ACK packet.
40 static size_t rxrpc_fill_out_ack(struct rxrpc_call
*call
,
41 struct rxrpc_pkt_buffer
*pkt
)
43 rxrpc_seq_t hard_ack
, top
, seq
;
48 /* Barrier against rxrpc_input_data(). */
49 hard_ack
= READ_ONCE(call
->rx_hard_ack
);
50 top
= smp_load_acquire(&call
->rx_top
);
52 pkt
->ack
.bufferSpace
= htons(8);
53 pkt
->ack
.maxSkew
= htons(call
->ackr_skew
);
54 pkt
->ack
.firstPacket
= htonl(hard_ack
+ 1);
55 pkt
->ack
.previousPacket
= htonl(call
->ackr_prev_seq
);
56 pkt
->ack
.serial
= htonl(call
->ackr_serial
);
57 pkt
->ack
.reason
= call
->ackr_reason
;
58 pkt
->ack
.nAcks
= top
- hard_ack
;
60 if (after(top
, hard_ack
)) {
63 ix
= seq
& RXRPC_RXTX_BUFF_MASK
;
64 if (call
->rxtx_buffer
[ix
])
65 *ackp
++ = RXRPC_ACK_TYPE_ACK
;
67 *ackp
++ = RXRPC_ACK_TYPE_NACK
;
69 } while (before_eq(seq
, top
));
72 mtu
= call
->conn
->params
.peer
->if_mtu
;
73 mtu
-= call
->conn
->params
.peer
->hdrsize
;
74 jmax
= (call
->nr_jumbo_dup
> 3) ? 1 : rxrpc_rx_jumbo_max
;
75 pkt
->ackinfo
.rxMTU
= htonl(rxrpc_rx_mtu
);
76 pkt
->ackinfo
.maxMTU
= htonl(mtu
);
77 pkt
->ackinfo
.rwind
= htonl(rxrpc_rx_window_size
);
78 pkt
->ackinfo
.jumbo_max
= htonl(jmax
);
83 return top
- hard_ack
+ 3;
87 * Send an ACK or ABORT call packet.
89 int rxrpc_send_call_packet(struct rxrpc_call
*call
, u8 type
)
91 struct rxrpc_connection
*conn
= NULL
;
92 struct rxrpc_pkt_buffer
*pkt
;
95 rxrpc_serial_t serial
;
100 _enter("%u,%s", call
->debug_id
, rxrpc_pkts
[type
]);
102 spin_lock_bh(&call
->lock
);
104 conn
= rxrpc_get_connection_maybe(call
->conn
);
105 spin_unlock_bh(&call
->lock
);
109 pkt
= kzalloc(sizeof(*pkt
), GFP_KERNEL
);
111 rxrpc_put_connection(conn
);
115 serial
= atomic_inc_return(&conn
->serial
);
117 msg
.msg_name
= &call
->peer
->srx
.transport
;
118 msg
.msg_namelen
= call
->peer
->srx
.transport_len
;
119 msg
.msg_control
= NULL
;
120 msg
.msg_controllen
= 0;
123 pkt
->whdr
.epoch
= htonl(conn
->proto
.epoch
);
124 pkt
->whdr
.cid
= htonl(call
->cid
);
125 pkt
->whdr
.callNumber
= htonl(call
->call_id
);
127 pkt
->whdr
.serial
= htonl(serial
);
128 pkt
->whdr
.type
= type
;
129 pkt
->whdr
.flags
= conn
->out_clientflag
;
130 pkt
->whdr
.userStatus
= 0;
131 pkt
->whdr
.securityIndex
= call
->security_ix
;
133 pkt
->whdr
.serviceId
= htons(call
->service_id
);
135 iov
[0].iov_base
= pkt
;
136 iov
[0].iov_len
= sizeof(pkt
->whdr
);
137 len
= sizeof(pkt
->whdr
);
140 case RXRPC_PACKET_TYPE_ACK
:
141 spin_lock_bh(&call
->lock
);
142 n
= rxrpc_fill_out_ack(call
, pkt
);
143 call
->ackr_reason
= 0;
145 spin_unlock_bh(&call
->lock
);
147 _proto("Tx ACK %%%u { m=%hu f=#%u p=#%u s=%%%u r=%s n=%u }",
149 ntohs(pkt
->ack
.maxSkew
),
150 ntohl(pkt
->ack
.firstPacket
),
151 ntohl(pkt
->ack
.previousPacket
),
152 ntohl(pkt
->ack
.serial
),
153 rxrpc_acks(pkt
->ack
.reason
),
156 iov
[0].iov_len
+= sizeof(pkt
->ack
) + n
;
157 iov
[1].iov_base
= &pkt
->ackinfo
;
158 iov
[1].iov_len
= sizeof(pkt
->ackinfo
);
159 len
+= sizeof(pkt
->ack
) + n
+ sizeof(pkt
->ackinfo
);
163 case RXRPC_PACKET_TYPE_ABORT
:
164 abort_code
= call
->abort_code
;
165 pkt
->abort_code
= htonl(abort_code
);
166 _proto("Tx ABORT %%%u { %d }", serial
, abort_code
);
167 iov
[0].iov_len
+= sizeof(pkt
->abort_code
);
168 len
+= sizeof(pkt
->abort_code
);
178 ret
= kernel_sendmsg(conn
->params
.local
->socket
,
179 &msg
, iov
, ioc
, len
);
181 if (ret
< 0 && call
->state
< RXRPC_CALL_COMPLETE
) {
182 switch (pkt
->whdr
.type
) {
183 case RXRPC_PACKET_TYPE_ACK
:
184 rxrpc_propose_ACK(call
, pkt
->ack
.reason
,
185 ntohs(pkt
->ack
.maxSkew
),
186 ntohl(pkt
->ack
.serial
),
189 case RXRPC_PACKET_TYPE_ABORT
:
195 rxrpc_put_connection(conn
);
201 * send a packet through the transport endpoint
203 int rxrpc_send_data_packet(struct rxrpc_connection
*conn
, struct sk_buff
*skb
)
209 _enter(",{%d}", skb
->len
);
211 iov
[0].iov_base
= skb
->head
;
212 iov
[0].iov_len
= skb
->len
;
214 msg
.msg_name
= &conn
->params
.peer
->srx
.transport
;
215 msg
.msg_namelen
= conn
->params
.peer
->srx
.transport_len
;
216 msg
.msg_control
= NULL
;
217 msg
.msg_controllen
= 0;
220 /* send the packet with the don't fragment bit set if we currently
221 * think it's small enough */
222 if (skb
->len
- sizeof(struct rxrpc_wire_header
) < conn
->params
.peer
->maxdata
) {
223 down_read(&conn
->params
.local
->defrag_sem
);
224 /* send the packet by UDP
225 * - returns -EMSGSIZE if UDP would have to fragment the packet
226 * to go out of the interface
227 * - in which case, we'll have processed the ICMP error
228 * message and update the peer record
230 ret
= kernel_sendmsg(conn
->params
.local
->socket
, &msg
, iov
, 1,
233 up_read(&conn
->params
.local
->defrag_sem
);
234 if (ret
== -EMSGSIZE
)
235 goto send_fragmentable
;
237 _leave(" = %d [%u]", ret
, conn
->params
.peer
->maxdata
);
242 /* attempt to send this message with fragmentation enabled */
243 _debug("send fragment");
245 down_write(&conn
->params
.local
->defrag_sem
);
247 switch (conn
->params
.local
->srx
.transport
.family
) {
249 opt
= IP_PMTUDISC_DONT
;
250 ret
= kernel_setsockopt(conn
->params
.local
->socket
,
251 SOL_IP
, IP_MTU_DISCOVER
,
252 (char *)&opt
, sizeof(opt
));
254 ret
= kernel_sendmsg(conn
->params
.local
->socket
, &msg
, iov
, 1,
257 opt
= IP_PMTUDISC_DO
;
258 kernel_setsockopt(conn
->params
.local
->socket
, SOL_IP
,
260 (char *)&opt
, sizeof(opt
));
265 up_write(&conn
->params
.local
->defrag_sem
);
266 _leave(" = %d [frag %u]", ret
, conn
->params
.peer
->maxdata
);
271 * reject packets through the local endpoint
273 void rxrpc_reject_packets(struct rxrpc_local
*local
)
277 struct sockaddr_in sin
;
279 struct rxrpc_skb_priv
*sp
;
280 struct rxrpc_wire_header whdr
;
287 _enter("%d", local
->debug_id
);
289 iov
[0].iov_base
= &whdr
;
290 iov
[0].iov_len
= sizeof(whdr
);
291 iov
[1].iov_base
= &code
;
292 iov
[1].iov_len
= sizeof(code
);
293 size
= sizeof(whdr
) + sizeof(code
);
296 msg
.msg_control
= NULL
;
297 msg
.msg_controllen
= 0;
300 memset(&sa
, 0, sizeof(sa
));
301 sa
.sa
.sa_family
= local
->srx
.transport
.family
;
302 switch (sa
.sa
.sa_family
) {
304 msg
.msg_namelen
= sizeof(sa
.sin
);
311 memset(&whdr
, 0, sizeof(whdr
));
312 whdr
.type
= RXRPC_PACKET_TYPE_ABORT
;
314 while ((skb
= skb_dequeue(&local
->reject_queue
))) {
317 switch (sa
.sa
.sa_family
) {
319 sa
.sin
.sin_port
= udp_hdr(skb
)->source
;
320 sa
.sin
.sin_addr
.s_addr
= ip_hdr(skb
)->saddr
;
321 code
= htonl(skb
->priority
);
323 whdr
.epoch
= htonl(sp
->hdr
.epoch
);
324 whdr
.cid
= htonl(sp
->hdr
.cid
);
325 whdr
.callNumber
= htonl(sp
->hdr
.callNumber
);
326 whdr
.serviceId
= htons(sp
->hdr
.serviceId
);
327 whdr
.flags
= sp
->hdr
.flags
;
328 whdr
.flags
^= RXRPC_CLIENT_INITIATED
;
329 whdr
.flags
&= RXRPC_CLIENT_INITIATED
;
331 kernel_sendmsg(local
->socket
, &msg
, iov
, 2, size
);
This page took 0.136014 seconds and 5 git commands to generate.