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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 13 14 #include <linux/net.h> 15 #include <linux/gfp.h> 16 #include <linux/skbuff.h> 17 #include <linux/export.h> 18 #include <net/sock.h> 19 #include <net/af_rxrpc.h> 20 #include "ar-internal.h" 21 22 struct rxrpc_ack_buffer { 23 struct rxrpc_wire_header whdr; 24 struct rxrpc_ackpacket ack; 25 u8 acks[255]; 26 u8 pad[3]; 27 struct rxrpc_ackinfo ackinfo; 28 }; 29 30 struct rxrpc_abort_buffer { 31 struct rxrpc_wire_header whdr; 32 __be32 abort_code; 33 }; 34 35 /* 36 * Fill out an ACK packet. 37 */ 38 static size_t rxrpc_fill_out_ack(struct rxrpc_call *call, 39 struct rxrpc_ack_buffer *pkt, 40 rxrpc_seq_t *_hard_ack, 41 rxrpc_seq_t *_top, 42 u8 reason) 43 { 44 rxrpc_serial_t serial; 45 rxrpc_seq_t hard_ack, top, seq; 46 int ix; 47 u32 mtu, jmax; 48 u8 *ackp = pkt->acks; 49 50 /* Barrier against rxrpc_input_data(). */ 51 serial = call->ackr_serial; 52 hard_ack = READ_ONCE(call->rx_hard_ack); 53 top = smp_load_acquire(&call->rx_top); 54 *_hard_ack = hard_ack; 55 *_top = top; 56 57 pkt->ack.bufferSpace = htons(8); 58 pkt->ack.maxSkew = htons(call->ackr_skew); 59 pkt->ack.firstPacket = htonl(hard_ack + 1); 60 pkt->ack.previousPacket = htonl(call->ackr_prev_seq); 61 pkt->ack.serial = htonl(serial); 62 pkt->ack.reason = reason; 63 pkt->ack.nAcks = top - hard_ack; 64 65 if (reason == RXRPC_ACK_PING) 66 pkt->whdr.flags |= RXRPC_REQUEST_ACK; 67 68 if (after(top, hard_ack)) { 69 seq = hard_ack + 1; 70 do { 71 ix = seq & RXRPC_RXTX_BUFF_MASK; 72 if (call->rxtx_buffer[ix]) 73 *ackp++ = RXRPC_ACK_TYPE_ACK; 74 else 75 *ackp++ = RXRPC_ACK_TYPE_NACK; 76 seq++; 77 } while (before_eq(seq, top)); 78 } 79 80 mtu = call->conn->params.peer->if_mtu; 81 mtu -= call->conn->params.peer->hdrsize; 82 jmax = (call->nr_jumbo_bad > 3) ? 1 : rxrpc_rx_jumbo_max; 83 pkt->ackinfo.rxMTU = htonl(rxrpc_rx_mtu); 84 pkt->ackinfo.maxMTU = htonl(mtu); 85 pkt->ackinfo.rwind = htonl(call->rx_winsize); 86 pkt->ackinfo.jumbo_max = htonl(jmax); 87 88 *ackp++ = 0; 89 *ackp++ = 0; 90 *ackp++ = 0; 91 return top - hard_ack + 3; 92 } 93 94 /* 95 * Send an ACK call packet. 96 */ 97 int rxrpc_send_ack_packet(struct rxrpc_call *call, bool ping) 98 { 99 struct rxrpc_connection *conn = NULL; 100 struct rxrpc_ack_buffer *pkt; 101 struct msghdr msg; 102 struct kvec iov[2]; 103 rxrpc_serial_t serial; 104 rxrpc_seq_t hard_ack, top; 105 size_t len, n; 106 int ret; 107 u8 reason; 108 109 spin_lock_bh(&call->lock); 110 if (call->conn) 111 conn = rxrpc_get_connection_maybe(call->conn); 112 spin_unlock_bh(&call->lock); 113 if (!conn) 114 return -ECONNRESET; 115 116 pkt = kzalloc(sizeof(*pkt), GFP_KERNEL); 117 if (!pkt) { 118 rxrpc_put_connection(conn); 119 return -ENOMEM; 120 } 121 122 msg.msg_name = &call->peer->srx.transport; 123 msg.msg_namelen = call->peer->srx.transport_len; 124 msg.msg_control = NULL; 125 msg.msg_controllen = 0; 126 msg.msg_flags = 0; 127 128 pkt->whdr.epoch = htonl(conn->proto.epoch); 129 pkt->whdr.cid = htonl(call->cid); 130 pkt->whdr.callNumber = htonl(call->call_id); 131 pkt->whdr.seq = 0; 132 pkt->whdr.type = RXRPC_PACKET_TYPE_ACK; 133 pkt->whdr.flags = RXRPC_SLOW_START_OK | conn->out_clientflag; 134 pkt->whdr.userStatus = 0; 135 pkt->whdr.securityIndex = call->security_ix; 136 pkt->whdr._rsvd = 0; 137 pkt->whdr.serviceId = htons(call->service_id); 138 139 spin_lock_bh(&call->lock); 140 if (ping) { 141 reason = RXRPC_ACK_PING; 142 } else { 143 reason = call->ackr_reason; 144 if (!call->ackr_reason) { 145 spin_unlock_bh(&call->lock); 146 ret = 0; 147 goto out; 148 } 149 call->ackr_reason = 0; 150 } 151 n = rxrpc_fill_out_ack(call, pkt, &hard_ack, &top, reason); 152 153 spin_unlock_bh(&call->lock); 154 155 iov[0].iov_base = pkt; 156 iov[0].iov_len = sizeof(pkt->whdr) + sizeof(pkt->ack) + n; 157 iov[1].iov_base = &pkt->ackinfo; 158 iov[1].iov_len = sizeof(pkt->ackinfo); 159 len = iov[0].iov_len + iov[1].iov_len; 160 161 serial = atomic_inc_return(&conn->serial); 162 pkt->whdr.serial = htonl(serial); 163 trace_rxrpc_tx_ack(call, serial, 164 ntohl(pkt->ack.firstPacket), 165 ntohl(pkt->ack.serial), 166 pkt->ack.reason, pkt->ack.nAcks); 167 168 if (ping) { 169 call->ping_serial = serial; 170 smp_wmb(); 171 /* We need to stick a time in before we send the packet in case 172 * the reply gets back before kernel_sendmsg() completes - but 173 * asking UDP to send the packet can take a relatively long 174 * time, so we update the time after, on the assumption that 175 * the packet transmission is more likely to happen towards the 176 * end of the kernel_sendmsg() call. 177 */ 178 call->ping_time = ktime_get_real(); 179 set_bit(RXRPC_CALL_PINGING, &call->flags); 180 trace_rxrpc_rtt_tx(call, rxrpc_rtt_tx_ping, serial); 181 } 182 183 ret = kernel_sendmsg(conn->params.local->socket, &msg, iov, 2, len); 184 if (ping) 185 call->ping_time = ktime_get_real(); 186 187 if (call->state < RXRPC_CALL_COMPLETE) { 188 if (ret < 0) { 189 if (ping) 190 clear_bit(RXRPC_CALL_PINGING, &call->flags); 191 rxrpc_propose_ACK(call, pkt->ack.reason, 192 ntohs(pkt->ack.maxSkew), 193 ntohl(pkt->ack.serial), 194 true, true, 195 rxrpc_propose_ack_retry_tx); 196 } else { 197 spin_lock_bh(&call->lock); 198 if (after(hard_ack, call->ackr_consumed)) 199 call->ackr_consumed = hard_ack; 200 if (after(top, call->ackr_seen)) 201 call->ackr_seen = top; 202 spin_unlock_bh(&call->lock); 203 } 204 } 205 206 out: 207 rxrpc_put_connection(conn); 208 kfree(pkt); 209 return ret; 210 } 211 212 /* 213 * Send an ABORT call packet. 214 */ 215 int rxrpc_send_abort_packet(struct rxrpc_call *call) 216 { 217 struct rxrpc_connection *conn = NULL; 218 struct rxrpc_abort_buffer pkt; 219 struct msghdr msg; 220 struct kvec iov[1]; 221 rxrpc_serial_t serial; 222 int ret; 223 224 spin_lock_bh(&call->lock); 225 if (call->conn) 226 conn = rxrpc_get_connection_maybe(call->conn); 227 spin_unlock_bh(&call->lock); 228 if (!conn) 229 return -ECONNRESET; 230 231 msg.msg_name = &call->peer->srx.transport; 232 msg.msg_namelen = call->peer->srx.transport_len; 233 msg.msg_control = NULL; 234 msg.msg_controllen = 0; 235 msg.msg_flags = 0; 236 237 pkt.whdr.epoch = htonl(conn->proto.epoch); 238 pkt.whdr.cid = htonl(call->cid); 239 pkt.whdr.callNumber = htonl(call->call_id); 240 pkt.whdr.seq = 0; 241 pkt.whdr.type = RXRPC_PACKET_TYPE_ABORT; 242 pkt.whdr.flags = conn->out_clientflag; 243 pkt.whdr.userStatus = 0; 244 pkt.whdr.securityIndex = call->security_ix; 245 pkt.whdr._rsvd = 0; 246 pkt.whdr.serviceId = htons(call->service_id); 247 pkt.abort_code = htonl(call->abort_code); 248 249 iov[0].iov_base = &pkt; 250 iov[0].iov_len = sizeof(pkt); 251 252 serial = atomic_inc_return(&conn->serial); 253 pkt.whdr.serial = htonl(serial); 254 255 ret = kernel_sendmsg(conn->params.local->socket, 256 &msg, iov, 1, sizeof(pkt)); 257 258 rxrpc_put_connection(conn); 259 return ret; 260 } 261 262 /* 263 * send a packet through the transport endpoint 264 */ 265 int rxrpc_send_data_packet(struct rxrpc_call *call, struct sk_buff *skb, 266 bool retrans) 267 { 268 struct rxrpc_connection *conn = call->conn; 269 struct rxrpc_wire_header whdr; 270 struct rxrpc_skb_priv *sp = rxrpc_skb(skb); 271 struct msghdr msg; 272 struct kvec iov[2]; 273 rxrpc_serial_t serial; 274 size_t len; 275 bool lost = false; 276 int ret, opt; 277 278 _enter(",{%d}", skb->len); 279 280 /* Each transmission of a Tx packet needs a new serial number */ 281 serial = atomic_inc_return(&conn->serial); 282 283 whdr.epoch = htonl(conn->proto.epoch); 284 whdr.cid = htonl(call->cid); 285 whdr.callNumber = htonl(call->call_id); 286 whdr.seq = htonl(sp->hdr.seq); 287 whdr.serial = htonl(serial); 288 whdr.type = RXRPC_PACKET_TYPE_DATA; 289 whdr.flags = sp->hdr.flags; 290 whdr.userStatus = 0; 291 whdr.securityIndex = call->security_ix; 292 whdr._rsvd = htons(sp->hdr._rsvd); 293 whdr.serviceId = htons(call->service_id); 294 295 iov[0].iov_base = &whdr; 296 iov[0].iov_len = sizeof(whdr); 297 iov[1].iov_base = skb->head; 298 iov[1].iov_len = skb->len; 299 len = iov[0].iov_len + iov[1].iov_len; 300 301 msg.msg_name = &call->peer->srx.transport; 302 msg.msg_namelen = call->peer->srx.transport_len; 303 msg.msg_control = NULL; 304 msg.msg_controllen = 0; 305 msg.msg_flags = 0; 306 307 /* If our RTT cache needs working on, request an ACK. Also request 308 * ACKs if a DATA packet appears to have been lost. 309 */ 310 if (!(sp->hdr.flags & RXRPC_LAST_PACKET) && 311 (retrans || 312 call->cong_mode == RXRPC_CALL_SLOW_START || 313 (call->peer->rtt_usage < 3 && sp->hdr.seq & 1) || 314 ktime_before(ktime_add_ms(call->peer->rtt_last_req, 1000), 315 ktime_get_real()))) 316 whdr.flags |= RXRPC_REQUEST_ACK; 317 318 if (IS_ENABLED(CONFIG_AF_RXRPC_INJECT_LOSS)) { 319 static int lose; 320 if ((lose++ & 7) == 7) { 321 ret = 0; 322 lost = true; 323 goto done; 324 } 325 } 326 327 _proto("Tx DATA %%%u { #%u }", serial, sp->hdr.seq); 328 329 /* send the packet with the don't fragment bit set if we currently 330 * think it's small enough */ 331 if (iov[1].iov_len >= call->peer->maxdata) 332 goto send_fragmentable; 333 334 down_read(&conn->params.local->defrag_sem); 335 /* send the packet by UDP 336 * - returns -EMSGSIZE if UDP would have to fragment the packet 337 * to go out of the interface 338 * - in which case, we'll have processed the ICMP error 339 * message and update the peer record 340 */ 341 ret = kernel_sendmsg(conn->params.local->socket, &msg, iov, 2, len); 342 343 up_read(&conn->params.local->defrag_sem); 344 if (ret == -EMSGSIZE) 345 goto send_fragmentable; 346 347 done: 348 trace_rxrpc_tx_data(call, sp->hdr.seq, serial, whdr.flags, 349 retrans, lost); 350 if (ret >= 0) { 351 ktime_t now = ktime_get_real(); 352 skb->tstamp = now; 353 smp_wmb(); 354 sp->hdr.serial = serial; 355 if (whdr.flags & RXRPC_REQUEST_ACK) { 356 call->peer->rtt_last_req = now; 357 trace_rxrpc_rtt_tx(call, rxrpc_rtt_tx_data, serial); 358 } 359 } 360 _leave(" = %d [%u]", ret, call->peer->maxdata); 361 return ret; 362 363 send_fragmentable: 364 /* attempt to send this message with fragmentation enabled */ 365 _debug("send fragment"); 366 367 down_write(&conn->params.local->defrag_sem); 368 369 switch (conn->params.local->srx.transport.family) { 370 case AF_INET: 371 opt = IP_PMTUDISC_DONT; 372 ret = kernel_setsockopt(conn->params.local->socket, 373 SOL_IP, IP_MTU_DISCOVER, 374 (char *)&opt, sizeof(opt)); 375 if (ret == 0) { 376 ret = kernel_sendmsg(conn->params.local->socket, &msg, 377 iov, 2, len); 378 379 opt = IP_PMTUDISC_DO; 380 kernel_setsockopt(conn->params.local->socket, SOL_IP, 381 IP_MTU_DISCOVER, 382 (char *)&opt, sizeof(opt)); 383 } 384 break; 385 386 #ifdef CONFIG_AF_RXRPC_IPV6 387 case AF_INET6: 388 opt = IPV6_PMTUDISC_DONT; 389 ret = kernel_setsockopt(conn->params.local->socket, 390 SOL_IPV6, IPV6_MTU_DISCOVER, 391 (char *)&opt, sizeof(opt)); 392 if (ret == 0) { 393 ret = kernel_sendmsg(conn->params.local->socket, &msg, 394 iov, 1, iov[0].iov_len); 395 396 opt = IPV6_PMTUDISC_DO; 397 kernel_setsockopt(conn->params.local->socket, 398 SOL_IPV6, IPV6_MTU_DISCOVER, 399 (char *)&opt, sizeof(opt)); 400 } 401 break; 402 #endif 403 } 404 405 up_write(&conn->params.local->defrag_sem); 406 goto done; 407 } 408 409 /* 410 * reject packets through the local endpoint 411 */ 412 void rxrpc_reject_packets(struct rxrpc_local *local) 413 { 414 struct sockaddr_rxrpc srx; 415 struct rxrpc_skb_priv *sp; 416 struct rxrpc_wire_header whdr; 417 struct sk_buff *skb; 418 struct msghdr msg; 419 struct kvec iov[2]; 420 size_t size; 421 __be32 code; 422 423 _enter("%d", local->debug_id); 424 425 iov[0].iov_base = &whdr; 426 iov[0].iov_len = sizeof(whdr); 427 iov[1].iov_base = &code; 428 iov[1].iov_len = sizeof(code); 429 size = sizeof(whdr) + sizeof(code); 430 431 msg.msg_name = &srx.transport; 432 msg.msg_control = NULL; 433 msg.msg_controllen = 0; 434 msg.msg_flags = 0; 435 436 memset(&whdr, 0, sizeof(whdr)); 437 whdr.type = RXRPC_PACKET_TYPE_ABORT; 438 439 while ((skb = skb_dequeue(&local->reject_queue))) { 440 rxrpc_see_skb(skb, rxrpc_skb_rx_seen); 441 sp = rxrpc_skb(skb); 442 443 if (rxrpc_extract_addr_from_skb(&srx, skb) == 0) { 444 msg.msg_namelen = srx.transport_len; 445 446 code = htonl(skb->priority); 447 448 whdr.epoch = htonl(sp->hdr.epoch); 449 whdr.cid = htonl(sp->hdr.cid); 450 whdr.callNumber = htonl(sp->hdr.callNumber); 451 whdr.serviceId = htons(sp->hdr.serviceId); 452 whdr.flags = sp->hdr.flags; 453 whdr.flags ^= RXRPC_CLIENT_INITIATED; 454 whdr.flags &= RXRPC_CLIENT_INITIATED; 455 456 kernel_sendmsg(local->socket, &msg, iov, 2, size); 457 } 458 459 rxrpc_free_skb(skb, rxrpc_skb_rx_freed); 460 } 461 462 _leave(""); 463 } 464