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