lustre/ptlrpc/connection.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  * GPL HEADER START
   5  *
   6  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 only,
  10  * as published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License version 2 for more details (a copy is included
  16  * in the LICENSE file that accompanied this code).
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * version 2 along with this program; If not, see
  20  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
  21  *
  22  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  23  * CA 95054 USA or visit www.sun.com if you need additional information or
  24  * have any questions.
  25  *
  26  * GPL HEADER END
  27  */
  28 /*
  29  * Copyright  2008 Sun Microsystems, Inc. All rights reserved
  30  * Use is subject to license terms.
  31  */
  32 /*
  33  * This file is part of Lustre, http://www.lustre.org/
  34  * Lustre is a trademark of Sun Microsystems, Inc.
  35  */
  36
  37 #define DEBUG_SUBSYSTEM S_RPC
  38 #ifdef __KERNEL__
  39 #include <obd_support.h>
  40 #include <obd_class.h>
  41 #include <lustre_net.h>
  42 #else
  43 #include <liblustre.h>
  44 #endif
  45
  46 #include "ptlrpc_internal.h"
  47 #include <class_hash.h>
  48
  49 static lustre_hash_t *conn_hash = NULL;
  50 static lustre_hash_ops_t conn_hash_ops;
  51
  52 struct ptlrpc_connection *
  53 ptlrpc_connection_get(lnet_process_id_t peer, lnet_nid_t self,
  54                       struct obd_uuid *uuid)
  55 {
  56         struct ptlrpc_connection *conn, *conn2;
  57         ENTRY;
  58
  59         conn = lustre_hash_lookup(conn_hash, &peer);
  60         if (conn)
  61                 GOTO(out, conn);
  62
  63         OBD_ALLOC_PTR(conn);
  64         if (!conn)
  65                 RETURN(NULL);
  66
  67         conn->c_peer = peer;
  68         conn->c_self = self;
  69         INIT_HLIST_NODE(&conn->c_hash);
  70         atomic_set(&conn->c_refcount, 1);
  71         if (uuid)
  72                 obd_str2uuid(&conn->c_remote_uuid, uuid->uuid);
  73
  74         /*
  75          * Add the newly created conn to the hash, on key collision we
  76          * lost a racing addition and must destroy our newly allocated
  77          * connection.  The object which exists in the has will be
  78          * returned and may be compared against out object.
  79          */
  80         conn2 = lustre_hash_findadd_unique(conn_hash, &peer, &conn->c_hash);
  81         if (conn != conn2) {
  82                 OBD_FREE_PTR(conn);
  83                 conn = conn2;
  84         }
  85         EXIT;
  86 out:
  87         CDEBUG(D_INFO, "conn=%p refcount %d to %s\n",
  88                conn, atomic_read(&conn->c_refcount),
  89                libcfs_nid2str(conn->c_peer.nid));
  90         return conn;
  91 }
  92
  93 int ptlrpc_connection_put(struct ptlrpc_connection *conn)
  94 {
  95         int rc = 0;
  96         ENTRY;
  97
  98         if (!conn)
  99                 RETURN(rc);
 100
 101         LASSERT(!hlist_unhashed(&conn->c_hash));
 102
 103         /*
 104          * We do not remove connection from hashtable and
 105          * do not free it even if last caller released ref,
 106          * as we want to have it cached for the case it is
 107          * needed again.
 108          *
 109          * Deallocating it and later creating new connection
 110          * again would be wastful. This way we also avoid
 111          * expensive locking to protect things from get/put
 112          * race when found cached connection is freed by
 113          * ptlrpc_connection_put().
 114          *
 115          * It will be freed later in module unload time,
 116          * when ptlrpc_connection_fini()->lh_exit->conn_exit()
 117          * path is called.
 118          */
 119         if (atomic_dec_return(&conn->c_refcount) == 1)
 120                 rc = 1;
 121
 122         CDEBUG(D_INFO, "PUT conn=%p refcount %d to %s\n",
 123                conn, atomic_read(&conn->c_refcount),
 124                libcfs_nid2str(conn->c_peer.nid));
 125
 126         RETURN(rc);
 127 }
 128
 129 struct ptlrpc_connection *
 130 ptlrpc_connection_addref(struct ptlrpc_connection *conn)
 131 {
 132         ENTRY;
 133
 134         atomic_inc(&conn->c_refcount);
 135         CDEBUG(D_INFO, "conn=%p refcount %d to %s\n",
 136                conn, atomic_read(&conn->c_refcount),
 137                libcfs_nid2str(conn->c_peer.nid));
 138
 139         RETURN(conn);
 140 }
 141
 142 int ptlrpc_connection_init(void)
 143 {
 144         ENTRY;
 145
 146         conn_hash = lustre_hash_init("CONN_HASH", 32, 32768,
 147                                      &conn_hash_ops, LH_REHASH);
 148         if (!conn_hash)
 149                 RETURN(-ENOMEM);
 150
 151         RETURN(0);
 152 }
 153
 154 void ptlrpc_connection_fini(void) {
 155         ENTRY;
 156         lustre_hash_exit(conn_hash);
 157         EXIT;
 158 }
 159
 160 /*
 161  * Hash operations for net_peer<->connection
 162  */
 163 static unsigned
 164 conn_hashfn(lustre_hash_t *lh,  void *key, unsigned mask)
 165 {
 166         return lh_djb2_hash(key, sizeof(lnet_process_id_t), mask);
 167 }
 168
 169 static int
 170 conn_compare(void *key, struct hlist_node *hnode)
 171 {
 172         struct ptlrpc_connection *conn;
 173         lnet_process_id_t *conn_key;
 174
 175         LASSERT(key != NULL);
 176         conn_key = (lnet_process_id_t*)key;
 177         conn = hlist_entry(hnode, struct ptlrpc_connection, c_hash);
 178
 179         return conn_key->nid == conn->c_peer.nid &&
 180                conn_key->pid == conn->c_peer.pid;
 181 }
 182
 183 static void *
 184 conn_key(struct hlist_node *hnode)
 185 {
 186         struct ptlrpc_connection *conn;
 187         conn = hlist_entry(hnode, struct ptlrpc_connection, c_hash);
 188         return &conn->c_peer;
 189 }
 190
 191 static void *
 192 conn_get(struct hlist_node *hnode)
 193 {
 194         struct ptlrpc_connection *conn;
 195
 196         conn = hlist_entry(hnode, struct ptlrpc_connection, c_hash);
 197         atomic_inc(&conn->c_refcount);
 198
 199         return conn;
 200 }
 201
 202 static void *
 203 conn_put(struct hlist_node *hnode)
 204 {
 205         struct ptlrpc_connection *conn;
 206
 207         conn = hlist_entry(hnode, struct ptlrpc_connection, c_hash);
 208         atomic_dec(&conn->c_refcount);
 209
 210         return conn;
 211 }
 212
 213 static void
 214 conn_exit(struct hlist_node *hnode)
 215 {
 216         struct ptlrpc_connection *conn;
 217
 218         conn = hlist_entry(hnode, struct ptlrpc_connection, c_hash);
 219         /*
 220          * Nothing should be left. Connection user put it and
 221          * connection also was deleted from table by this time
 222          * so we should have 0 refs.
 223          */
 224         LASSERTF(atomic_read(&conn->c_refcount) == 0,
 225                  "Busy connection with %d refs\n",
 226                  atomic_read(&conn->c_refcount));
 227         OBD_FREE_PTR(conn);
 228 }
 229
 230 static lustre_hash_ops_t conn_hash_ops = {
 231         .lh_hash    = conn_hashfn,
 232         .lh_compare = conn_compare,
 233         .lh_key     = conn_key,
 234         .lh_get     = conn_get,
 235         .lh_put     = conn_put,
 236         .lh_exit    = conn_exit,
 237 };