1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* Peer event handling, typically ICMP messages. 3 * 4 * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved. 5 * Written by David Howells (dhowells@redhat.com) 6 */ 7 8 #include <linux/module.h> 9 #include <linux/net.h> 10 #include <linux/skbuff.h> 11 #include <linux/errqueue.h> 12 #include <linux/udp.h> 13 #include <linux/in.h> 14 #include <linux/in6.h> 15 #include <linux/icmp.h> 16 #include <net/sock.h> 17 #include <net/af_rxrpc.h> 18 #include <net/ip.h> 19 #include "ar-internal.h" 20 21 static void rxrpc_store_error(struct rxrpc_peer *, struct sk_buff *); 22 static void rxrpc_distribute_error(struct rxrpc_peer *, struct sk_buff *, 23 enum rxrpc_call_completion, int); 24 25 /* 26 * Find the peer associated with a local error. 27 */ 28 static struct rxrpc_peer *rxrpc_lookup_peer_local_rcu(struct rxrpc_local *local, 29 const struct sk_buff *skb, 30 struct sockaddr_rxrpc *srx) 31 { 32 struct sock_exterr_skb *serr = SKB_EXT_ERR(skb); 33 34 _enter(""); 35 36 memset(srx, 0, sizeof(*srx)); 37 srx->transport_type = local->srx.transport_type; 38 srx->transport_len = local->srx.transport_len; 39 srx->transport.family = local->srx.transport.family; 40 41 /* Can we see an ICMP4 packet on an ICMP6 listening socket? and vice 42 * versa? 43 */ 44 switch (srx->transport.family) { 45 case AF_INET: 46 srx->transport_len = sizeof(srx->transport.sin); 47 srx->transport.family = AF_INET; 48 srx->transport.sin.sin_port = serr->port; 49 switch (serr->ee.ee_origin) { 50 case SO_EE_ORIGIN_ICMP: 51 memcpy(&srx->transport.sin.sin_addr, 52 skb_network_header(skb) + serr->addr_offset, 53 sizeof(struct in_addr)); 54 break; 55 case SO_EE_ORIGIN_ICMP6: 56 memcpy(&srx->transport.sin.sin_addr, 57 skb_network_header(skb) + serr->addr_offset + 12, 58 sizeof(struct in_addr)); 59 break; 60 default: 61 memcpy(&srx->transport.sin.sin_addr, &ip_hdr(skb)->saddr, 62 sizeof(struct in_addr)); 63 break; 64 } 65 break; 66 67 #ifdef CONFIG_AF_RXRPC_IPV6 68 case AF_INET6: 69 switch (serr->ee.ee_origin) { 70 case SO_EE_ORIGIN_ICMP6: 71 srx->transport.sin6.sin6_port = serr->port; 72 memcpy(&srx->transport.sin6.sin6_addr, 73 skb_network_header(skb) + serr->addr_offset, 74 sizeof(struct in6_addr)); 75 break; 76 case SO_EE_ORIGIN_ICMP: 77 srx->transport_len = sizeof(srx->transport.sin); 78 srx->transport.family = AF_INET; 79 srx->transport.sin.sin_port = serr->port; 80 memcpy(&srx->transport.sin.sin_addr, 81 skb_network_header(skb) + serr->addr_offset, 82 sizeof(struct in_addr)); 83 break; 84 default: 85 memcpy(&srx->transport.sin6.sin6_addr, 86 &ipv6_hdr(skb)->saddr, 87 sizeof(struct in6_addr)); 88 break; 89 } 90 break; 91 #endif 92 93 default: 94 BUG(); 95 } 96 97 return rxrpc_lookup_peer_rcu(local, srx); 98 } 99 100 /* 101 * Handle an MTU/fragmentation problem. 102 */ 103 static void rxrpc_adjust_mtu(struct rxrpc_peer *peer, unsigned int mtu) 104 { 105 unsigned int max_data; 106 107 /* wind down the local interface MTU */ 108 if (mtu > 0 && peer->if_mtu == 65535 && mtu < peer->if_mtu) 109 peer->if_mtu = mtu; 110 111 if (mtu == 0) { 112 /* they didn't give us a size, estimate one */ 113 mtu = peer->if_mtu; 114 if (mtu > 1500) { 115 mtu >>= 1; 116 if (mtu < 1500) 117 mtu = 1500; 118 } else { 119 mtu -= 100; 120 if (mtu < peer->hdrsize) 121 mtu = peer->hdrsize + 4; 122 } 123 } 124 125 max_data = max_t(int, mtu - peer->hdrsize, 500); 126 if (max_data < peer->max_data) { 127 if (peer->pmtud_good > max_data) 128 peer->pmtud_good = max_data; 129 if (peer->pmtud_bad > max_data + 1) 130 peer->pmtud_bad = max_data + 1; 131 132 trace_rxrpc_pmtud_reduce(peer, 0, max_data, rxrpc_pmtud_reduce_icmp); 133 write_seqcount_begin(&peer->mtu_lock); 134 peer->max_data = max_data; 135 write_seqcount_end(&peer->mtu_lock); 136 } 137 } 138 139 /* 140 * Handle an error received on the local endpoint. 141 */ 142 void rxrpc_input_error(struct rxrpc_local *local, struct sk_buff *skb) 143 { 144 struct sock_exterr_skb *serr = SKB_EXT_ERR(skb); 145 struct sockaddr_rxrpc srx; 146 struct rxrpc_peer *peer = NULL; 147 148 _enter("L=%x", local->debug_id); 149 150 if (!skb->len && serr->ee.ee_origin == SO_EE_ORIGIN_TIMESTAMPING) { 151 _leave("UDP empty message"); 152 return; 153 } 154 155 rcu_read_lock(); 156 peer = rxrpc_lookup_peer_local_rcu(local, skb, &srx); 157 if (peer && !rxrpc_get_peer_maybe(peer, rxrpc_peer_get_input_error)) 158 peer = NULL; 159 rcu_read_unlock(); 160 if (!peer) 161 return; 162 163 trace_rxrpc_rx_icmp(peer, &serr->ee, &srx); 164 165 if ((serr->ee.ee_origin == SO_EE_ORIGIN_ICMP && 166 serr->ee.ee_type == ICMP_DEST_UNREACH && 167 serr->ee.ee_code == ICMP_FRAG_NEEDED)) { 168 rxrpc_adjust_mtu(peer, serr->ee.ee_info); 169 goto out; 170 } 171 172 rxrpc_store_error(peer, skb); 173 out: 174 rxrpc_put_peer(peer, rxrpc_peer_put_input_error); 175 } 176 177 /* 178 * Map an error report to error codes on the peer record. 179 */ 180 static void rxrpc_store_error(struct rxrpc_peer *peer, struct sk_buff *skb) 181 { 182 enum rxrpc_call_completion compl = RXRPC_CALL_NETWORK_ERROR; 183 struct sock_exterr_skb *serr = SKB_EXT_ERR(skb); 184 struct sock_extended_err *ee = &serr->ee; 185 int err = ee->ee_errno; 186 187 _enter(""); 188 189 switch (ee->ee_origin) { 190 case SO_EE_ORIGIN_NONE: 191 case SO_EE_ORIGIN_LOCAL: 192 compl = RXRPC_CALL_LOCAL_ERROR; 193 break; 194 195 case SO_EE_ORIGIN_ICMP6: 196 if (err == EACCES) 197 err = EHOSTUNREACH; 198 fallthrough; 199 case SO_EE_ORIGIN_ICMP: 200 default: 201 break; 202 } 203 204 rxrpc_distribute_error(peer, skb, compl, err); 205 } 206 207 /* 208 * Distribute an error that occurred on a peer. 209 */ 210 static void rxrpc_distribute_error(struct rxrpc_peer *peer, struct sk_buff *skb, 211 enum rxrpc_call_completion compl, int err) 212 { 213 struct rxrpc_call *call; 214 HLIST_HEAD(error_targets); 215 216 spin_lock_irq(&peer->lock); 217 hlist_move_list(&peer->error_targets, &error_targets); 218 219 while (!hlist_empty(&error_targets)) { 220 call = hlist_entry(error_targets.first, 221 struct rxrpc_call, error_link); 222 hlist_del_init(&call->error_link); 223 spin_unlock_irq(&peer->lock); 224 225 rxrpc_see_call(call, rxrpc_call_see_distribute_error); 226 rxrpc_set_call_completion(call, compl, 0, -err); 227 rxrpc_input_call_event(call); 228 229 spin_lock_irq(&peer->lock); 230 } 231 232 spin_unlock_irq(&peer->lock); 233 } 234 235 /* 236 * Perform keep-alive pings. 237 */ 238 static void rxrpc_peer_keepalive_dispatch(struct rxrpc_net *rxnet, 239 struct list_head *collector, 240 time64_t base, 241 u8 cursor) 242 { 243 struct rxrpc_peer *peer; 244 const u8 mask = ARRAY_SIZE(rxnet->peer_keepalive) - 1; 245 time64_t keepalive_at; 246 bool use; 247 int slot; 248 249 spin_lock(&rxnet->peer_hash_lock); 250 251 while (!list_empty(collector)) { 252 peer = list_entry(collector->next, 253 struct rxrpc_peer, keepalive_link); 254 255 list_del_init(&peer->keepalive_link); 256 if (!rxrpc_get_peer_maybe(peer, rxrpc_peer_get_keepalive)) 257 continue; 258 259 use = __rxrpc_use_local(peer->local, rxrpc_local_use_peer_keepalive); 260 spin_unlock(&rxnet->peer_hash_lock); 261 262 if (use) { 263 keepalive_at = peer->last_tx_at + RXRPC_KEEPALIVE_TIME; 264 slot = keepalive_at - base; 265 _debug("%02x peer %u t=%d {%pISp}", 266 cursor, peer->debug_id, slot, &peer->srx.transport); 267 268 if (keepalive_at <= base || 269 keepalive_at > base + RXRPC_KEEPALIVE_TIME) { 270 rxrpc_send_keepalive(peer); 271 slot = RXRPC_KEEPALIVE_TIME; 272 } 273 274 /* A transmission to this peer occurred since last we 275 * examined it so put it into the appropriate future 276 * bucket. 277 */ 278 slot += cursor; 279 slot &= mask; 280 spin_lock(&rxnet->peer_hash_lock); 281 list_add_tail(&peer->keepalive_link, 282 &rxnet->peer_keepalive[slot & mask]); 283 spin_unlock(&rxnet->peer_hash_lock); 284 rxrpc_unuse_local(peer->local, rxrpc_local_unuse_peer_keepalive); 285 } 286 rxrpc_put_peer(peer, rxrpc_peer_put_keepalive); 287 spin_lock(&rxnet->peer_hash_lock); 288 } 289 290 spin_unlock(&rxnet->peer_hash_lock); 291 } 292 293 /* 294 * Perform keep-alive pings with VERSION packets to keep any NAT alive. 295 */ 296 void rxrpc_peer_keepalive_worker(struct work_struct *work) 297 { 298 struct rxrpc_net *rxnet = 299 container_of(work, struct rxrpc_net, peer_keepalive_work); 300 const u8 mask = ARRAY_SIZE(rxnet->peer_keepalive) - 1; 301 time64_t base, now, delay; 302 u8 cursor, stop; 303 LIST_HEAD(collector); 304 305 now = ktime_get_seconds(); 306 base = rxnet->peer_keepalive_base; 307 cursor = rxnet->peer_keepalive_cursor; 308 _enter("%lld,%u", base - now, cursor); 309 310 if (!rxnet->live) 311 return; 312 313 /* Remove to a temporary list all the peers that are currently lodged 314 * in expired buckets plus all new peers. 315 * 316 * Everything in the bucket at the cursor is processed this 317 * second; the bucket at cursor + 1 goes at now + 1s and so 318 * on... 319 */ 320 spin_lock(&rxnet->peer_hash_lock); 321 list_splice_init(&rxnet->peer_keepalive_new, &collector); 322 323 stop = cursor + ARRAY_SIZE(rxnet->peer_keepalive); 324 while (base <= now && (s8)(cursor - stop) < 0) { 325 list_splice_tail_init(&rxnet->peer_keepalive[cursor & mask], 326 &collector); 327 base++; 328 cursor++; 329 } 330 331 base = now; 332 spin_unlock(&rxnet->peer_hash_lock); 333 334 rxnet->peer_keepalive_base = base; 335 rxnet->peer_keepalive_cursor = cursor; 336 rxrpc_peer_keepalive_dispatch(rxnet, &collector, base, cursor); 337 ASSERT(list_empty(&collector)); 338 339 /* Schedule the timer for the next occupied timeslot. */ 340 cursor = rxnet->peer_keepalive_cursor; 341 stop = cursor + RXRPC_KEEPALIVE_TIME - 1; 342 for (; (s8)(cursor - stop) < 0; cursor++) { 343 if (!list_empty(&rxnet->peer_keepalive[cursor & mask])) 344 break; 345 base++; 346 } 347 348 now = ktime_get_seconds(); 349 delay = base - now; 350 if (delay < 1) 351 delay = 1; 352 delay *= HZ; 353 if (rxnet->live) 354 timer_reduce(&rxnet->peer_keepalive_timer, jiffies + delay); 355 356 _leave(""); 357 } 358 359 /* 360 * Do path MTU probing. 361 */ 362 void rxrpc_input_probe_for_pmtud(struct rxrpc_connection *conn, rxrpc_serial_t acked_serial, 363 bool sendmsg_fail) 364 { 365 struct rxrpc_peer *peer = conn->peer; 366 unsigned int max_data = peer->max_data; 367 int good, trial, bad, jumbo; 368 369 good = peer->pmtud_good; 370 trial = peer->pmtud_trial; 371 bad = peer->pmtud_bad; 372 if (good >= bad - 1) { 373 conn->pmtud_probe = 0; 374 peer->pmtud_lost = false; 375 return; 376 } 377 378 if (!peer->pmtud_probing) 379 goto send_probe; 380 381 if (sendmsg_fail || after(acked_serial, conn->pmtud_probe)) { 382 /* Retry a lost probe. */ 383 if (!peer->pmtud_lost) { 384 trace_rxrpc_pmtud_lost(conn, acked_serial); 385 conn->pmtud_probe = 0; 386 peer->pmtud_lost = true; 387 goto send_probe; 388 } 389 390 /* The probed size didn't seem to get through. */ 391 bad = trial; 392 peer->pmtud_bad = bad; 393 if (bad <= max_data) 394 max_data = bad - 1; 395 } else { 396 /* It did get through. */ 397 good = trial; 398 peer->pmtud_good = good; 399 if (good > max_data) 400 max_data = good; 401 } 402 403 max_data = umin(max_data, peer->ackr_max_data); 404 if (max_data != peer->max_data) { 405 preempt_disable(); 406 write_seqcount_begin(&peer->mtu_lock); 407 peer->max_data = max_data; 408 write_seqcount_end(&peer->mtu_lock); 409 preempt_enable(); 410 } 411 412 jumbo = max_data + sizeof(struct rxrpc_jumbo_header); 413 jumbo /= RXRPC_JUMBO_SUBPKTLEN; 414 peer->pmtud_jumbo = jumbo; 415 416 trace_rxrpc_pmtud_rx(conn, acked_serial); 417 conn->pmtud_probe = 0; 418 peer->pmtud_lost = false; 419 420 if (good < RXRPC_JUMBO(2) && bad > RXRPC_JUMBO(2)) 421 trial = RXRPC_JUMBO(2); 422 else if (good < RXRPC_JUMBO(4) && bad > RXRPC_JUMBO(4)) 423 trial = RXRPC_JUMBO(4); 424 else if (good < RXRPC_JUMBO(3) && bad > RXRPC_JUMBO(3)) 425 trial = RXRPC_JUMBO(3); 426 else if (good < RXRPC_JUMBO(6) && bad > RXRPC_JUMBO(6)) 427 trial = RXRPC_JUMBO(6); 428 else if (good < RXRPC_JUMBO(5) && bad > RXRPC_JUMBO(5)) 429 trial = RXRPC_JUMBO(5); 430 else if (good < RXRPC_JUMBO(8) && bad > RXRPC_JUMBO(8)) 431 trial = RXRPC_JUMBO(8); 432 else if (good < RXRPC_JUMBO(7) && bad > RXRPC_JUMBO(7)) 433 trial = RXRPC_JUMBO(7); 434 else 435 trial = (good + bad) / 2; 436 peer->pmtud_trial = trial; 437 438 if (good >= bad) 439 return; 440 441 send_probe: 442 peer->pmtud_pending = true; 443 } 444