lnet/lnet/peer.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  * lnet/lnet/peer.c
  37  */
  38
  39 #define DEBUG_SUBSYSTEM S_LNET
  40
  41 #include <lnet/lib-lnet.h>
  42
  43 int
  44 lnet_create_peer_table(void)
  45 {
  46         struct list_head *hash;
  47         int               i;
  48
  49         LASSERT (the_lnet.ln_peer_hash == NULL);
  50         LIBCFS_ALLOC(hash, LNET_PEER_HASHSIZE * sizeof(struct list_head));
  51
  52         if (hash == NULL) {
  53                 CERROR("Can't allocate peer hash table\n");
  54                 return -ENOMEM;
  55         }
  56
  57         for (i = 0; i < LNET_PEER_HASHSIZE; i++)
  58                 CFS_INIT_LIST_HEAD(&hash[i]);
  59
  60         the_lnet.ln_peer_hash = hash;
  61         return 0;
  62 }
  63
  64 void
  65 lnet_destroy_peer_table(void)
  66 {
  67         int         i;
  68
  69         if (the_lnet.ln_peer_hash == NULL)
  70                 return;
  71
  72         for (i = 0; i < LNET_PEER_HASHSIZE; i++)
  73                 LASSERT (list_empty(&the_lnet.ln_peer_hash[i]));
  74
  75         LIBCFS_FREE(the_lnet.ln_peer_hash,
  76                     LNET_PEER_HASHSIZE * sizeof (struct list_head));
  77         the_lnet.ln_peer_hash = NULL;
  78 }
  79
  80 void
  81 lnet_clear_peer_table(void)
  82 {
  83         int         i;
  84
  85         LASSERT (the_lnet.ln_shutdown);         /* i.e. no new peers */
  86
  87         for (i = 0; i < LNET_PEER_HASHSIZE; i++) {
  88                 struct list_head *peers = &the_lnet.ln_peer_hash[i];
  89
  90                 LNET_LOCK();
  91                 while (!list_empty(peers)) {
  92                         lnet_peer_t *lp = list_entry(peers->next,
  93                                                      lnet_peer_t, lp_hashlist);
  94
  95                         list_del(&lp->lp_hashlist);
  96                         lnet_peer_decref_locked(lp);   /* lose hash table's ref */
  97                 }
  98                 LNET_UNLOCK();
  99         }
 100
 101         LNET_LOCK();
 102         for (i = 3; the_lnet.ln_npeers != 0;i++) {
 103                 LNET_UNLOCK();
 104
 105                 if ((i & (i-1)) == 0)
 106                         CDEBUG(D_WARNING,"Waiting for %d peers\n",
 107                                the_lnet.ln_npeers);
 108                 cfs_pause(cfs_time_seconds(1));
 109
 110                 LNET_LOCK();
 111         }
 112         LNET_UNLOCK();
 113 }
 114
 115 void
 116 lnet_destroy_peer_locked (lnet_peer_t *lp)
 117 {
 118         lnet_ni_decref_locked(lp->lp_ni);
 119         LNET_UNLOCK();
 120
 121         LASSERT (lp->lp_refcount == 0);
 122         LASSERT (lp->lp_rtr_refcount == 0);
 123         LASSERT (list_empty(&lp->lp_txq));
 124         LASSERT (lp->lp_txqnob == 0);
 125
 126         LIBCFS_FREE(lp, sizeof(*lp));
 127
 128         LNET_LOCK();
 129
 130         LASSERT(the_lnet.ln_npeers > 0);
 131         the_lnet.ln_npeers--;
 132 }
 133
 134 lnet_peer_t *
 135 lnet_find_peer_locked (lnet_nid_t nid)
 136 {
 137         unsigned int      idx = LNET_NIDADDR(nid) % LNET_PEER_HASHSIZE;
 138         struct list_head *peers = &the_lnet.ln_peer_hash[idx];
 139         struct list_head *tmp;
 140         lnet_peer_t      *lp;
 141
 142         if (the_lnet.ln_shutdown)
 143                 return NULL;
 144
 145         list_for_each (tmp, peers) {
 146                 lp = list_entry(tmp, lnet_peer_t, lp_hashlist);
 147
 148                 if (lp->lp_nid == nid) {
 149                         lnet_peer_addref_locked(lp);
 150                         return lp;
 151                 }
 152         }
 153
 154         return NULL;
 155 }
 156
 157 int
 158 lnet_nid2peer_locked(lnet_peer_t **lpp, lnet_nid_t nid)
 159 {
 160         lnet_peer_t    *lp;
 161         lnet_peer_t    *lp2;
 162
 163         lp = lnet_find_peer_locked(nid);
 164         if (lp != NULL) {
 165                 *lpp = lp;
 166                 return 0;
 167         }
 168
 169         LNET_UNLOCK();
 170
 171         LIBCFS_ALLOC(lp, sizeof(*lp));
 172         if (lp == NULL) {
 173                 *lpp = NULL;
 174                 LNET_LOCK();
 175                 return -ENOMEM;
 176         }
 177
 178         memset(lp, 0, sizeof(*lp));             /* zero counters etc */
 179
 180         CFS_INIT_LIST_HEAD(&lp->lp_txq);
 181         CFS_INIT_LIST_HEAD(&lp->lp_rtrq);
 182
 183         lp->lp_notify = 0;
 184         lp->lp_notifylnd = 0;
 185         lp->lp_notifying = 0;
 186         lp->lp_alive_count = 0;
 187         lp->lp_timestamp = 0;
 188         lp->lp_alive = !lnet_peers_start_down(); /* 1 bit!! */
 189         lp->lp_last_alive = cfs_time_current_sec(); /* assumes alive */
 190         lp->lp_last_query = 0; /* didn't ask LND yet */
 191         lp->lp_ping_timestamp = 0;
 192         lp->lp_nid = nid;
 193         lp->lp_refcount = 2;                    /* 1 for caller; 1 for hash */
 194         lp->lp_rtr_refcount = 0;
 195
 196         LNET_LOCK();
 197
 198         lp2 = lnet_find_peer_locked(nid);
 199         if (lp2 != NULL) {
 200                 LNET_UNLOCK();
 201                 LIBCFS_FREE(lp, sizeof(*lp));
 202                 LNET_LOCK();
 203
 204                 if (the_lnet.ln_shutdown) {
 205                         lnet_peer_decref_locked(lp2);
 206                         *lpp = NULL;
 207                         return -ESHUTDOWN;
 208                 }
 209
 210                 *lpp = lp2;
 211                 return 0;
 212         }
 213
 214         lp->lp_ni = lnet_net2ni_locked(LNET_NIDNET(nid));
 215         if (lp->lp_ni == NULL) {
 216                 LNET_UNLOCK();
 217                 LIBCFS_FREE(lp, sizeof(*lp));
 218                 LNET_LOCK();
 219
 220                 *lpp = NULL;
 221                 return the_lnet.ln_shutdown ? -ESHUTDOWN : -EHOSTUNREACH;
 222         }
 223
 224         lp->lp_txcredits    =
 225         lp->lp_mintxcredits = lp->lp_ni->ni_peertxcredits;
 226         lp->lp_rtrcredits    =
 227         lp->lp_minrtrcredits = lnet_peer_buffer_credits(lp->lp_ni);
 228
 229         LASSERT (!the_lnet.ln_shutdown);
 230         /* can't add peers after shutdown starts */
 231
 232         list_add_tail(&lp->lp_hashlist, lnet_nid2peerhash(nid));
 233         the_lnet.ln_npeers++;
 234         the_lnet.ln_peertable_version++;
 235         *lpp = lp;
 236         return 0;
 237 }
 238
 239 void
 240 lnet_debug_peer(lnet_nid_t nid)
 241 {
 242         char        *aliveness = "NA";
 243         int          rc;
 244         lnet_peer_t *lp;
 245
 246         LNET_LOCK();
 247
 248         rc = lnet_nid2peer_locked(&lp, nid);
 249         if (rc != 0) {
 250                 LNET_UNLOCK();
 251                 CDEBUG(D_WARNING, "No peer %s\n", libcfs_nid2str(nid));
 252                 return;
 253         }
 254
 255         if (lnet_isrouter(lp) || lp->lp_ni->ni_peertimeout > 0)
 256                 aliveness = lp->lp_alive ? "up" : "down";
 257
 258         CDEBUG(D_WARNING, "%-24s %4d %5s %5d %5d %5d %5d %5d %ld\n",
 259                libcfs_nid2str(lp->lp_nid), lp->lp_refcount,
 260                aliveness, lp->lp_ni->ni_peertxcredits,
 261                lp->lp_rtrcredits, lp->lp_minrtrcredits,
 262                lp->lp_txcredits, lp->lp_mintxcredits, lp->lp_txqnob);
 263
 264         lnet_peer_decref_locked(lp);
 265
 266         LNET_UNLOCK();
 267 }