1 /* Peer event handling, typically ICMP messages.
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 #include <linux/module.h>
13 #include <linux/net.h>
14 #include <linux/skbuff.h>
15 #include <linux/errqueue.h>
16 #include <linux/udp.h>
17 #include <linux/in.h>
18 #include <linux/in6.h>
19 #include <linux/icmp.h>
20 #include <net/sock.h>
21 #include <net/af_rxrpc.h>
22 #include <net/ip.h>
23 #include "ar-internal.h"
24
25 static void rxrpc_store_error(struct rxrpc_peer *, struct sock_exterr_skb *);
26
27 /*
28 * Find the peer associated with an ICMP packet.
29 */
rxrpc_lookup_peer_icmp_rcu(struct rxrpc_local * local,const struct sk_buff * skb)30 static struct rxrpc_peer *rxrpc_lookup_peer_icmp_rcu(struct rxrpc_local *local,
31 const struct sk_buff *skb)
32 {
33 struct sock_exterr_skb *serr = SKB_EXT_ERR(skb);
34 struct sockaddr_rxrpc srx;
35
36 _enter("");
37
38 memset(&srx, 0, sizeof(srx));
39 srx.transport_type = local->srx.transport_type;
40 srx.transport_len = local->srx.transport_len;
41 srx.transport.family = local->srx.transport.family;
42
43 /* Can we see an ICMP4 packet on an ICMP6 listening socket? and vice
44 * versa?
45 */
46 switch (srx.transport.family) {
47 case AF_INET:
48 srx.transport.sin.sin_port = serr->port;
49 switch (serr->ee.ee_origin) {
50 case SO_EE_ORIGIN_ICMP:
51 _net("Rx ICMP");
52 memcpy(&srx.transport.sin.sin_addr,
53 skb_network_header(skb) + serr->addr_offset,
54 sizeof(struct in_addr));
55 break;
56 case SO_EE_ORIGIN_ICMP6:
57 _net("Rx ICMP6 on v4 sock");
58 memcpy(&srx.transport.sin.sin_addr,
59 skb_network_header(skb) + serr->addr_offset + 12,
60 sizeof(struct in_addr));
61 break;
62 default:
63 memcpy(&srx.transport.sin.sin_addr, &ip_hdr(skb)->saddr,
64 sizeof(struct in_addr));
65 break;
66 }
67 break;
68
69 #ifdef CONFIG_AF_RXRPC_IPV6
70 case AF_INET6:
71 srx.transport.sin6.sin6_port = serr->port;
72 switch (serr->ee.ee_origin) {
73 case SO_EE_ORIGIN_ICMP6:
74 _net("Rx ICMP6");
75 memcpy(&srx.transport.sin6.sin6_addr,
76 skb_network_header(skb) + serr->addr_offset,
77 sizeof(struct in6_addr));
78 break;
79 case SO_EE_ORIGIN_ICMP:
80 _net("Rx ICMP on v6 sock");
81 srx.transport.sin6.sin6_addr.s6_addr32[0] = 0;
82 srx.transport.sin6.sin6_addr.s6_addr32[1] = 0;
83 srx.transport.sin6.sin6_addr.s6_addr32[2] = htonl(0xffff);
84 memcpy(srx.transport.sin6.sin6_addr.s6_addr + 12,
85 skb_network_header(skb) + serr->addr_offset,
86 sizeof(struct in_addr));
87 break;
88 default:
89 memcpy(&srx.transport.sin6.sin6_addr,
90 &ipv6_hdr(skb)->saddr,
91 sizeof(struct in6_addr));
92 break;
93 }
94 break;
95 #endif
96
97 default:
98 BUG();
99 }
100
101 return rxrpc_lookup_peer_rcu(local, &srx);
102 }
103
104 /*
105 * Handle an MTU/fragmentation problem.
106 */
rxrpc_adjust_mtu(struct rxrpc_peer * peer,struct sock_exterr_skb * serr)107 static void rxrpc_adjust_mtu(struct rxrpc_peer *peer, struct sock_exterr_skb *serr)
108 {
109 u32 mtu = serr->ee.ee_info;
110
111 _net("Rx ICMP Fragmentation Needed (%d)", mtu);
112
113 /* wind down the local interface MTU */
114 if (mtu > 0 && peer->if_mtu == 65535 && mtu < peer->if_mtu) {
115 peer->if_mtu = mtu;
116 _net("I/F MTU %u", mtu);
117 }
118
119 if (mtu == 0) {
120 /* they didn't give us a size, estimate one */
121 mtu = peer->if_mtu;
122 if (mtu > 1500) {
123 mtu >>= 1;
124 if (mtu < 1500)
125 mtu = 1500;
126 } else {
127 mtu -= 100;
128 if (mtu < peer->hdrsize)
129 mtu = peer->hdrsize + 4;
130 }
131 }
132
133 if (mtu < peer->mtu) {
134 spin_lock_bh(&peer->lock);
135 peer->mtu = mtu;
136 peer->maxdata = peer->mtu - peer->hdrsize;
137 spin_unlock_bh(&peer->lock);
138 _net("Net MTU %u (maxdata %u)",
139 peer->mtu, peer->maxdata);
140 }
141 }
142
143 /*
144 * Handle an error received on the local endpoint.
145 */
rxrpc_error_report(struct sock * sk)146 void rxrpc_error_report(struct sock *sk)
147 {
148 struct sock_exterr_skb *serr;
149 struct rxrpc_local *local = sk->sk_user_data;
150 struct rxrpc_peer *peer;
151 struct sk_buff *skb;
152
153 if (unlikely(!local))
154 return;
155
156 _enter("%p{%d}", sk, local->debug_id);
157
158 skb = sock_dequeue_err_skb(sk);
159 if (!skb) {
160 _leave("UDP socket errqueue empty");
161 return;
162 }
163 rxrpc_new_skb(skb, rxrpc_skb_rx_received);
164 serr = SKB_EXT_ERR(skb);
165 if (!skb->len && serr->ee.ee_origin == SO_EE_ORIGIN_TIMESTAMPING) {
166 _leave("UDP empty message");
167 rxrpc_free_skb(skb, rxrpc_skb_rx_freed);
168 return;
169 }
170
171 rcu_read_lock();
172 peer = rxrpc_lookup_peer_icmp_rcu(local, skb);
173 if (peer && !rxrpc_get_peer_maybe(peer))
174 peer = NULL;
175 if (!peer) {
176 rcu_read_unlock();
177 rxrpc_free_skb(skb, rxrpc_skb_rx_freed);
178 _leave(" [no peer]");
179 return;
180 }
181
182 if ((serr->ee.ee_origin == SO_EE_ORIGIN_ICMP &&
183 serr->ee.ee_type == ICMP_DEST_UNREACH &&
184 serr->ee.ee_code == ICMP_FRAG_NEEDED)) {
185 rxrpc_adjust_mtu(peer, serr);
186 rcu_read_unlock();
187 rxrpc_free_skb(skb, rxrpc_skb_rx_freed);
188 rxrpc_put_peer(peer);
189 _leave(" [MTU update]");
190 return;
191 }
192
193 rxrpc_store_error(peer, serr);
194 rcu_read_unlock();
195 rxrpc_free_skb(skb, rxrpc_skb_rx_freed);
196
197 /* The ref we obtained is passed off to the work item */
198 rxrpc_queue_work(&peer->error_distributor);
199 _leave("");
200 }
201
202 /*
203 * Map an error report to error codes on the peer record.
204 */
rxrpc_store_error(struct rxrpc_peer * peer,struct sock_exterr_skb * serr)205 static void rxrpc_store_error(struct rxrpc_peer *peer,
206 struct sock_exterr_skb *serr)
207 {
208 struct sock_extended_err *ee;
209 int err;
210
211 _enter("");
212
213 ee = &serr->ee;
214
215 _net("Rx Error o=%d t=%d c=%d e=%d",
216 ee->ee_origin, ee->ee_type, ee->ee_code, ee->ee_errno);
217
218 err = ee->ee_errno;
219
220 switch (ee->ee_origin) {
221 case SO_EE_ORIGIN_ICMP:
222 switch (ee->ee_type) {
223 case ICMP_DEST_UNREACH:
224 switch (ee->ee_code) {
225 case ICMP_NET_UNREACH:
226 _net("Rx Received ICMP Network Unreachable");
227 break;
228 case ICMP_HOST_UNREACH:
229 _net("Rx Received ICMP Host Unreachable");
230 break;
231 case ICMP_PORT_UNREACH:
232 _net("Rx Received ICMP Port Unreachable");
233 break;
234 case ICMP_NET_UNKNOWN:
235 _net("Rx Received ICMP Unknown Network");
236 break;
237 case ICMP_HOST_UNKNOWN:
238 _net("Rx Received ICMP Unknown Host");
239 break;
240 default:
241 _net("Rx Received ICMP DestUnreach code=%u",
242 ee->ee_code);
243 break;
244 }
245 break;
246
247 case ICMP_TIME_EXCEEDED:
248 _net("Rx Received ICMP TTL Exceeded");
249 break;
250
251 default:
252 _proto("Rx Received ICMP error { type=%u code=%u }",
253 ee->ee_type, ee->ee_code);
254 break;
255 }
256 break;
257
258 case SO_EE_ORIGIN_NONE:
259 case SO_EE_ORIGIN_LOCAL:
260 _proto("Rx Received local error { error=%d }", err);
261 err += RXRPC_LOCAL_ERROR_OFFSET;
262 break;
263
264 case SO_EE_ORIGIN_ICMP6:
265 default:
266 _proto("Rx Received error report { orig=%u }", ee->ee_origin);
267 break;
268 }
269
270 peer->error_report = err;
271 }
272
273 /*
274 * Distribute an error that occurred on a peer
275 */
rxrpc_peer_error_distributor(struct work_struct * work)276 void rxrpc_peer_error_distributor(struct work_struct *work)
277 {
278 struct rxrpc_peer *peer =
279 container_of(work, struct rxrpc_peer, error_distributor);
280 struct rxrpc_call *call;
281 enum rxrpc_call_completion compl;
282 int error;
283
284 _enter("");
285
286 error = READ_ONCE(peer->error_report);
287 if (error < RXRPC_LOCAL_ERROR_OFFSET) {
288 compl = RXRPC_CALL_NETWORK_ERROR;
289 } else {
290 compl = RXRPC_CALL_LOCAL_ERROR;
291 error -= RXRPC_LOCAL_ERROR_OFFSET;
292 }
293
294 _debug("ISSUE ERROR %s %d", rxrpc_call_completions[compl], error);
295
296 spin_lock_bh(&peer->lock);
297
298 while (!hlist_empty(&peer->error_targets)) {
299 call = hlist_entry(peer->error_targets.first,
300 struct rxrpc_call, error_link);
301 hlist_del_init(&call->error_link);
302 rxrpc_see_call(call);
303
304 if (rxrpc_set_call_completion(call, compl, 0, -error))
305 rxrpc_notify_socket(call);
306 }
307
308 spin_unlock_bh(&peer->lock);
309
310 rxrpc_put_peer(peer);
311 _leave("");
312 }
313
314 /*
315 * Add RTT information to cache. This is called in softirq mode and has
316 * exclusive access to the peer RTT data.
317 */
rxrpc_peer_add_rtt(struct rxrpc_call * call,enum rxrpc_rtt_rx_trace why,rxrpc_serial_t send_serial,rxrpc_serial_t resp_serial,ktime_t send_time,ktime_t resp_time)318 void rxrpc_peer_add_rtt(struct rxrpc_call *call, enum rxrpc_rtt_rx_trace why,
319 rxrpc_serial_t send_serial, rxrpc_serial_t resp_serial,
320 ktime_t send_time, ktime_t resp_time)
321 {
322 struct rxrpc_peer *peer = call->peer;
323 s64 rtt;
324 u64 sum = peer->rtt_sum, avg;
325 u8 cursor = peer->rtt_cursor, usage = peer->rtt_usage;
326
327 rtt = ktime_to_ns(ktime_sub(resp_time, send_time));
328 if (rtt < 0)
329 return;
330
331 /* Replace the oldest datum in the RTT buffer */
332 sum -= peer->rtt_cache[cursor];
333 sum += rtt;
334 peer->rtt_cache[cursor] = rtt;
335 peer->rtt_cursor = (cursor + 1) & (RXRPC_RTT_CACHE_SIZE - 1);
336 peer->rtt_sum = sum;
337 if (usage < RXRPC_RTT_CACHE_SIZE) {
338 usage++;
339 peer->rtt_usage = usage;
340 }
341
342 /* Now recalculate the average */
343 if (usage == RXRPC_RTT_CACHE_SIZE) {
344 avg = sum / RXRPC_RTT_CACHE_SIZE;
345 } else {
346 avg = sum;
347 do_div(avg, usage);
348 }
349
350 peer->rtt = avg;
351 trace_rxrpc_rtt_rx(call, why, send_serial, resp_serial, rtt,
352 usage, avg);
353 }
354