1 /* RxRPC virtual connection handler, common bits. 2 * 3 * Copyright (C) 2007, 2016 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/module.h> 15 #include <linux/slab.h> 16 #include <linux/net.h> 17 #include <linux/skbuff.h> 18 #include "ar-internal.h" 19 20 /* 21 * Time till a connection expires after last use (in seconds). 22 */ 23 unsigned int __read_mostly rxrpc_connection_expiry = 10 * 60; 24 unsigned int __read_mostly rxrpc_closed_conn_expiry = 10; 25 26 static void rxrpc_destroy_connection(struct rcu_head *); 27 28 static void rxrpc_connection_timer(struct timer_list *timer) 29 { 30 struct rxrpc_connection *conn = 31 container_of(timer, struct rxrpc_connection, timer); 32 33 rxrpc_queue_conn(conn); 34 } 35 36 /* 37 * allocate a new connection 38 */ 39 struct rxrpc_connection *rxrpc_alloc_connection(gfp_t gfp) 40 { 41 struct rxrpc_connection *conn; 42 43 _enter(""); 44 45 conn = kzalloc(sizeof(struct rxrpc_connection), gfp); 46 if (conn) { 47 INIT_LIST_HEAD(&conn->cache_link); 48 spin_lock_init(&conn->channel_lock); 49 INIT_LIST_HEAD(&conn->waiting_calls); 50 timer_setup(&conn->timer, &rxrpc_connection_timer, 0); 51 INIT_WORK(&conn->processor, &rxrpc_process_connection); 52 INIT_LIST_HEAD(&conn->proc_link); 53 INIT_LIST_HEAD(&conn->link); 54 skb_queue_head_init(&conn->rx_queue); 55 conn->security = &rxrpc_no_security; 56 spin_lock_init(&conn->state_lock); 57 conn->debug_id = atomic_inc_return(&rxrpc_debug_id); 58 conn->size_align = 4; 59 conn->idle_timestamp = jiffies; 60 } 61 62 _leave(" = %p{%d}", conn, conn ? conn->debug_id : 0); 63 return conn; 64 } 65 66 /* 67 * Look up a connection in the cache by protocol parameters. 68 * 69 * If successful, a pointer to the connection is returned, but no ref is taken. 70 * NULL is returned if there is no match. 71 * 72 * The caller must be holding the RCU read lock. 73 */ 74 struct rxrpc_connection *rxrpc_find_connection_rcu(struct rxrpc_local *local, 75 struct sk_buff *skb) 76 { 77 struct rxrpc_connection *conn; 78 struct rxrpc_conn_proto k; 79 struct rxrpc_skb_priv *sp = rxrpc_skb(skb); 80 struct sockaddr_rxrpc srx; 81 struct rxrpc_peer *peer; 82 83 _enter(",%x", sp->hdr.cid & RXRPC_CIDMASK); 84 85 if (rxrpc_extract_addr_from_skb(local, &srx, skb) < 0) 86 goto not_found; 87 88 k.epoch = sp->hdr.epoch; 89 k.cid = sp->hdr.cid & RXRPC_CIDMASK; 90 91 /* We may have to handle mixing IPv4 and IPv6 */ 92 if (srx.transport.family != local->srx.transport.family) { 93 pr_warn_ratelimited("AF_RXRPC: Protocol mismatch %u not %u\n", 94 srx.transport.family, 95 local->srx.transport.family); 96 goto not_found; 97 } 98 99 k.epoch = sp->hdr.epoch; 100 k.cid = sp->hdr.cid & RXRPC_CIDMASK; 101 102 if (sp->hdr.flags & RXRPC_CLIENT_INITIATED) { 103 /* We need to look up service connections by the full protocol 104 * parameter set. We look up the peer first as an intermediate 105 * step and then the connection from the peer's tree. 106 */ 107 peer = rxrpc_lookup_peer_rcu(local, &srx); 108 if (!peer) 109 goto not_found; 110 conn = rxrpc_find_service_conn_rcu(peer, skb); 111 if (!conn || atomic_read(&conn->usage) == 0) 112 goto not_found; 113 _leave(" = %p", conn); 114 return conn; 115 } else { 116 /* Look up client connections by connection ID alone as their 117 * IDs are unique for this machine. 118 */ 119 conn = idr_find(&rxrpc_client_conn_ids, 120 sp->hdr.cid >> RXRPC_CIDSHIFT); 121 if (!conn || atomic_read(&conn->usage) == 0) { 122 _debug("no conn"); 123 goto not_found; 124 } 125 126 if (conn->proto.epoch != k.epoch || 127 conn->params.local != local) 128 goto not_found; 129 130 peer = conn->params.peer; 131 switch (srx.transport.family) { 132 case AF_INET: 133 if (peer->srx.transport.sin.sin_port != 134 srx.transport.sin.sin_port || 135 peer->srx.transport.sin.sin_addr.s_addr != 136 srx.transport.sin.sin_addr.s_addr) 137 goto not_found; 138 break; 139 #ifdef CONFIG_AF_RXRPC_IPV6 140 case AF_INET6: 141 if (peer->srx.transport.sin6.sin6_port != 142 srx.transport.sin6.sin6_port || 143 memcmp(&peer->srx.transport.sin6.sin6_addr, 144 &srx.transport.sin6.sin6_addr, 145 sizeof(struct in6_addr)) != 0) 146 goto not_found; 147 break; 148 #endif 149 default: 150 BUG(); 151 } 152 153 _leave(" = %p", conn); 154 return conn; 155 } 156 157 not_found: 158 _leave(" = NULL"); 159 return NULL; 160 } 161 162 /* 163 * Disconnect a call and clear any channel it occupies when that call 164 * terminates. The caller must hold the channel_lock and must release the 165 * call's ref on the connection. 166 */ 167 void __rxrpc_disconnect_call(struct rxrpc_connection *conn, 168 struct rxrpc_call *call) 169 { 170 struct rxrpc_channel *chan = 171 &conn->channels[call->cid & RXRPC_CHANNELMASK]; 172 173 _enter("%d,%x", conn->debug_id, call->cid); 174 175 if (rcu_access_pointer(chan->call) == call) { 176 /* Save the result of the call so that we can repeat it if necessary 177 * through the channel, whilst disposing of the actual call record. 178 */ 179 trace_rxrpc_disconnect_call(call); 180 if (call->abort_code) { 181 chan->last_abort = call->abort_code; 182 chan->last_type = RXRPC_PACKET_TYPE_ABORT; 183 } else { 184 chan->last_seq = call->rx_hard_ack; 185 chan->last_type = RXRPC_PACKET_TYPE_ACK; 186 } 187 /* Sync with rxrpc_conn_retransmit(). */ 188 smp_wmb(); 189 chan->last_call = chan->call_id; 190 chan->call_id = chan->call_counter; 191 192 rcu_assign_pointer(chan->call, NULL); 193 } 194 195 _leave(""); 196 } 197 198 /* 199 * Disconnect a call and clear any channel it occupies when that call 200 * terminates. 201 */ 202 void rxrpc_disconnect_call(struct rxrpc_call *call) 203 { 204 struct rxrpc_connection *conn = call->conn; 205 206 call->peer->cong_cwnd = call->cong_cwnd; 207 208 spin_lock_bh(&conn->params.peer->lock); 209 hlist_del_init(&call->error_link); 210 spin_unlock_bh(&conn->params.peer->lock); 211 212 if (rxrpc_is_client_call(call)) 213 return rxrpc_disconnect_client_call(call); 214 215 spin_lock(&conn->channel_lock); 216 __rxrpc_disconnect_call(conn, call); 217 spin_unlock(&conn->channel_lock); 218 219 call->conn = NULL; 220 conn->idle_timestamp = jiffies; 221 rxrpc_put_connection(conn); 222 } 223 224 /* 225 * Kill off a connection. 226 */ 227 void rxrpc_kill_connection(struct rxrpc_connection *conn) 228 { 229 struct rxrpc_net *rxnet = conn->params.local->rxnet; 230 231 ASSERT(!rcu_access_pointer(conn->channels[0].call) && 232 !rcu_access_pointer(conn->channels[1].call) && 233 !rcu_access_pointer(conn->channels[2].call) && 234 !rcu_access_pointer(conn->channels[3].call)); 235 ASSERT(list_empty(&conn->cache_link)); 236 237 write_lock(&rxnet->conn_lock); 238 list_del_init(&conn->proc_link); 239 write_unlock(&rxnet->conn_lock); 240 241 /* Drain the Rx queue. Note that even though we've unpublished, an 242 * incoming packet could still be being added to our Rx queue, so we 243 * will need to drain it again in the RCU cleanup handler. 244 */ 245 rxrpc_purge_queue(&conn->rx_queue); 246 247 /* Leave final destruction to RCU. The connection processor work item 248 * must carry a ref on the connection to prevent us getting here whilst 249 * it is queued or running. 250 */ 251 call_rcu(&conn->rcu, rxrpc_destroy_connection); 252 } 253 254 /* 255 * Queue a connection's work processor, getting a ref to pass to the work 256 * queue. 257 */ 258 bool rxrpc_queue_conn(struct rxrpc_connection *conn) 259 { 260 const void *here = __builtin_return_address(0); 261 int n = __atomic_add_unless(&conn->usage, 1, 0); 262 if (n == 0) 263 return false; 264 if (rxrpc_queue_work(&conn->processor)) 265 trace_rxrpc_conn(conn, rxrpc_conn_queued, n + 1, here); 266 else 267 rxrpc_put_connection(conn); 268 return true; 269 } 270 271 /* 272 * Note the re-emergence of a connection. 273 */ 274 void rxrpc_see_connection(struct rxrpc_connection *conn) 275 { 276 const void *here = __builtin_return_address(0); 277 if (conn) { 278 int n = atomic_read(&conn->usage); 279 280 trace_rxrpc_conn(conn, rxrpc_conn_seen, n, here); 281 } 282 } 283 284 /* 285 * Get a ref on a connection. 286 */ 287 void rxrpc_get_connection(struct rxrpc_connection *conn) 288 { 289 const void *here = __builtin_return_address(0); 290 int n = atomic_inc_return(&conn->usage); 291 292 trace_rxrpc_conn(conn, rxrpc_conn_got, n, here); 293 } 294 295 /* 296 * Try to get a ref on a connection. 297 */ 298 struct rxrpc_connection * 299 rxrpc_get_connection_maybe(struct rxrpc_connection *conn) 300 { 301 const void *here = __builtin_return_address(0); 302 303 if (conn) { 304 int n = __atomic_add_unless(&conn->usage, 1, 0); 305 if (n > 0) 306 trace_rxrpc_conn(conn, rxrpc_conn_got, n + 1, here); 307 else 308 conn = NULL; 309 } 310 return conn; 311 } 312 313 /* 314 * Set the service connection reap timer. 315 */ 316 static void rxrpc_set_service_reap_timer(struct rxrpc_net *rxnet, 317 unsigned long reap_at) 318 { 319 if (rxnet->live) 320 timer_reduce(&rxnet->service_conn_reap_timer, reap_at); 321 } 322 323 /* 324 * Release a service connection 325 */ 326 void rxrpc_put_service_conn(struct rxrpc_connection *conn) 327 { 328 const void *here = __builtin_return_address(0); 329 int n; 330 331 n = atomic_dec_return(&conn->usage); 332 trace_rxrpc_conn(conn, rxrpc_conn_put_service, n, here); 333 ASSERTCMP(n, >=, 0); 334 if (n == 1) 335 rxrpc_set_service_reap_timer(conn->params.local->rxnet, 336 jiffies + rxrpc_connection_expiry); 337 } 338 339 /* 340 * destroy a virtual connection 341 */ 342 static void rxrpc_destroy_connection(struct rcu_head *rcu) 343 { 344 struct rxrpc_connection *conn = 345 container_of(rcu, struct rxrpc_connection, rcu); 346 347 _enter("{%d,u=%d}", conn->debug_id, atomic_read(&conn->usage)); 348 349 ASSERTCMP(atomic_read(&conn->usage), ==, 0); 350 351 _net("DESTROY CONN %d", conn->debug_id); 352 353 del_timer_sync(&conn->timer); 354 rxrpc_purge_queue(&conn->rx_queue); 355 356 conn->security->clear(conn); 357 key_put(conn->params.key); 358 key_put(conn->server_key); 359 rxrpc_put_peer(conn->params.peer); 360 rxrpc_put_local(conn->params.local); 361 362 kfree(conn); 363 _leave(""); 364 } 365 366 /* 367 * reap dead service connections 368 */ 369 void rxrpc_service_connection_reaper(struct work_struct *work) 370 { 371 struct rxrpc_connection *conn, *_p; 372 struct rxrpc_net *rxnet = 373 container_of(work, struct rxrpc_net, service_conn_reaper); 374 unsigned long expire_at, earliest, idle_timestamp, now; 375 376 LIST_HEAD(graveyard); 377 378 _enter(""); 379 380 now = jiffies; 381 earliest = now + MAX_JIFFY_OFFSET; 382 383 write_lock(&rxnet->conn_lock); 384 list_for_each_entry_safe(conn, _p, &rxnet->service_conns, link) { 385 ASSERTCMP(atomic_read(&conn->usage), >, 0); 386 if (likely(atomic_read(&conn->usage) > 1)) 387 continue; 388 if (conn->state == RXRPC_CONN_SERVICE_PREALLOC) 389 continue; 390 391 if (rxnet->live) { 392 idle_timestamp = READ_ONCE(conn->idle_timestamp); 393 expire_at = idle_timestamp + rxrpc_connection_expiry * HZ; 394 if (conn->params.local->service_closed) 395 expire_at = idle_timestamp + rxrpc_closed_conn_expiry * HZ; 396 397 _debug("reap CONN %d { u=%d,t=%ld }", 398 conn->debug_id, atomic_read(&conn->usage), 399 (long)expire_at - (long)now); 400 401 if (time_before(now, expire_at)) { 402 if (time_before(expire_at, earliest)) 403 earliest = expire_at; 404 continue; 405 } 406 } 407 408 /* The usage count sits at 1 whilst the object is unused on the 409 * list; we reduce that to 0 to make the object unavailable. 410 */ 411 if (atomic_cmpxchg(&conn->usage, 1, 0) != 1) 412 continue; 413 trace_rxrpc_conn(conn, rxrpc_conn_reap_service, 0, 0); 414 415 if (rxrpc_conn_is_client(conn)) 416 BUG(); 417 else 418 rxrpc_unpublish_service_conn(conn); 419 420 list_move_tail(&conn->link, &graveyard); 421 } 422 write_unlock(&rxnet->conn_lock); 423 424 if (earliest != now + MAX_JIFFY_OFFSET) { 425 _debug("reschedule reaper %ld", (long)earliest - (long)now); 426 ASSERT(time_after(earliest, now)); 427 rxrpc_set_service_reap_timer(rxnet, earliest); 428 } 429 430 while (!list_empty(&graveyard)) { 431 conn = list_entry(graveyard.next, struct rxrpc_connection, 432 link); 433 list_del_init(&conn->link); 434 435 ASSERTCMP(atomic_read(&conn->usage), ==, 0); 436 rxrpc_kill_connection(conn); 437 } 438 439 _leave(""); 440 } 441 442 /* 443 * preemptively destroy all the service connection records rather than 444 * waiting for them to time out 445 */ 446 void rxrpc_destroy_all_connections(struct rxrpc_net *rxnet) 447 { 448 struct rxrpc_connection *conn, *_p; 449 bool leak = false; 450 451 _enter(""); 452 453 rxrpc_destroy_all_client_connections(rxnet); 454 455 del_timer_sync(&rxnet->service_conn_reap_timer); 456 rxrpc_queue_work(&rxnet->service_conn_reaper); 457 flush_workqueue(rxrpc_workqueue); 458 459 write_lock(&rxnet->conn_lock); 460 list_for_each_entry_safe(conn, _p, &rxnet->service_conns, link) { 461 pr_err("AF_RXRPC: Leaked conn %p {%d}\n", 462 conn, atomic_read(&conn->usage)); 463 leak = true; 464 } 465 write_unlock(&rxnet->conn_lock); 466 BUG_ON(leak); 467 468 ASSERT(list_empty(&rxnet->conn_proc_list)); 469 470 _leave(""); 471 } 472