1 /* Client connection-specific management code. 2 * 3 * Copyright (C) 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 Licence 8 * as published by the Free Software Foundation; either version 9 * 2 of the Licence, or (at your option) any later version. 10 */ 11 12 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 13 14 #include <linux/slab.h> 15 #include <linux/idr.h> 16 #include <linux/timer.h> 17 #include "ar-internal.h" 18 19 /* 20 * We use machine-unique IDs for our client connections. 21 */ 22 DEFINE_IDR(rxrpc_client_conn_ids); 23 static DEFINE_SPINLOCK(rxrpc_conn_id_lock); 24 25 /* 26 * Get a connection ID and epoch for a client connection from the global pool. 27 * The connection struct pointer is then recorded in the idr radix tree. The 28 * epoch is changed if this wraps. 29 * 30 * TODO: The IDR tree gets very expensive on memory if the connection IDs are 31 * widely scattered throughout the number space, so we shall need to retire 32 * connections that have, say, an ID more than four times the maximum number of 33 * client conns away from the current allocation point to try and keep the IDs 34 * concentrated. We will also need to retire connections from an old epoch. 35 */ 36 static int rxrpc_get_client_connection_id(struct rxrpc_connection *conn, 37 gfp_t gfp) 38 { 39 u32 epoch; 40 int id; 41 42 _enter(""); 43 44 idr_preload(gfp); 45 spin_lock(&rxrpc_conn_id_lock); 46 47 epoch = rxrpc_epoch; 48 49 /* We could use idr_alloc_cyclic() here, but we really need to know 50 * when the thing wraps so that we can advance the epoch. 51 */ 52 if (rxrpc_client_conn_ids.cur == 0) 53 rxrpc_client_conn_ids.cur = 1; 54 id = idr_alloc(&rxrpc_client_conn_ids, conn, 55 rxrpc_client_conn_ids.cur, 0x40000000, GFP_NOWAIT); 56 if (id < 0) { 57 if (id != -ENOSPC) 58 goto error; 59 id = idr_alloc(&rxrpc_client_conn_ids, conn, 60 1, 0x40000000, GFP_NOWAIT); 61 if (id < 0) 62 goto error; 63 epoch++; 64 rxrpc_epoch = epoch; 65 } 66 rxrpc_client_conn_ids.cur = id + 1; 67 68 spin_unlock(&rxrpc_conn_id_lock); 69 idr_preload_end(); 70 71 conn->proto.epoch = epoch; 72 conn->proto.cid = id << RXRPC_CIDSHIFT; 73 set_bit(RXRPC_CONN_HAS_IDR, &conn->flags); 74 _leave(" [CID %x:%x]", epoch, conn->proto.cid); 75 return 0; 76 77 error: 78 spin_unlock(&rxrpc_conn_id_lock); 79 idr_preload_end(); 80 _leave(" = %d", id); 81 return id; 82 } 83 84 /* 85 * Release a connection ID for a client connection from the global pool. 86 */ 87 static void rxrpc_put_client_connection_id(struct rxrpc_connection *conn) 88 { 89 if (test_bit(RXRPC_CONN_HAS_IDR, &conn->flags)) { 90 spin_lock(&rxrpc_conn_id_lock); 91 idr_remove(&rxrpc_client_conn_ids, 92 conn->proto.cid >> RXRPC_CIDSHIFT); 93 spin_unlock(&rxrpc_conn_id_lock); 94 } 95 } 96 97 /* 98 * Destroy the client connection ID tree. 99 */ 100 void rxrpc_destroy_client_conn_ids(void) 101 { 102 struct rxrpc_connection *conn; 103 int id; 104 105 if (!idr_is_empty(&rxrpc_client_conn_ids)) { 106 idr_for_each_entry(&rxrpc_client_conn_ids, conn, id) { 107 pr_err("AF_RXRPC: Leaked client conn %p {%d}\n", 108 conn, atomic_read(&conn->usage)); 109 } 110 BUG(); 111 } 112 113 idr_destroy(&rxrpc_client_conn_ids); 114 } 115 116 /* 117 * Allocate a client connection. The caller must take care to clear any 118 * padding bytes in *cp. 119 */ 120 static struct rxrpc_connection * 121 rxrpc_alloc_client_connection(struct rxrpc_conn_parameters *cp, gfp_t gfp) 122 { 123 struct rxrpc_connection *conn; 124 int ret; 125 126 _enter(""); 127 128 conn = rxrpc_alloc_connection(gfp); 129 if (!conn) { 130 _leave(" = -ENOMEM"); 131 return ERR_PTR(-ENOMEM); 132 } 133 134 conn->params = *cp; 135 conn->out_clientflag = RXRPC_CLIENT_INITIATED; 136 conn->state = RXRPC_CONN_CLIENT; 137 138 ret = rxrpc_get_client_connection_id(conn, gfp); 139 if (ret < 0) 140 goto error_0; 141 142 ret = rxrpc_init_client_conn_security(conn); 143 if (ret < 0) 144 goto error_1; 145 146 ret = conn->security->prime_packet_security(conn); 147 if (ret < 0) 148 goto error_2; 149 150 write_lock(&rxrpc_connection_lock); 151 list_add_tail(&conn->link, &rxrpc_connections); 152 write_unlock(&rxrpc_connection_lock); 153 154 /* We steal the caller's peer ref. */ 155 cp->peer = NULL; 156 rxrpc_get_local(conn->params.local); 157 key_get(conn->params.key); 158 159 _leave(" = %p", conn); 160 return conn; 161 162 error_2: 163 conn->security->clear(conn); 164 error_1: 165 rxrpc_put_client_connection_id(conn); 166 error_0: 167 kfree(conn); 168 _leave(" = %d", ret); 169 return ERR_PTR(ret); 170 } 171 172 /* 173 * find a connection for a call 174 * - called in process context with IRQs enabled 175 */ 176 int rxrpc_connect_call(struct rxrpc_call *call, 177 struct rxrpc_conn_parameters *cp, 178 struct sockaddr_rxrpc *srx, 179 gfp_t gfp) 180 { 181 struct rxrpc_connection *conn, *candidate = NULL; 182 struct rxrpc_local *local = cp->local; 183 struct rb_node *p, **pp, *parent; 184 long diff; 185 int chan; 186 187 DECLARE_WAITQUEUE(myself, current); 188 189 _enter("{%d,%lx},", call->debug_id, call->user_call_ID); 190 191 cp->peer = rxrpc_lookup_peer(cp->local, srx, gfp); 192 if (!cp->peer) 193 return -ENOMEM; 194 195 if (!cp->exclusive) { 196 /* Search for a existing client connection unless this is going 197 * to be a connection that's used exclusively for a single call. 198 */ 199 _debug("search 1"); 200 spin_lock(&local->client_conns_lock); 201 p = local->client_conns.rb_node; 202 while (p) { 203 conn = rb_entry(p, struct rxrpc_connection, client_node); 204 205 #define cmp(X) ((long)conn->params.X - (long)cp->X) 206 diff = (cmp(peer) ?: 207 cmp(key) ?: 208 cmp(security_level)); 209 if (diff < 0) 210 p = p->rb_left; 211 else if (diff > 0) 212 p = p->rb_right; 213 else 214 goto found_extant_conn; 215 } 216 spin_unlock(&local->client_conns_lock); 217 } 218 219 /* We didn't find a connection or we want an exclusive one. */ 220 _debug("get new conn"); 221 candidate = rxrpc_alloc_client_connection(cp, gfp); 222 if (!candidate) { 223 _leave(" = -ENOMEM"); 224 return -ENOMEM; 225 } 226 227 if (cp->exclusive) { 228 /* Assign the call on an exclusive connection to channel 0 and 229 * don't add the connection to the endpoint's shareable conn 230 * lookup tree. 231 */ 232 _debug("exclusive chan 0"); 233 conn = candidate; 234 atomic_set(&conn->avail_chans, RXRPC_MAXCALLS - 1); 235 spin_lock(&conn->channel_lock); 236 chan = 0; 237 goto found_channel; 238 } 239 240 /* We need to redo the search before attempting to add a new connection 241 * lest we race with someone else adding a conflicting instance. 242 */ 243 _debug("search 2"); 244 spin_lock(&local->client_conns_lock); 245 246 pp = &local->client_conns.rb_node; 247 parent = NULL; 248 while (*pp) { 249 parent = *pp; 250 conn = rb_entry(parent, struct rxrpc_connection, client_node); 251 252 diff = (cmp(peer) ?: 253 cmp(key) ?: 254 cmp(security_level)); 255 if (diff < 0) 256 pp = &(*pp)->rb_left; 257 else if (diff > 0) 258 pp = &(*pp)->rb_right; 259 else 260 goto found_extant_conn; 261 } 262 263 /* The second search also failed; simply add the new connection with 264 * the new call in channel 0. Note that we need to take the channel 265 * lock before dropping the client conn lock. 266 */ 267 _debug("new conn"); 268 set_bit(RXRPC_CONN_IN_CLIENT_CONNS, &candidate->flags); 269 rb_link_node(&candidate->client_node, parent, pp); 270 rb_insert_color(&candidate->client_node, &local->client_conns); 271 attached: 272 conn = candidate; 273 candidate = NULL; 274 275 atomic_set(&conn->avail_chans, RXRPC_MAXCALLS - 1); 276 spin_lock(&conn->channel_lock); 277 spin_unlock(&local->client_conns_lock); 278 chan = 0; 279 280 found_channel: 281 _debug("found chan"); 282 call->conn = conn; 283 call->channel = chan; 284 call->epoch = conn->proto.epoch; 285 call->cid = conn->proto.cid | chan; 286 call->call_id = ++conn->channels[chan].call_counter; 287 conn->channels[chan].call_id = call->call_id; 288 rcu_assign_pointer(conn->channels[chan].call, call); 289 290 _net("CONNECT call %d on conn %d", call->debug_id, conn->debug_id); 291 292 spin_unlock(&conn->channel_lock); 293 rxrpc_put_peer(cp->peer); 294 cp->peer = NULL; 295 _leave(" = %p {u=%d}", conn, atomic_read(&conn->usage)); 296 return 0; 297 298 /* We found a potentially suitable connection already in existence. If 299 * we can reuse it (ie. its usage count hasn't been reduced to 0 by the 300 * reaper), discard any candidate we may have allocated, and try to get 301 * a channel on this one, otherwise we have to replace it. 302 */ 303 found_extant_conn: 304 _debug("found conn"); 305 if (!rxrpc_get_connection_maybe(conn)) { 306 set_bit(RXRPC_CONN_IN_CLIENT_CONNS, &candidate->flags); 307 rb_replace_node(&conn->client_node, 308 &candidate->client_node, 309 &local->client_conns); 310 clear_bit(RXRPC_CONN_IN_CLIENT_CONNS, &conn->flags); 311 goto attached; 312 } 313 314 spin_unlock(&local->client_conns_lock); 315 316 rxrpc_put_connection(candidate); 317 318 if (!atomic_add_unless(&conn->avail_chans, -1, 0)) { 319 if (!gfpflags_allow_blocking(gfp)) { 320 rxrpc_put_connection(conn); 321 _leave(" = -EAGAIN"); 322 return -EAGAIN; 323 } 324 325 add_wait_queue(&conn->channel_wq, &myself); 326 for (;;) { 327 set_current_state(TASK_INTERRUPTIBLE); 328 if (atomic_add_unless(&conn->avail_chans, -1, 0)) 329 break; 330 if (signal_pending(current)) 331 goto interrupted; 332 schedule(); 333 } 334 remove_wait_queue(&conn->channel_wq, &myself); 335 __set_current_state(TASK_RUNNING); 336 } 337 338 /* The connection allegedly now has a free channel and we can now 339 * attach the call to it. 340 */ 341 spin_lock(&conn->channel_lock); 342 343 for (chan = 0; chan < RXRPC_MAXCALLS; chan++) 344 if (!conn->channels[chan].call) 345 goto found_channel; 346 BUG(); 347 348 interrupted: 349 remove_wait_queue(&conn->channel_wq, &myself); 350 __set_current_state(TASK_RUNNING); 351 rxrpc_put_connection(conn); 352 rxrpc_put_peer(cp->peer); 353 cp->peer = NULL; 354 _leave(" = -ERESTARTSYS"); 355 return -ERESTARTSYS; 356 } 357 358 /* 359 * Remove a client connection from the local endpoint's tree, thereby removing 360 * it as a target for reuse for new client calls. 361 */ 362 void rxrpc_unpublish_client_conn(struct rxrpc_connection *conn) 363 { 364 struct rxrpc_local *local = conn->params.local; 365 366 spin_lock(&local->client_conns_lock); 367 if (test_and_clear_bit(RXRPC_CONN_IN_CLIENT_CONNS, &conn->flags)) 368 rb_erase(&conn->client_node, &local->client_conns); 369 spin_unlock(&local->client_conns_lock); 370 371 rxrpc_put_client_connection_id(conn); 372 } 373