lnet/lnet/peer.c

   1 /*
   2  * GPL HEADER START
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 only,
   8  * as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License version 2 for more details (a copy is included
  14  * in the LICENSE file that accompanied this code).
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * version 2 along with this program; If not, see
  18  * http://www.gnu.org/licenses/gpl-2.0.html
  19  *
  20  * GPL HEADER END
  21  */
  22 /*
  23  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
  24  * Use is subject to license terms.
  25  *
  26  * Copyright (c) 2012, 2014, Intel Corporation.
  27  */
  28 /*
  29  * This file is part of Lustre, http://www.lustre.org/
  30  * Lustre is a trademark of Sun Microsystems, Inc.
  31  *
  32  * lnet/lnet/peer.c
  33  */
  34
  35 #define DEBUG_SUBSYSTEM S_LNET
  36
  37 #include <lnet/lib-lnet.h>
  38 #include <lnet/lib-dlc.h>
  39
  40 static void
  41 lnet_peer_remove_from_remote_list(struct lnet_peer_ni *lpni)
  42 {
  43         if (!list_empty(&lpni->lpni_on_remote_peer_ni_list)) {
  44                 list_del_init(&lpni->lpni_on_remote_peer_ni_list);
  45                 lnet_peer_ni_decref_locked(lpni);
  46         }
  47 }
  48
  49 void
  50 lnet_peer_net_added(struct lnet_net *net)
  51 {
  52         struct lnet_peer_ni *lpni, *tmp;
  53
  54         list_for_each_entry_safe(lpni, tmp, &the_lnet.ln_remote_peer_ni_list,
  55                                  lpni_on_remote_peer_ni_list) {
  56
  57                 if (LNET_NIDNET(lpni->lpni_nid) == net->net_id) {
  58                         lpni->lpni_net = net;
  59                         lpni->lpni_txcredits =
  60                         lpni->lpni_mintxcredits =
  61                                 lpni->lpni_net->net_tunables.lct_peer_tx_credits;
  62                         lpni->lpni_rtrcredits =
  63                         lpni->lpni_minrtrcredits =
  64                                 lnet_peer_buffer_credits(lpni->lpni_net);
  65
  66                         lnet_peer_remove_from_remote_list(lpni);
  67                 }
  68         }
  69 }
  70
  71 static void
  72 lnet_peer_tables_destroy(void)
  73 {
  74         struct lnet_peer_table  *ptable;
  75         struct list_head        *hash;
  76         int                     i;
  77         int                     j;
  78
  79         if (!the_lnet.ln_peer_tables)
  80                 return;
  81
  82         cfs_percpt_for_each(ptable, i, the_lnet.ln_peer_tables) {
  83                 hash = ptable->pt_hash;
  84                 if (!hash) /* not intialized */
  85                         break;
  86
  87                 ptable->pt_hash = NULL;
  88                 for (j = 0; j < LNET_PEER_HASH_SIZE; j++)
  89                         LASSERT(list_empty(&hash[j]));
  90
  91                 LIBCFS_FREE(hash, LNET_PEER_HASH_SIZE * sizeof(*hash));
  92         }
  93
  94         cfs_percpt_free(the_lnet.ln_peer_tables);
  95         the_lnet.ln_peer_tables = NULL;
  96 }
  97
  98 int
  99 lnet_peer_tables_create(void)
 100 {
 101         struct lnet_peer_table  *ptable;
 102         struct list_head        *hash;
 103         int                     i;
 104         int                     j;
 105
 106         the_lnet.ln_peer_tables = cfs_percpt_alloc(lnet_cpt_table(),
 107                                                    sizeof(*ptable));
 108         if (the_lnet.ln_peer_tables == NULL) {
 109                 CERROR("Failed to allocate cpu-partition peer tables\n");
 110                 return -ENOMEM;
 111         }
 112
 113         cfs_percpt_for_each(ptable, i, the_lnet.ln_peer_tables) {
 114                 LIBCFS_CPT_ALLOC(hash, lnet_cpt_table(), i,
 115                                  LNET_PEER_HASH_SIZE * sizeof(*hash));
 116                 if (hash == NULL) {
 117                         CERROR("Failed to create peer hash table\n");
 118                         lnet_peer_tables_destroy();
 119                         return -ENOMEM;
 120                 }
 121
 122                 for (j = 0; j < LNET_PEER_HASH_SIZE; j++)
 123                         INIT_LIST_HEAD(&hash[j]);
 124                 ptable->pt_hash = hash; /* sign of initialization */
 125         }
 126
 127         return 0;
 128 }
 129
 130 void lnet_peer_uninit()
 131 {
 132         int cpt;
 133         struct lnet_peer_ni *lpni, *tmp;
 134         struct lnet_peer_table *ptable = NULL;
 135
 136         /* remove all peer_nis from the remote peer and he hash list */
 137         list_for_each_entry_safe(lpni, tmp, &the_lnet.ln_remote_peer_ni_list,
 138                                  lpni_on_remote_peer_ni_list) {
 139                 list_del_init(&lpni->lpni_on_remote_peer_ni_list);
 140                 lnet_peer_ni_decref_locked(lpni);
 141
 142                 cpt = lnet_cpt_of_nid_locked(lpni->lpni_nid, NULL);
 143                 ptable = the_lnet.ln_peer_tables[cpt];
 144                 ptable->pt_zombies++;
 145
 146                 list_del_init(&lpni->lpni_hashlist);
 147                 lnet_peer_ni_decref_locked(lpni);
 148         }
 149
 150         lnet_peer_tables_destroy();
 151 }
 152
 153 static void
 154 lnet_peer_table_cleanup_locked(lnet_ni_t *ni, struct lnet_peer_table *ptable)
 155 {
 156         int                      i;
 157         struct lnet_peer_ni     *lp;
 158         struct lnet_peer_ni     *tmp;
 159
 160         for (i = 0; i < LNET_PEER_HASH_SIZE; i++) {
 161                 list_for_each_entry_safe(lp, tmp, &ptable->pt_hash[i],
 162                                          lpni_hashlist) {
 163                         if (ni != NULL && ni->ni_net != lp->lpni_net)
 164                                 continue;
 165                         list_del_init(&lp->lpni_hashlist);
 166                         /* Lose hash table's ref */
 167                         ptable->pt_zombies++;
 168                         lnet_peer_ni_decref_locked(lp);
 169                 }
 170         }
 171 }
 172
 173 static void
 174 lnet_peer_table_finalize_wait_locked(struct lnet_peer_table *ptable,
 175                                      int cpt_locked)
 176 {
 177         int     i;
 178
 179         for (i = 3; ptable->pt_zombies != 0; i++) {
 180                 lnet_net_unlock(cpt_locked);
 181
 182                 if (IS_PO2(i)) {
 183                         CDEBUG(D_WARNING,
 184                                "Waiting for %d zombies on peer table\n",
 185                                ptable->pt_zombies);
 186                 }
 187                 set_current_state(TASK_UNINTERRUPTIBLE);
 188                 schedule_timeout(cfs_time_seconds(1) >> 1);
 189                 lnet_net_lock(cpt_locked);
 190         }
 191 }
 192
 193 static void
 194 lnet_peer_table_del_rtrs_locked(lnet_ni_t *ni, struct lnet_peer_table *ptable,
 195                                 int cpt_locked)
 196 {
 197         struct lnet_peer_ni     *lp;
 198         struct lnet_peer_ni     *tmp;
 199         lnet_nid_t              lpni_nid;
 200         int                     i;
 201
 202         for (i = 0; i < LNET_PEER_HASH_SIZE; i++) {
 203                 list_for_each_entry_safe(lp, tmp, &ptable->pt_hash[i],
 204                                          lpni_hashlist) {
 205                         if (ni->ni_net != lp->lpni_net)
 206                                 continue;
 207
 208                         if (lp->lpni_rtr_refcount == 0)
 209                                 continue;
 210
 211                         lpni_nid = lp->lpni_nid;
 212
 213                         lnet_net_unlock(cpt_locked);
 214                         lnet_del_route(LNET_NIDNET(LNET_NID_ANY), lpni_nid);
 215                         lnet_net_lock(cpt_locked);
 216                 }
 217         }
 218 }
 219
 220 void
 221 lnet_peer_tables_cleanup(lnet_ni_t *ni)
 222 {
 223         int                             i;
 224         struct lnet_peer_table          *ptable;
 225
 226         LASSERT(the_lnet.ln_shutdown || ni != NULL);
 227         /* If just deleting the peers for a NI, get rid of any routes these
 228          * peers are gateways for. */
 229         cfs_percpt_for_each(ptable, i, the_lnet.ln_peer_tables) {
 230                 lnet_net_lock(LNET_LOCK_EX);
 231                 lnet_peer_table_del_rtrs_locked(ni, ptable, i);
 232                 lnet_net_unlock(LNET_LOCK_EX);
 233         }
 234
 235         /* Start the cleanup process */
 236         cfs_percpt_for_each(ptable, i, the_lnet.ln_peer_tables) {
 237                 lnet_net_lock(LNET_LOCK_EX);
 238                 lnet_peer_table_cleanup_locked(ni, ptable);
 239                 lnet_net_unlock(LNET_LOCK_EX);
 240         }
 241
 242         /* Wait until all peers have been destroyed. */
 243         cfs_percpt_for_each(ptable, i, the_lnet.ln_peer_tables) {
 244                 lnet_net_lock(LNET_LOCK_EX);
 245                 lnet_peer_table_finalize_wait_locked(ptable, i);
 246                 lnet_net_unlock(LNET_LOCK_EX);
 247         }
 248 }
 249
 250 static struct lnet_peer_ni *
 251 lnet_get_peer_ni_locked(struct lnet_peer_table *ptable, lnet_nid_t nid)
 252 {
 253         struct list_head        *peers;
 254         struct lnet_peer_ni     *lp;
 255
 256         LASSERT(!the_lnet.ln_shutdown);
 257
 258         peers = &ptable->pt_hash[lnet_nid2peerhash(nid)];
 259         list_for_each_entry(lp, peers, lpni_hashlist) {
 260                 if (lp->lpni_nid == nid) {
 261                         lnet_peer_ni_addref_locked(lp);
 262                         return lp;
 263                 }
 264         }
 265
 266         return NULL;
 267 }
 268
 269 struct lnet_peer_ni *
 270 lnet_find_peer_ni_locked(lnet_nid_t nid)
 271 {
 272         struct lnet_peer_ni *lpni;
 273         struct lnet_peer_table *ptable;
 274         int cpt;
 275
 276         cpt = lnet_nid_cpt_hash(nid, LNET_CPT_NUMBER);
 277
 278         ptable = the_lnet.ln_peer_tables[cpt];
 279         lpni = lnet_get_peer_ni_locked(ptable, nid);
 280
 281         return lpni;
 282 }
 283
 284 int
 285 lnet_find_or_create_peer_locked(lnet_nid_t dst_nid, int cpt, struct lnet_peer **peer)
 286 {
 287         struct lnet_peer_ni *lpni;
 288
 289         lpni = lnet_find_peer_ni_locked(dst_nid);
 290         if (!lpni) {
 291                 int rc;
 292                 rc = lnet_nid2peerni_locked(&lpni, dst_nid, cpt);
 293                 if (rc != 0)
 294                         return rc;
 295         }
 296
 297         *peer = lpni->lpni_peer_net->lpn_peer;
 298         lnet_peer_ni_decref_locked(lpni);
 299
 300         return 0;
 301 }
 302
 303 struct lnet_peer_ni *
 304 lnet_get_peer_ni_idx_locked(int idx, struct lnet_peer_net **lpn,
 305                             struct lnet_peer **lp)
 306 {
 307         struct lnet_peer_ni     *lpni;
 308
 309         list_for_each_entry((*lp), &the_lnet.ln_peers, lp_on_lnet_peer_list) {
 310                 list_for_each_entry((*lpn), &((*lp)->lp_peer_nets), lpn_on_peer_list) {
 311                         list_for_each_entry(lpni, &((*lpn)->lpn_peer_nis),
 312                                             lpni_on_peer_net_list)
 313                                 if (idx-- == 0)
 314                                         return lpni;
 315                 }
 316         }
 317
 318         return NULL;
 319 }
 320
 321 struct lnet_peer_ni *
 322 lnet_get_next_peer_ni_locked(struct lnet_peer *peer,
 323                              struct lnet_peer_net *peer_net,
 324                              struct lnet_peer_ni *prev)
 325 {
 326         struct lnet_peer_ni *lpni;
 327         struct lnet_peer_net *net = peer_net;
 328
 329         if (!prev) {
 330                 if (!net)
 331                         net = list_entry(peer->lp_peer_nets.next,
 332                                          struct lnet_peer_net,
 333                                          lpn_on_peer_list);
 334                 lpni = list_entry(net->lpn_peer_nis.next, struct lnet_peer_ni,
 335                                   lpni_on_peer_net_list);
 336
 337                 return lpni;
 338         }
 339
 340         if (prev->lpni_on_peer_net_list.next ==
 341             &prev->lpni_peer_net->lpn_peer_nis) {
 342                 /*
 343                  * if you reached the end of the peer ni list and the peer
 344                  * net is specified then there are no more peer nis in that
 345                  * net.
 346                  */
 347                 if (net)
 348                         return NULL;
 349
 350                 /*
 351                  * we reached the end of this net ni list. move to the
 352                  * next net
 353                  */
 354                 if (prev->lpni_peer_net->lpn_on_peer_list.next ==
 355                     &peer->lp_peer_nets)
 356                         /* no more nets and no more NIs. */
 357                         return NULL;
 358
 359                 /* get the next net */
 360                 net = list_entry(prev->lpni_peer_net->lpn_on_peer_list.next,
 361                                  struct lnet_peer_net,
 362                                  lpn_on_peer_list);
 363                 /* get the ni on it */
 364                 lpni = list_entry(net->lpn_peer_nis.next, struct lnet_peer_ni,
 365                                   lpni_on_peer_net_list);
 366
 367                 return lpni;
 368         }
 369
 370         /* there are more nis left */
 371         lpni = list_entry(prev->lpni_on_peer_net_list.next,
 372                           struct lnet_peer_ni, lpni_on_peer_net_list);
 373
 374         return lpni;
 375 }
 376
 377 bool
 378 lnet_peer_is_ni_pref_locked(struct lnet_peer_ni *lpni, struct lnet_ni *ni)
 379 {
 380         int i;
 381
 382         for (i = 0; i < lpni->lpni_pref_nnids; i++) {
 383                 if (lpni->lpni_pref_nids[i] == ni->ni_nid)
 384                         return true;
 385         }
 386         return false;
 387 }
 388
 389 lnet_nid_t
 390 lnet_peer_primary_nid(lnet_nid_t nid)
 391 {
 392         struct lnet_peer_ni *lpni;
 393         lnet_nid_t primary_nid = nid;
 394         int cpt;
 395
 396         cpt = lnet_net_lock_current();
 397         lpni = lnet_find_peer_ni_locked(nid);
 398         if (lpni) {
 399                 primary_nid = lpni->lpni_peer_net->lpn_peer->lp_primary_nid;
 400                 lnet_peer_ni_decref_locked(lpni);
 401         }
 402         lnet_net_unlock(cpt);
 403
 404         return primary_nid;
 405 }
 406
 407 static void
 408 lnet_try_destroy_peer_hierarchy_locked(struct lnet_peer_ni *lpni)
 409 {
 410         struct lnet_peer_net *peer_net;
 411         struct lnet_peer *peer;
 412
 413         /* TODO: could the below situation happen? accessing an already
 414          * destroyed peer? */
 415         if (lpni->lpni_peer_net == NULL ||
 416             lpni->lpni_peer_net->lpn_peer == NULL)
 417                 return;
 418
 419         peer_net = lpni->lpni_peer_net;
 420         peer = lpni->lpni_peer_net->lpn_peer;
 421
 422         list_del_init(&lpni->lpni_on_peer_net_list);
 423         lpni->lpni_peer_net = NULL;
 424
 425         /* if peer_net is empty, then remove it from the peer */
 426         if (list_empty(&peer_net->lpn_peer_nis)) {
 427                 list_del_init(&peer_net->lpn_on_peer_list);
 428                 peer_net->lpn_peer = NULL;
 429                 LIBCFS_FREE(peer_net, sizeof(*peer_net));
 430
 431                 /* if the peer is empty then remove it from the
 432                  * the_lnet.ln_peers */
 433                 if (list_empty(&peer->lp_peer_nets)) {
 434                         list_del_init(&peer->lp_on_lnet_peer_list);
 435                         LIBCFS_FREE(peer, sizeof(*peer));
 436                 }
 437         }
 438 }
 439
 440 static int
 441 lnet_build_peer_hierarchy(struct lnet_peer_ni *lpni)
 442 {
 443         struct lnet_peer *peer;
 444         struct lnet_peer_net *peer_net;
 445         __u32 lpni_net = LNET_NIDNET(lpni->lpni_nid);
 446
 447         peer = NULL;
 448         peer_net = NULL;
 449
 450         LIBCFS_ALLOC(peer, sizeof(*peer));
 451         if (peer == NULL)
 452                 return -ENOMEM;
 453
 454         LIBCFS_ALLOC(peer_net, sizeof(*peer_net));
 455         if (peer_net == NULL) {
 456                 LIBCFS_FREE(peer, sizeof(*peer));
 457                 return -ENOMEM;
 458         }
 459
 460         INIT_LIST_HEAD(&peer->lp_on_lnet_peer_list);
 461         INIT_LIST_HEAD(&peer->lp_peer_nets);
 462         INIT_LIST_HEAD(&peer_net->lpn_on_peer_list);
 463         INIT_LIST_HEAD(&peer_net->lpn_peer_nis);
 464
 465         /* build the hierarchy */
 466         peer_net->lpn_net_id = lpni_net;
 467         peer_net->lpn_peer = peer;
 468         lpni->lpni_peer_net = peer_net;
 469         peer->lp_primary_nid = lpni->lpni_nid;
 470         list_add_tail(&peer_net->lpn_on_peer_list, &peer->lp_peer_nets);
 471         list_add_tail(&lpni->lpni_on_peer_net_list, &peer_net->lpn_peer_nis);
 472         list_add_tail(&peer->lp_on_lnet_peer_list, &the_lnet.ln_peers);
 473
 474         return 0;
 475 }
 476
 477 struct lnet_peer_net *
 478 lnet_peer_get_net_locked(struct lnet_peer *peer, __u32 net_id)
 479 {
 480         struct lnet_peer_net *peer_net;
 481         list_for_each_entry(peer_net, &peer->lp_peer_nets, lpn_on_peer_list) {
 482                 if (peer_net->lpn_net_id == net_id)
 483                         return peer_net;
 484         }
 485         return NULL;
 486 }
 487
 488 /*
 489  * given the key nid find the peer to add the new peer NID to. If the key
 490  * nid is NULL, then create a new peer, but first make sure that the NID
 491  * is unique
 492  */
 493 int
 494 lnet_add_peer_ni_to_peer(lnet_nid_t key_nid, lnet_nid_t nid)
 495 {
 496         struct lnet_peer_ni *lpni, *lpni2;
 497         struct lnet_peer *peer;
 498         struct lnet_peer_net *peer_net, *pn;
 499         int cpt, cpt2, rc;
 500         struct lnet_peer_table *ptable = NULL;
 501         __u32 net_id = LNET_NIDNET(nid);
 502
 503         if (nid == LNET_NID_ANY)
 504                 return -EINVAL;
 505
 506         /* check that nid is unique */
 507         cpt = lnet_nid_cpt_hash(nid, LNET_CPT_NUMBER);
 508         lnet_net_lock(cpt);
 509         lpni = lnet_find_peer_ni_locked(nid);
 510         if (lpni != NULL) {
 511                 lnet_peer_ni_decref_locked(lpni);
 512                 lnet_net_unlock(cpt);
 513                 return -EEXIST;
 514         }
 515         lnet_net_unlock(cpt);
 516
 517         if (key_nid != LNET_NID_ANY) {
 518                 cpt2 = lnet_nid_cpt_hash(key_nid, LNET_CPT_NUMBER);
 519                 lnet_net_lock(cpt2);
 520                 lpni = lnet_find_peer_ni_locked(key_nid);
 521                 if (lpni == NULL) {
 522                         lnet_net_unlock(cpt2);
 523                         /* key_nid refers to a non-existant peer_ni.*/
 524                         return -EINVAL;
 525                 }
 526                 peer = lpni->lpni_peer_net->lpn_peer;
 527                 peer->lp_multi_rail = true;
 528                 lnet_peer_ni_decref_locked(lpni);
 529                 lnet_net_unlock(cpt2);
 530         } else {
 531                 lnet_net_lock(LNET_LOCK_EX);
 532                 rc = lnet_nid2peerni_locked(&lpni, nid, LNET_LOCK_EX);
 533                 if (rc == 0) {
 534                         lpni->lpni_peer_net->lpn_peer->lp_multi_rail = true;
 535                         lnet_peer_ni_decref_locked(lpni);
 536                 }
 537                 lnet_net_unlock(LNET_LOCK_EX);
 538                 return rc;
 539         }
 540
 541         lpni = NULL;
 542
 543         LIBCFS_CPT_ALLOC(lpni, lnet_cpt_table(), cpt, sizeof(*lpni));
 544         if (lpni == NULL)
 545                 return -ENOMEM;
 546
 547         INIT_LIST_HEAD(&lpni->lpni_txq);
 548         INIT_LIST_HEAD(&lpni->lpni_rtrq);
 549         INIT_LIST_HEAD(&lpni->lpni_routes);
 550         INIT_LIST_HEAD(&lpni->lpni_hashlist);
 551         INIT_LIST_HEAD(&lpni->lpni_on_peer_net_list);
 552         INIT_LIST_HEAD(&lpni->lpni_on_remote_peer_ni_list);
 553
 554         lpni->lpni_alive = !lnet_peers_start_down(); /* 1 bit!! */
 555         lpni->lpni_last_alive = cfs_time_current(); /* assumes alive */
 556         lpni->lpni_ping_feats = LNET_PING_FEAT_INVAL;
 557         lpni->lpni_nid = nid;
 558         lpni->lpni_cpt = cpt;
 559         lnet_set_peer_ni_health_locked(lpni, true);
 560
 561         /* allocate here in case we need to add a new peer_net */
 562         peer_net = NULL;
 563         LIBCFS_ALLOC(peer_net, sizeof(*peer_net));
 564         if (peer_net == NULL) {
 565                 rc = -ENOMEM;
 566                 if (lpni != NULL)
 567                         LIBCFS_FREE(lpni, sizeof(*lpni));
 568                 return rc;
 569         }
 570
 571         lnet_net_lock(LNET_LOCK_EX);
 572
 573         ptable = the_lnet.ln_peer_tables[cpt];
 574         ptable->pt_number++;
 575
 576         lpni2 = lnet_find_peer_ni_locked(nid);
 577         if (lpni2 != NULL) {
 578                 lnet_peer_ni_decref_locked(lpni2);
 579                 /* sanity check that lpni2's peer is what we expect */
 580                 if (lpni2->lpni_peer_net->lpn_peer != peer)
 581                         rc = -EEXIST;
 582                 else
 583                         rc = -EINVAL;
 584
 585                 ptable->pt_number--;
 586                 /* another thread has already added it */
 587                 lnet_net_unlock(LNET_LOCK_EX);
 588                 LIBCFS_FREE(peer_net, sizeof(*peer_net));
 589                 return rc;
 590         }
 591
 592         lpni->lpni_net = lnet_get_net_locked(LNET_NIDNET(lpni->lpni_nid));
 593         if (lpni->lpni_net != NULL) {
 594                 lpni->lpni_txcredits    =
 595                 lpni->lpni_mintxcredits =
 596                         lpni->lpni_net->net_tunables.lct_peer_tx_credits;
 597                 lpni->lpni_rtrcredits =
 598                 lpni->lpni_minrtrcredits = lnet_peer_buffer_credits(lpni->lpni_net);
 599         } else {
 600                 /*
 601                  * if you're adding a peer which is not on a local network
 602                  * then we can't assign any of the credits. It won't be
 603                  * picked for sending anyway. Eventually a network can be
 604                  * added, in this case we need to revisit this peer and
 605                  * update its credits.
 606                  */
 607
 608                 /* increment refcount for remote peer list */
 609                 atomic_inc(&lpni->lpni_refcount);
 610                 list_add_tail(&lpni->lpni_on_remote_peer_ni_list,
 611                               &the_lnet.ln_remote_peer_ni_list);
 612         }
 613
 614         /* increment refcount for peer on hash list */
 615         atomic_inc(&lpni->lpni_refcount);
 616
 617         list_add_tail(&lpni->lpni_hashlist,
 618                       &ptable->pt_hash[lnet_nid2peerhash(nid)]);
 619         ptable->pt_version++;
 620
 621         /* add the lpni to a net */
 622         list_for_each_entry(pn, &peer->lp_peer_nets, lpn_on_peer_list) {
 623                 if (pn->lpn_net_id == net_id) {
 624                         list_add_tail(&lpni->lpni_on_peer_net_list,
 625                                       &pn->lpn_peer_nis);
 626                         lpni->lpni_peer_net = pn;
 627                         lnet_net_unlock(LNET_LOCK_EX);
 628                         LIBCFS_FREE(peer_net, sizeof(*peer_net));
 629                         return 0;
 630                 }
 631         }
 632
 633         INIT_LIST_HEAD(&peer_net->lpn_on_peer_list);
 634         INIT_LIST_HEAD(&peer_net->lpn_peer_nis);
 635
 636         /* build the hierarchy */
 637         peer_net->lpn_net_id = net_id;
 638         peer_net->lpn_peer = peer;
 639         lpni->lpni_peer_net = peer_net;
 640         list_add_tail(&lpni->lpni_on_peer_net_list, &peer_net->lpn_peer_nis);
 641         list_add_tail(&peer_net->lpn_on_peer_list, &peer->lp_peer_nets);
 642
 643         lnet_net_unlock(LNET_LOCK_EX);
 644         return 0;
 645 }
 646
 647 int
 648 lnet_del_peer_ni_from_peer(lnet_nid_t key_nid, lnet_nid_t nid)
 649 {
 650         int cpt;
 651         lnet_nid_t local_nid;
 652         struct lnet_peer *peer;
 653         struct lnet_peer_ni *lpni, *lpni2;
 654         struct lnet_peer_table *ptable = NULL;
 655
 656         if (key_nid == LNET_NID_ANY)
 657                 return -EINVAL;
 658
 659         local_nid = (nid != LNET_NID_ANY) ? nid : key_nid;
 660         cpt = lnet_nid_cpt_hash(local_nid, LNET_CPT_NUMBER);
 661         lnet_net_lock(LNET_LOCK_EX);
 662
 663         lpni = lnet_find_peer_ni_locked(local_nid);
 664         if (lpni == NULL) {
 665                 lnet_net_unlock(cpt);
 666                 return -EINVAL;
 667         }
 668         lnet_peer_ni_decref_locked(lpni);
 669
 670         peer = lpni->lpni_peer_net->lpn_peer;
 671         LASSERT(peer != NULL);
 672
 673         if (peer->lp_primary_nid == lpni->lpni_nid) {
 674                 /*
 675                  * deleting the primary ni is equivalent to deleting the
 676                  * entire peer
 677                  */
 678                 lpni = NULL;
 679                 lpni = lnet_get_next_peer_ni_locked(peer, NULL, lpni);
 680                 while (lpni != NULL) {
 681                         lpni2 = lnet_get_next_peer_ni_locked(peer, NULL, lpni);
 682                         cpt = lnet_nid_cpt_hash(lpni->lpni_nid,
 683                                                 LNET_CPT_NUMBER);
 684                         lnet_peer_remove_from_remote_list(lpni);
 685                         ptable = the_lnet.ln_peer_tables[cpt];
 686                         ptable->pt_zombies++;
 687                         list_del_init(&lpni->lpni_hashlist);
 688                         lnet_peer_ni_decref_locked(lpni);
 689                         lpni = lpni2;
 690                 }
 691                 lnet_net_unlock(LNET_LOCK_EX);
 692
 693                 return 0;
 694         }
 695
 696         lnet_peer_remove_from_remote_list(lpni);
 697         cpt = lnet_nid_cpt_hash(lpni->lpni_nid, LNET_CPT_NUMBER);
 698         ptable = the_lnet.ln_peer_tables[cpt];
 699         ptable->pt_zombies++;
 700         list_del_init(&lpni->lpni_hashlist);
 701         lnet_peer_ni_decref_locked(lpni);
 702         lnet_net_unlock(LNET_LOCK_EX);
 703
 704         return 0;
 705 }
 706
 707 void
 708 lnet_destroy_peer_ni_locked(struct lnet_peer_ni *lpni)
 709 {
 710         struct lnet_peer_table *ptable;
 711
 712         LASSERT(atomic_read(&lpni->lpni_refcount) == 0);
 713         LASSERT(lpni->lpni_rtr_refcount == 0);
 714         LASSERT(list_empty(&lpni->lpni_txq));
 715         LASSERT(list_empty(&lpni->lpni_hashlist));
 716         LASSERT(lpni->lpni_txqnob == 0);
 717         LASSERT(lpni->lpni_peer_net != NULL);
 718         LASSERT(lpni->lpni_peer_net->lpn_peer != NULL);
 719
 720         ptable = the_lnet.ln_peer_tables[lpni->lpni_cpt];
 721         LASSERT(ptable->pt_number > 0);
 722         ptable->pt_number--;
 723
 724         lpni->lpni_net = NULL;
 725
 726         lnet_try_destroy_peer_hierarchy_locked(lpni);
 727
 728         LIBCFS_FREE(lpni, sizeof(*lpni));
 729
 730         LASSERT(ptable->pt_zombies > 0);
 731         ptable->pt_zombies--;
 732 }
 733
 734 int
 735 lnet_nid2peerni_locked(struct lnet_peer_ni **lpnip, lnet_nid_t nid, int cpt)
 736 {
 737         struct lnet_peer_table  *ptable;
 738         struct lnet_peer_ni     *lpni = NULL;
 739         struct lnet_peer_ni     *lpni2;
 740         int                     cpt2;
 741         int                     rc = 0;
 742
 743         *lpnip = NULL;
 744         if (the_lnet.ln_shutdown) /* it's shutting down */
 745                 return -ESHUTDOWN;
 746
 747         /*
 748          * calculate cpt2 with the standard hash function
 749          * This cpt2 becomes the slot where we'll find or create the peer.
 750          */
 751         cpt2 = lnet_nid_cpt_hash(nid, LNET_CPT_NUMBER);
 752
 753         /*
 754          * Any changes to the peer tables happen under exclusive write
 755          * lock. Any reads to the peer tables can be done via a standard
 756          * CPT read lock.
 757          */
 758         if (cpt != LNET_LOCK_EX) {
 759                 lnet_net_unlock(cpt);
 760                 lnet_net_lock(LNET_LOCK_EX);
 761         }
 762
 763         ptable = the_lnet.ln_peer_tables[cpt2];
 764         lpni = lnet_get_peer_ni_locked(ptable, nid);
 765         if (lpni != NULL) {
 766                 *lpnip = lpni;
 767                 if (cpt != LNET_LOCK_EX) {
 768                         lnet_net_unlock(LNET_LOCK_EX);
 769                         lnet_net_lock(cpt);
 770                 }
 771                 return 0;
 772         }
 773
 774         /*
 775          * take extra refcount in case another thread has shutdown LNet
 776          * and destroyed locks and peer-table before I finish the allocation
 777          */
 778         ptable->pt_number++;
 779         lnet_net_unlock(LNET_LOCK_EX);
 780
 781         LIBCFS_CPT_ALLOC(lpni, lnet_cpt_table(), cpt2, sizeof(*lpni));
 782
 783         if (lpni == NULL) {
 784                 rc = -ENOMEM;
 785                 lnet_net_lock(cpt);
 786                 goto out;
 787         }
 788
 789         INIT_LIST_HEAD(&lpni->lpni_txq);
 790         INIT_LIST_HEAD(&lpni->lpni_rtrq);
 791         INIT_LIST_HEAD(&lpni->lpni_routes);
 792         INIT_LIST_HEAD(&lpni->lpni_hashlist);
 793         INIT_LIST_HEAD(&lpni->lpni_on_peer_net_list);
 794         INIT_LIST_HEAD(&lpni->lpni_on_remote_peer_ni_list);
 795
 796         lpni->lpni_alive = !lnet_peers_start_down(); /* 1 bit!! */
 797         lpni->lpni_last_alive = cfs_time_current(); /* assumes alive */
 798         lpni->lpni_ping_feats = LNET_PING_FEAT_INVAL;
 799         lpni->lpni_nid = nid;
 800         lpni->lpni_cpt = cpt2;
 801         atomic_set(&lpni->lpni_refcount, 2);    /* 1 for caller; 1 for hash */
 802
 803         rc = lnet_build_peer_hierarchy(lpni);
 804         if (rc != 0)
 805                 goto out;
 806
 807         lnet_net_lock(LNET_LOCK_EX);
 808
 809         if (the_lnet.ln_shutdown) {
 810                 rc = -ESHUTDOWN;
 811                 goto out;
 812         }
 813
 814         lpni2 = lnet_get_peer_ni_locked(ptable, nid);
 815         if (lpni2 != NULL) {
 816                 *lpnip = lpni2;
 817                 goto out;
 818         }
 819
 820         lpni->lpni_net = lnet_get_net_locked(LNET_NIDNET(lpni->lpni_nid));
 821         if (lpni->lpni_net) {
 822                 lpni->lpni_txcredits    =
 823                 lpni->lpni_mintxcredits =
 824                         lpni->lpni_net->net_tunables.lct_peer_tx_credits;
 825                 lpni->lpni_rtrcredits    =
 826                 lpni->lpni_minrtrcredits =
 827                         lnet_peer_buffer_credits(lpni->lpni_net);
 828         } else {
 829                 /*
 830                  * if you're adding a peer which is not on a local network
 831                  * then we can't assign any of the credits. It won't be
 832                  * picked for sending anyway. Eventually a network can be
 833                  * added, in this case we need to revisit this peer and
 834                  * update its credits.
 835                  */
 836
 837                 CDEBUG(D_NET, "peer_ni %s is not directly connected\n",
 838                        libcfs_nid2str(nid));
 839                 /* increment refcount for remote peer list */
 840                 atomic_inc(&lpni->lpni_refcount);
 841                 list_add_tail(&lpni->lpni_on_remote_peer_ni_list,
 842                               &the_lnet.ln_remote_peer_ni_list);
 843         }
 844
 845         lnet_set_peer_ni_health_locked(lpni, true);
 846
 847         list_add_tail(&lpni->lpni_hashlist,
 848                         &ptable->pt_hash[lnet_nid2peerhash(nid)]);
 849         ptable->pt_version++;
 850         *lpnip = lpni;
 851
 852         if (cpt != LNET_LOCK_EX) {
 853                 lnet_net_unlock(LNET_LOCK_EX);
 854                 lnet_net_lock(cpt);
 855         }
 856
 857         return 0;
 858 out:
 859         if (lpni != NULL) {
 860                 lnet_try_destroy_peer_hierarchy_locked(lpni);
 861                 LIBCFS_FREE(lpni, sizeof(*lpni));
 862         }
 863         ptable->pt_number--;
 864         if (cpt != LNET_LOCK_EX) {
 865                 lnet_net_unlock(LNET_LOCK_EX);
 866                 lnet_net_lock(cpt);
 867         }
 868         return rc;
 869 }
 870
 871 void
 872 lnet_debug_peer(lnet_nid_t nid)
 873 {
 874         char                    *aliveness = "NA";
 875         struct lnet_peer_ni     *lp;
 876         int                     rc;
 877         int                     cpt;
 878
 879         cpt = lnet_cpt_of_nid(nid, NULL);
 880         lnet_net_lock(cpt);
 881
 882         rc = lnet_nid2peerni_locked(&lp, nid, cpt);
 883         if (rc != 0) {
 884                 lnet_net_unlock(cpt);
 885                 CDEBUG(D_WARNING, "No peer %s\n", libcfs_nid2str(nid));
 886                 return;
 887         }
 888
 889         if (lnet_isrouter(lp) || lnet_peer_aliveness_enabled(lp))
 890                 aliveness = lp->lpni_alive ? "up" : "down";
 891
 892         CDEBUG(D_WARNING, "%-24s %4d %5s %5d %5d %5d %5d %5d %ld\n",
 893                libcfs_nid2str(lp->lpni_nid), atomic_read(&lp->lpni_refcount),
 894                aliveness, lp->lpni_net->net_tunables.lct_peer_tx_credits,
 895                lp->lpni_rtrcredits, lp->lpni_minrtrcredits,
 896                lp->lpni_txcredits, lp->lpni_mintxcredits, lp->lpni_txqnob);
 897
 898         lnet_peer_ni_decref_locked(lp);
 899
 900         lnet_net_unlock(cpt);
 901 }
 902
 903 int lnet_get_peer_ni_info(__u32 peer_index, __u64 *nid,
 904                           char aliveness[LNET_MAX_STR_LEN],
 905                           __u32 *cpt_iter, __u32 *refcount,
 906                           __u32 *ni_peer_tx_credits, __u32 *peer_tx_credits,
 907                           __u32 *peer_rtr_credits, __u32 *peer_min_rtr_credits,
 908                           __u32 *peer_tx_qnob)
 909 {
 910         struct lnet_peer_table          *peer_table;
 911         struct lnet_peer_ni             *lp;
 912         int                             j;
 913         int                             lncpt;
 914         bool                            found = false;
 915
 916         /* get the number of CPTs */
 917         lncpt = cfs_percpt_number(the_lnet.ln_peer_tables);
 918
 919         /* if the cpt number to be examined is >= the number of cpts in
 920          * the system then indicate that there are no more cpts to examin
 921          */
 922         if (*cpt_iter >= lncpt)
 923                 return -ENOENT;
 924
 925         /* get the current table */
 926         peer_table = the_lnet.ln_peer_tables[*cpt_iter];
 927         /* if the ptable is NULL then there are no more cpts to examine */
 928         if (peer_table == NULL)
 929                 return -ENOENT;
 930
 931         lnet_net_lock(*cpt_iter);
 932
 933         for (j = 0; j < LNET_PEER_HASH_SIZE && !found; j++) {
 934                 struct list_head *peers = &peer_table->pt_hash[j];
 935
 936                 list_for_each_entry(lp, peers, lpni_hashlist) {
 937                         if (peer_index-- > 0)
 938                                 continue;
 939
 940                         snprintf(aliveness, LNET_MAX_STR_LEN, "NA");
 941                         if (lnet_isrouter(lp) ||
 942                                 lnet_peer_aliveness_enabled(lp))
 943                                 snprintf(aliveness, LNET_MAX_STR_LEN,
 944                                          lp->lpni_alive ? "up" : "down");
 945
 946                         *nid = lp->lpni_nid;
 947                         *refcount = atomic_read(&lp->lpni_refcount);
 948                         *ni_peer_tx_credits =
 949                                 lp->lpni_net->net_tunables.lct_peer_tx_credits;
 950                         *peer_tx_credits = lp->lpni_txcredits;
 951                         *peer_rtr_credits = lp->lpni_rtrcredits;
 952                         *peer_min_rtr_credits = lp->lpni_mintxcredits;
 953                         *peer_tx_qnob = lp->lpni_txqnob;
 954
 955                         found = true;
 956                 }
 957
 958         }
 959         lnet_net_unlock(*cpt_iter);
 960
 961         *cpt_iter = lncpt;
 962
 963         return found ? 0 : -ENOENT;
 964 }
 965
 966 int lnet_get_peer_info(__u32 idx, lnet_nid_t *primary_nid, lnet_nid_t *nid,
 967                        struct lnet_peer_ni_credit_info *peer_ni_info)
 968 {
 969         struct lnet_peer_ni *lpni = NULL;
 970         struct lnet_peer_net *lpn = NULL;
 971         struct lnet_peer *lp = NULL;
 972
 973         lpni = lnet_get_peer_ni_idx_locked(idx, &lpn, &lp);
 974
 975         if (!lpni)
 976                 return -ENOENT;
 977
 978         *primary_nid = lp->lp_primary_nid;
 979         *nid = lpni->lpni_nid;
 980         snprintf(peer_ni_info->cr_aliveness, LNET_MAX_STR_LEN, "NA");
 981         if (lnet_isrouter(lpni) ||
 982                 lnet_peer_aliveness_enabled(lpni))
 983                 snprintf(peer_ni_info->cr_aliveness, LNET_MAX_STR_LEN,
 984                          lpni->lpni_alive ? "up" : "down");
 985
 986         peer_ni_info->cr_refcount = atomic_read(&lpni->lpni_refcount);
 987         peer_ni_info->cr_ni_peer_tx_credits = (lpni->lpni_net != NULL) ?
 988                 lpni->lpni_net->net_tunables.lct_peer_tx_credits : 0;
 989         peer_ni_info->cr_peer_tx_credits = lpni->lpni_txcredits;
 990         peer_ni_info->cr_peer_rtr_credits = lpni->lpni_rtrcredits;
 991         peer_ni_info->cr_peer_min_rtr_credits = lpni->lpni_mintxcredits;
 992         peer_ni_info->cr_peer_tx_qnob = lpni->lpni_txqnob;
 993
 994         return 0;
 995 }