lnet/ulnds/ptllnd/ptllnd.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/ulnds/ptllnd/ptllnd.c
  37  *
  38  * Author: Eric Barton <eeb@bartonsoftware.com>
  39  */
  40
  41 #include "ptllnd.h"
  42
  43 lnd_t               the_ptllnd = {
  44         .lnd_type       = PTLLND,
  45         .lnd_startup    = ptllnd_startup,
  46         .lnd_shutdown   = ptllnd_shutdown,
  47         .lnd_ctl        = ptllnd_ctl,
  48         .lnd_send       = ptllnd_send,
  49         .lnd_recv       = ptllnd_recv,
  50         .lnd_eager_recv = ptllnd_eager_recv,
  51         .lnd_notify     = ptllnd_notify,
  52         .lnd_wait       = ptllnd_wait,
  53         .lnd_setasync   = ptllnd_setasync,
  54 };
  55
  56 static int ptllnd_ni_count = 0;
  57
  58 static struct list_head ptllnd_idle_history;
  59 static struct list_head ptllnd_history_list;
  60
  61 void
  62 ptllnd_history_fini(void)
  63 {
  64         ptllnd_he_t *he;
  65
  66         while (!list_empty(&ptllnd_idle_history)) {
  67                 he = list_entry(ptllnd_idle_history.next,
  68                                 ptllnd_he_t, he_list);
  69
  70                 list_del(&he->he_list);
  71                 LIBCFS_FREE(he, sizeof(*he));
  72         }
  73
  74         while (!list_empty(&ptllnd_history_list)) {
  75                 he = list_entry(ptllnd_history_list.next,
  76                                 ptllnd_he_t, he_list);
  77
  78                 list_del(&he->he_list);
  79                 LIBCFS_FREE(he, sizeof(*he));
  80         }
  81 }
  82
  83 int
  84 ptllnd_history_init(void)
  85 {
  86         int          i;
  87         ptllnd_he_t *he;
  88         int          n;
  89         int          rc;
  90
  91         CFS_INIT_LIST_HEAD(&ptllnd_idle_history);
  92         CFS_INIT_LIST_HEAD(&ptllnd_history_list);
  93
  94         rc = ptllnd_parse_int_tunable(&n, "PTLLND_HISTORY", 0);
  95         if (rc != 0)
  96                 return rc;
  97
  98         for (i = 0; i < n; i++) {
  99                 LIBCFS_ALLOC(he, sizeof(*he));
 100                 if (he == NULL) {
 101                         ptllnd_history_fini();
 102                         return -ENOMEM;
 103                 }
 104
 105                 list_add(&he->he_list, &ptllnd_idle_history);
 106         }
 107
 108         PTLLND_HISTORY("Init");
 109
 110         return 0;
 111 }
 112
 113 void
 114 ptllnd_history(const char *fn, const char *file, const int line,
 115                const char *fmt, ...)
 116 {
 117         static int     seq;
 118
 119         va_list        ap;
 120         ptllnd_he_t   *he;
 121
 122         if (!list_empty(&ptllnd_idle_history)) {
 123                 he = list_entry(ptllnd_idle_history.next,
 124                                 ptllnd_he_t, he_list);
 125         } else if (!list_empty(&ptllnd_history_list)) {
 126                 he = list_entry(ptllnd_history_list.next,
 127                                 ptllnd_he_t, he_list);
 128         } else {
 129                 return;
 130         }
 131
 132         list_del(&he->he_list);
 133         list_add_tail(&he->he_list, &ptllnd_history_list);
 134
 135         he->he_seq = seq++;
 136         he->he_fn = fn;
 137         he->he_file = file;
 138         he->he_line = line;
 139         gettimeofday(&he->he_time, NULL);
 140
 141         va_start(ap, fmt);
 142         vsnprintf(he->he_msg, sizeof(he->he_msg), fmt, ap);
 143         va_end(ap);
 144 }
 145
 146 void
 147 ptllnd_dump_history(void)
 148 {
 149         ptllnd_he_t    *he;
 150
 151         PTLLND_HISTORY("dumping...");
 152
 153         while (!list_empty(&ptllnd_history_list)) {
 154                 he = list_entry(ptllnd_history_list.next,
 155                                 ptllnd_he_t, he_list);
 156
 157                 list_del(&he->he_list);
 158
 159                 CDEBUG(D_WARNING, "%d %d.%06d (%s:%d:%s()) %s\n", he->he_seq,
 160                        (int)he->he_time.tv_sec, (int)he->he_time.tv_usec,
 161                        he->he_file, he->he_line, he->he_fn, he->he_msg);
 162
 163                 list_add_tail(&he->he_list, &ptllnd_idle_history);
 164         }
 165
 166         PTLLND_HISTORY("complete");
 167 }
 168
 169 void
 170 ptllnd_assert_wire_constants (void)
 171 {
 172         /* Wire protocol assertions generated by 'wirecheck'
 173          * running on Linux fedora 2.6.11-co-0.6.4 #1 Mon Jun 19 05:36:13 UTC 2006 i686 i686 i386 GNU
 174          * with gcc version 4.1.1 20060525 (Red Hat 4.1.1-1) */
 175
 176
 177         /* Constants... */
 178         CLASSERT (PTL_RESERVED_MATCHBITS == 0x100);
 179         CLASSERT (LNET_MSG_MATCHBITS == 0);
 180         CLASSERT (PTLLND_MSG_MAGIC == 0x50746C4E);
 181         CLASSERT (PTLLND_MSG_VERSION == 0x04);
 182         CLASSERT (PTLLND_RDMA_OK == 0x00);
 183         CLASSERT (PTLLND_RDMA_FAIL == 0x01);
 184         CLASSERT (PTLLND_MSG_TYPE_INVALID == 0x00);
 185         CLASSERT (PTLLND_MSG_TYPE_PUT == 0x01);
 186         CLASSERT (PTLLND_MSG_TYPE_GET == 0x02);
 187         CLASSERT (PTLLND_MSG_TYPE_IMMEDIATE == 0x03);
 188         CLASSERT (PTLLND_MSG_TYPE_NOOP == 0x04);
 189         CLASSERT (PTLLND_MSG_TYPE_HELLO == 0x05);
 190         CLASSERT (PTLLND_MSG_TYPE_NAK == 0x06);
 191
 192         /* Checks for struct kptl_msg_t */
 193         CLASSERT ((int)sizeof(kptl_msg_t) == 136);
 194         CLASSERT ((int)offsetof(kptl_msg_t, ptlm_magic) == 0);
 195         CLASSERT ((int)sizeof(((kptl_msg_t *)0)->ptlm_magic) == 4);
 196         CLASSERT ((int)offsetof(kptl_msg_t, ptlm_version) == 4);
 197         CLASSERT ((int)sizeof(((kptl_msg_t *)0)->ptlm_version) == 2);
 198         CLASSERT ((int)offsetof(kptl_msg_t, ptlm_type) == 6);
 199         CLASSERT ((int)sizeof(((kptl_msg_t *)0)->ptlm_type) == 1);
 200         CLASSERT ((int)offsetof(kptl_msg_t, ptlm_credits) == 7);
 201         CLASSERT ((int)sizeof(((kptl_msg_t *)0)->ptlm_credits) == 1);
 202         CLASSERT ((int)offsetof(kptl_msg_t, ptlm_nob) == 8);
 203         CLASSERT ((int)sizeof(((kptl_msg_t *)0)->ptlm_nob) == 4);
 204         CLASSERT ((int)offsetof(kptl_msg_t, ptlm_cksum) == 12);
 205         CLASSERT ((int)sizeof(((kptl_msg_t *)0)->ptlm_cksum) == 4);
 206         CLASSERT ((int)offsetof(kptl_msg_t, ptlm_srcnid) == 16);
 207         CLASSERT ((int)sizeof(((kptl_msg_t *)0)->ptlm_srcnid) == 8);
 208         CLASSERT ((int)offsetof(kptl_msg_t, ptlm_srcstamp) == 24);
 209         CLASSERT ((int)sizeof(((kptl_msg_t *)0)->ptlm_srcstamp) == 8);
 210         CLASSERT ((int)offsetof(kptl_msg_t, ptlm_dstnid) == 32);
 211         CLASSERT ((int)sizeof(((kptl_msg_t *)0)->ptlm_dstnid) == 8);
 212         CLASSERT ((int)offsetof(kptl_msg_t, ptlm_dststamp) == 40);
 213         CLASSERT ((int)sizeof(((kptl_msg_t *)0)->ptlm_dststamp) == 8);
 214         CLASSERT ((int)offsetof(kptl_msg_t, ptlm_srcpid) == 48);
 215         CLASSERT ((int)sizeof(((kptl_msg_t *)0)->ptlm_srcpid) == 4);
 216         CLASSERT ((int)offsetof(kptl_msg_t, ptlm_dstpid) == 52);
 217         CLASSERT ((int)sizeof(((kptl_msg_t *)0)->ptlm_dstpid) == 4);
 218         CLASSERT ((int)offsetof(kptl_msg_t, ptlm_u.immediate) == 56);
 219         CLASSERT ((int)sizeof(((kptl_msg_t *)0)->ptlm_u.immediate) == 72);
 220         CLASSERT ((int)offsetof(kptl_msg_t, ptlm_u.rdma) == 56);
 221         CLASSERT ((int)sizeof(((kptl_msg_t *)0)->ptlm_u.rdma) == 80);
 222         CLASSERT ((int)offsetof(kptl_msg_t, ptlm_u.hello) == 56);
 223         CLASSERT ((int)sizeof(((kptl_msg_t *)0)->ptlm_u.hello) == 12);
 224
 225         /* Checks for struct kptl_immediate_msg_t */
 226         CLASSERT ((int)sizeof(kptl_immediate_msg_t) == 72);
 227         CLASSERT ((int)offsetof(kptl_immediate_msg_t, kptlim_hdr) == 0);
 228         CLASSERT ((int)sizeof(((kptl_immediate_msg_t *)0)->kptlim_hdr) == 72);
 229         CLASSERT ((int)offsetof(kptl_immediate_msg_t, kptlim_payload[13]) == 85);
 230         CLASSERT ((int)sizeof(((kptl_immediate_msg_t *)0)->kptlim_payload[13]) == 1);
 231
 232         /* Checks for struct kptl_rdma_msg_t */
 233         CLASSERT ((int)sizeof(kptl_rdma_msg_t) == 80);
 234         CLASSERT ((int)offsetof(kptl_rdma_msg_t, kptlrm_hdr) == 0);
 235         CLASSERT ((int)sizeof(((kptl_rdma_msg_t *)0)->kptlrm_hdr) == 72);
 236         CLASSERT ((int)offsetof(kptl_rdma_msg_t, kptlrm_matchbits) == 72);
 237         CLASSERT ((int)sizeof(((kptl_rdma_msg_t *)0)->kptlrm_matchbits) == 8);
 238
 239         /* Checks for struct kptl_hello_msg_t */
 240         CLASSERT ((int)sizeof(kptl_hello_msg_t) == 12);
 241         CLASSERT ((int)offsetof(kptl_hello_msg_t, kptlhm_matchbits) == 0);
 242         CLASSERT ((int)sizeof(((kptl_hello_msg_t *)0)->kptlhm_matchbits) == 8);
 243         CLASSERT ((int)offsetof(kptl_hello_msg_t, kptlhm_max_msg_size) == 8);
 244         CLASSERT ((int)sizeof(((kptl_hello_msg_t *)0)->kptlhm_max_msg_size) == 4);
 245 }
 246
 247 int
 248 ptllnd_parse_int_tunable(int *value, char *name, int dflt)
 249 {
 250         char    *env = getenv(name);
 251         char    *end;
 252
 253         if (env == NULL) {
 254                 *value = dflt;
 255                 return 0;
 256         }
 257
 258         *value = strtoull(env, &end, 0);
 259         if (*end == 0)
 260                 return 0;
 261
 262         CERROR("Can't parse tunable %s=%s\n", name, env);
 263         return -EINVAL;
 264 }
 265
 266 int
 267 ptllnd_get_tunables(lnet_ni_t *ni)
 268 {
 269         ptllnd_ni_t *plni = ni->ni_data;
 270         int          max_msg_size;
 271         int          msgs_per_buffer;
 272         int          rc;
 273         int          temp;
 274
 275         /*  Other tunable defaults depend on this */
 276         rc = ptllnd_parse_int_tunable(&plni->plni_debug, "PTLLND_DEBUG", 0);
 277         if (rc != 0)
 278                 return rc;
 279
 280         rc = ptllnd_parse_int_tunable(&plni->plni_portal,
 281                                       "PTLLND_PORTAL", PTLLND_PORTAL);
 282         if (rc != 0)
 283                 return rc;
 284
 285         rc = ptllnd_parse_int_tunable(&temp,
 286                                       "PTLLND_PID", PTLLND_PID);
 287         if (rc != 0)
 288                 return rc;
 289         plni->plni_ptllnd_pid = (ptl_pid_t)temp;
 290
 291         rc = ptllnd_parse_int_tunable(&plni->plni_peer_credits,
 292                                       "PTLLND_PEERCREDITS", PTLLND_PEERCREDITS);
 293         if (rc != 0)
 294                 return rc;
 295         if (plni->plni_peer_credits > PTLLND_MSG_MAX_CREDITS) {
 296                 CERROR("PTLLND_PEERCREDITS must be <= %d\n", PTLLND_MSG_MAX_CREDITS);
 297                 return -EINVAL;
 298         }
 299
 300         rc = ptllnd_parse_int_tunable(&max_msg_size,
 301                                       "PTLLND_MAX_MSG_SIZE",
 302                                       PTLLND_MAX_ULND_MSG_SIZE);
 303         if (rc != 0)
 304                 return rc;
 305
 306         rc = ptllnd_parse_int_tunable(&msgs_per_buffer,
 307                                       "PTLLND_MSGS_PER_BUFFER", 64);
 308         if (rc != 0)
 309                 return rc;
 310
 311         rc = ptllnd_parse_int_tunable(&plni->plni_msgs_spare,
 312                                       "PTLLND_MSGS_SPARE", 256);
 313         if (rc != 0)
 314                 return rc;
 315
 316         rc = ptllnd_parse_int_tunable(&plni->plni_peer_hash_size,
 317                                       "PTLLND_PEER_HASH_SIZE", 101);
 318         if (rc != 0)
 319                 return rc;
 320
 321
 322         rc = ptllnd_parse_int_tunable(&plni->plni_eq_size,
 323                                       "PTLLND_EQ_SIZE", 1024);
 324         if (rc != 0)
 325                 return rc;
 326
 327         rc = ptllnd_parse_int_tunable(&plni->plni_checksum,
 328                                       "PTLLND_CHECKSUM", 0);
 329         if (rc != 0)
 330                 return rc;
 331
 332         rc = ptllnd_parse_int_tunable(&plni->plni_max_tx_history,
 333                                       "PTLLND_TX_HISTORY",
 334                                       plni->plni_debug ? 1024 : 0);
 335         if (rc != 0)
 336                 return rc;
 337
 338         rc = ptllnd_parse_int_tunable(&plni->plni_abort_on_protocol_mismatch,
 339                                       "PTLLND_ABORT_ON_PROTOCOL_MISMATCH", 1);
 340         if (rc != 0)
 341                 return rc;
 342
 343         rc = ptllnd_parse_int_tunable(&plni->plni_abort_on_nak,
 344                                       "PTLLND_ABORT_ON_NAK", 0);
 345         if (rc != 0)
 346                 return rc;
 347
 348         rc = ptllnd_parse_int_tunable(&plni->plni_dump_on_nak,
 349                                       "PTLLND_DUMP_ON_NAK", plni->plni_debug);
 350         if (rc != 0)
 351                 return rc;
 352
 353         rc = ptllnd_parse_int_tunable(&plni->plni_watchdog_interval,
 354                                       "PTLLND_WATCHDOG_INTERVAL", 1);
 355         if (rc != 0)
 356                 return rc;
 357         if (plni->plni_watchdog_interval <= 0)
 358                 plni->plni_watchdog_interval = 1;
 359
 360         rc = ptllnd_parse_int_tunable(&plni->plni_timeout,
 361                                       "PTLLND_TIMEOUT", 50);
 362         if (rc != 0)
 363                 return rc;
 364
 365         rc = ptllnd_parse_int_tunable(&plni->plni_long_wait,
 366                                       "PTLLND_LONG_WAIT",
 367                                       plni->plni_debug ? 5 : plni->plni_timeout);
 368         if (rc != 0)
 369                 return rc;
 370         plni->plni_long_wait *= 1000;           /* convert to mS */
 371
 372         plni->plni_max_msg_size = max_msg_size & ~7;
 373         if (plni->plni_max_msg_size < PTLLND_MIN_BUFFER_SIZE)
 374                 plni->plni_max_msg_size = PTLLND_MIN_BUFFER_SIZE;
 375         CLASSERT ((PTLLND_MIN_BUFFER_SIZE & 7) == 0);
 376         CLASSERT (sizeof(kptl_msg_t) <= PTLLND_MIN_BUFFER_SIZE);
 377
 378         plni->plni_buffer_size = plni->plni_max_msg_size * msgs_per_buffer;
 379
 380         CDEBUG(D_NET, "portal          = %d\n",plni->plni_portal);
 381         CDEBUG(D_NET, "ptllnd_pid      = %d\n",plni->plni_ptllnd_pid);
 382         CDEBUG(D_NET, "max_msg_size    = %d\n",max_msg_size);
 383         CDEBUG(D_NET, "msgs_per_buffer = %d\n",msgs_per_buffer);
 384         CDEBUG(D_NET, "msgs_spare      = %d\n",plni->plni_msgs_spare);
 385         CDEBUG(D_NET, "peer_hash_size  = %d\n",plni->plni_peer_hash_size);
 386         CDEBUG(D_NET, "eq_size         = %d\n",plni->plni_eq_size);
 387         CDEBUG(D_NET, "max_msg_size    = %d\n",plni->plni_max_msg_size);
 388         CDEBUG(D_NET, "buffer_size     = %d\n",plni->plni_buffer_size);
 389
 390         return 0;
 391 }
 392
 393 ptllnd_buffer_t *
 394 ptllnd_create_buffer (lnet_ni_t *ni)
 395 {
 396         ptllnd_ni_t     *plni = ni->ni_data;
 397         ptllnd_buffer_t *buf;
 398
 399         LIBCFS_ALLOC(buf, sizeof(*buf));
 400         if (buf == NULL) {
 401                 CERROR("Can't allocate buffer descriptor\n");
 402                 return NULL;
 403         }
 404
 405         buf->plb_ni = ni;
 406         buf->plb_posted = 0;
 407         CFS_INIT_LIST_HEAD(&buf->plb_list);
 408
 409         LIBCFS_ALLOC(buf->plb_buffer, plni->plni_buffer_size);
 410         if (buf->plb_buffer == NULL) {
 411                 CERROR("Can't allocate buffer size %d\n",
 412                        plni->plni_buffer_size);
 413                 LIBCFS_FREE(buf, sizeof(*buf));
 414                 return NULL;
 415         }
 416
 417         list_add(&buf->plb_list, &plni->plni_buffers);
 418         plni->plni_nbuffers++;
 419
 420         return buf;
 421 }
 422
 423 void
 424 ptllnd_destroy_buffer (ptllnd_buffer_t *buf)
 425 {
 426         ptllnd_ni_t     *plni = buf->plb_ni->ni_data;
 427
 428         LASSERT (!buf->plb_posted);
 429
 430         plni->plni_nbuffers--;
 431         list_del(&buf->plb_list);
 432         LIBCFS_FREE(buf->plb_buffer, plni->plni_buffer_size);
 433         LIBCFS_FREE(buf, sizeof(*buf));
 434 }
 435
 436 int
 437 ptllnd_size_buffers (lnet_ni_t *ni, int delta)
 438 {
 439         ptllnd_ni_t     *plni = ni->ni_data;
 440         ptllnd_buffer_t *buf;
 441         int              nmsgs;
 442         int              nbufs;
 443         int              rc;
 444
 445         CDEBUG(D_NET, "nposted_buffers = %d (before)\n",plni->plni_nposted_buffers);
 446         CDEBUG(D_NET, "nbuffers = %d (before)\n",plni->plni_nbuffers);
 447
 448         plni->plni_nmsgs += delta;
 449         LASSERT(plni->plni_nmsgs >= 0);
 450
 451         nmsgs = plni->plni_nmsgs + plni->plni_msgs_spare;
 452
 453         nbufs = (nmsgs * plni->plni_max_msg_size + plni->plni_buffer_size - 1) /
 454                 plni->plni_buffer_size;
 455
 456         while (nbufs > plni->plni_nbuffers) {
 457                 buf = ptllnd_create_buffer(ni);
 458
 459                 if (buf == NULL)
 460                         return -ENOMEM;
 461
 462                 rc = ptllnd_post_buffer(buf);
 463                 if (rc != 0) {
 464                         /* TODO - this path seems to orpahn the buffer
 465                          * in a state where its not posted and will never be
 466                          * However it does not leak the buffer as it's
 467                          * already been put onto the global buffer list
 468                          * and will be cleaned up
 469                          */
 470                         return rc;
 471                 }
 472         }
 473
 474         CDEBUG(D_NET, "nposted_buffers = %d (after)\n",plni->plni_nposted_buffers);
 475         CDEBUG(D_NET, "nbuffers = %d (after)\n",plni->plni_nbuffers);
 476         return 0;
 477 }
 478
 479 void
 480 ptllnd_destroy_buffers (lnet_ni_t *ni)
 481 {
 482         ptllnd_ni_t       *plni = ni->ni_data;
 483         ptllnd_buffer_t   *buf;
 484         struct list_head  *tmp;
 485         struct list_head  *nxt;
 486
 487         CDEBUG(D_NET, "nposted_buffers = %d (before)\n",plni->plni_nposted_buffers);
 488         CDEBUG(D_NET, "nbuffers = %d (before)\n",plni->plni_nbuffers);
 489
 490         list_for_each_safe(tmp, nxt, &plni->plni_buffers) {
 491                 buf = list_entry(tmp, ptllnd_buffer_t, plb_list);
 492
 493                 //CDEBUG(D_NET, "buf=%p posted=%d\n",buf,buf->plb_posted);
 494
 495                 LASSERT (plni->plni_nbuffers > 0);
 496                 if (buf->plb_posted) {
 497                         time_t   start = cfs_time_current_sec();
 498                         int      w = plni->plni_long_wait;
 499
 500                         LASSERT (plni->plni_nposted_buffers > 0);
 501
 502 #ifdef LUSTRE_PORTALS_UNLINK_SEMANTICS
 503                         (void) PtlMDUnlink(buf->plb_md);
 504
 505                         while (buf->plb_posted) {
 506                                 if (w > 0 && cfs_time_current_sec() > start + w/1000) {
 507                                         CWARN("Waited %ds to unlink buffer\n",
 508                                               (int)(cfs_time_current_sec() - start));
 509                                         w *= 2;
 510                                 }
 511                                 ptllnd_wait(ni, w);
 512                         }
 513 #else
 514                         while (buf->plb_posted) {
 515                                 rc = PtlMDUnlink(buf->plb_md);
 516                                 if (rc == PTL_OK) {
 517                                         buf->plb_posted = 0;
 518                                         plni->plni_nposted_buffers--;
 519                                         break;
 520                                 }
 521                                 LASSERT (rc == PTL_MD_IN_USE);
 522                                 if (w > 0 && cfs_time_current_sec() > start + w/1000) {
 523                                         CWARN("Waited %ds to unlink buffer\n",
 524                                               cfs_time_current_sec() - start);
 525                                         w *= 2;
 526                                 }
 527                                 ptllnd_wait(ni, w);
 528                         }
 529 #endif
 530                 }
 531                 ptllnd_destroy_buffer(buf);
 532         }
 533
 534         CDEBUG(D_NET, "nposted_buffers = %d (after)\n",plni->plni_nposted_buffers);
 535         CDEBUG(D_NET, "nbuffers = %d (after)\n",plni->plni_nbuffers);
 536
 537         LASSERT (plni->plni_nposted_buffers == 0);
 538         LASSERT (plni->plni_nbuffers == 0);
 539 }
 540
 541 int
 542 ptllnd_create_peer_hash (lnet_ni_t *ni)
 543 {
 544         ptllnd_ni_t *plni = ni->ni_data;
 545         int          i;
 546
 547         plni->plni_npeers = 0;
 548
 549         LIBCFS_ALLOC(plni->plni_peer_hash,
 550                      plni->plni_peer_hash_size * sizeof(*plni->plni_peer_hash));
 551         if (plni->plni_peer_hash == NULL) {
 552                 CERROR("Can't allocate ptllnd peer hash (size %d)\n",
 553                        plni->plni_peer_hash_size);
 554                 return -ENOMEM;
 555         }
 556
 557         for (i = 0; i < plni->plni_peer_hash_size; i++)
 558                 CFS_INIT_LIST_HEAD(&plni->plni_peer_hash[i]);
 559
 560         return 0;
 561 }
 562
 563 void
 564 ptllnd_destroy_peer_hash (lnet_ni_t *ni)
 565 {
 566         ptllnd_ni_t    *plni = ni->ni_data;
 567         int             i;
 568
 569         LASSERT( plni->plni_npeers == 0);
 570
 571         for (i = 0; i < plni->plni_peer_hash_size; i++)
 572                 LASSERT (list_empty(&plni->plni_peer_hash[i]));
 573
 574         LIBCFS_FREE(plni->plni_peer_hash,
 575                     plni->plni_peer_hash_size * sizeof(*plni->plni_peer_hash));
 576 }
 577
 578 void
 579 ptllnd_close_peers (lnet_ni_t *ni)
 580 {
 581         ptllnd_ni_t    *plni = ni->ni_data;
 582         ptllnd_peer_t  *plp;
 583         int             i;
 584
 585         for (i = 0; i < plni->plni_peer_hash_size; i++)
 586                 while (!list_empty(&plni->plni_peer_hash[i])) {
 587                         plp = list_entry(plni->plni_peer_hash[i].next,
 588                                          ptllnd_peer_t, plp_list);
 589
 590                         ptllnd_close_peer(plp, 0);
 591                 }
 592 }
 593
 594 int
 595 ptllnd_ctl(lnet_ni_t *ni, unsigned int cmd, void *arg)
 596 {
 597         switch (cmd) {
 598         case IOC_LIBCFS_DEBUG_PEER:
 599                 ptllnd_dump_debug(ni, *((lnet_process_id_t *)arg));
 600                 return 0;
 601
 602         default:
 603                 return -EINVAL;
 604         }
 605 }
 606
 607 __u64
 608 ptllnd_get_timestamp(void)
 609 {
 610         struct timeval  tv;
 611         int             rc = gettimeofday(&tv, NULL);
 612
 613         LASSERT (rc == 0);
 614         return ((__u64)tv.tv_sec) * 1000000 + tv.tv_usec;
 615 }
 616
 617 void
 618 ptllnd_shutdown (lnet_ni_t *ni)
 619 {
 620         ptllnd_ni_t *plni = ni->ni_data;
 621         int          rc;
 622         time_t       start = cfs_time_current_sec();
 623         int          w = plni->plni_long_wait;
 624
 625         LASSERT (ptllnd_ni_count == 1);
 626         plni->plni_max_tx_history = 0;
 627
 628         ptllnd_cull_tx_history(plni);
 629
 630         ptllnd_close_peers(ni);
 631         ptllnd_destroy_buffers(ni);
 632
 633         while (plni->plni_npeers > 0) {
 634                 if (w > 0 && cfs_time_current_sec() > start + w/1000) {
 635                         CWARN("Waited %ds for peers to shutdown\n",
 636                               (int)(cfs_time_current_sec() - start));
 637                         w *= 2;
 638                 }
 639                 ptllnd_wait(ni, w);
 640         }
 641
 642         LASSERT (plni->plni_ntxs == 0);
 643         LASSERT (plni->plni_nrxs == 0);
 644
 645         rc = PtlEQFree(plni->plni_eqh);
 646         LASSERT (rc == PTL_OK);
 647
 648         rc = PtlNIFini(plni->plni_nih);
 649         LASSERT (rc == PTL_OK);
 650
 651         ptllnd_destroy_peer_hash(ni);
 652         LIBCFS_FREE(plni, sizeof(*plni));
 653         ptllnd_ni_count--;
 654 }
 655
 656 int
 657 ptllnd_startup (lnet_ni_t *ni)
 658 {
 659         ptllnd_ni_t *plni;
 660         int          rc;
 661
 662         /* could get limits from portals I guess... */
 663         ni->ni_maxtxcredits =
 664         ni->ni_peertxcredits = 1000;
 665
 666         if (ptllnd_ni_count != 0) {
 667                 CERROR("Can't have > 1 instance of ptllnd\n");
 668                 return -EPERM;
 669         }
 670
 671         ptllnd_ni_count++;
 672
 673         rc = ptllnd_history_init();
 674         if (rc != 0) {
 675                 CERROR("Can't init history\n");
 676                 goto failed0;
 677         }
 678
 679         LIBCFS_ALLOC(plni, sizeof(*plni));
 680         if (plni == NULL) {
 681                 CERROR("Can't allocate ptllnd state\n");
 682                 rc = -ENOMEM;
 683                 goto failed0;
 684         }
 685
 686         ni->ni_data = plni;
 687
 688         plni->plni_stamp = ptllnd_get_timestamp();
 689         plni->plni_nrxs = 0;
 690         plni->plni_ntxs = 0;
 691         plni->plni_ntx_history = 0;
 692         plni->plni_watchdog_peeridx = 0;
 693         plni->plni_watchdog_nextt = cfs_time_current_sec();
 694         CFS_INIT_LIST_HEAD(&plni->plni_zombie_txs);
 695         CFS_INIT_LIST_HEAD(&plni->plni_tx_history);
 696
 697         /*
 698          *  Initilize buffer related data structures
 699          */
 700         CFS_INIT_LIST_HEAD(&plni->plni_buffers);
 701         plni->plni_nbuffers = 0;
 702         plni->plni_nposted_buffers = 0;
 703
 704         rc = ptllnd_get_tunables(ni);
 705         if (rc != 0)
 706                 goto failed1;
 707
 708         rc = ptllnd_create_peer_hash(ni);
 709         if (rc != 0)
 710                 goto failed1;
 711
 712         /* NB I most probably won't get the PID I requested here.  It doesn't
 713          * matter because I don't need a fixed PID (only connection acceptors
 714          * need a "well known" PID). */
 715
 716         rc = PtlNIInit(PTL_IFACE_DEFAULT, plni->plni_ptllnd_pid,
 717                        NULL, NULL, &plni->plni_nih);
 718         if (rc != PTL_OK && rc != PTL_IFACE_DUP) {
 719                 CERROR("PtlNIInit failed: %s(%d)\n",
 720                        ptllnd_errtype2str(rc), rc);
 721                 rc = -ENODEV;
 722                 goto failed2;
 723         }
 724
 725         rc = PtlEQAlloc(plni->plni_nih, plni->plni_eq_size,
 726                         PTL_EQ_HANDLER_NONE, &plni->plni_eqh);
 727         if (rc != PTL_OK) {
 728                 CERROR("PtlEQAlloc failed: %s(%d)\n",
 729                        ptllnd_errtype2str(rc), rc);
 730                 rc = -ENODEV;
 731                 goto failed3;
 732         }
 733
 734         /*
 735          * Fetch the Portals NID
 736          */
 737         rc = PtlGetId(plni->plni_nih, &plni->plni_portals_id);
 738         if (rc != PTL_OK) {
 739                 CERROR ("PtlGetID failed : %s(%d)\n",
 740                         ptllnd_errtype2str(rc), rc);
 741                 rc = -EINVAL;
 742                 goto failed4;
 743         }
 744
 745         /*
 746          * Create the new NID.  Based on the LND network type
 747          * and the lower ni's address data.
 748          */
 749         ni->ni_nid = ptllnd_ptl2lnetnid(ni, plni->plni_portals_id.nid);
 750
 751         CDEBUG(D_NET, "ptl id  =%s\n", ptllnd_ptlid2str(plni->plni_portals_id));
 752         CDEBUG(D_NET, "lnet id =%s (passed back)\n",
 753                libcfs_id2str((lnet_process_id_t) {
 754                        .nid = ni->ni_nid, .pid = the_lnet.ln_pid}));
 755
 756         rc = ptllnd_size_buffers(ni, 0);
 757         if (rc != 0)
 758                 goto failed4;
 759
 760         return 0;
 761
 762  failed4:
 763         ptllnd_destroy_buffers(ni);
 764         PtlEQFree(plni->plni_eqh);
 765  failed3:
 766         PtlNIFini(plni->plni_nih);
 767  failed2:
 768         ptllnd_destroy_peer_hash(ni);
 769  failed1:
 770         LIBCFS_FREE(plni, sizeof(*plni));
 771  failed0:
 772         ptllnd_history_fini();
 773         ptllnd_ni_count--;
 774         CDEBUG(D_NET, "<<< rc=%d\n",rc);
 775         return rc;
 776 }
 777
 778 const char *ptllnd_evtype2str(int type)
 779 {
 780 #define DO_TYPE(x) case x: return #x;
 781         switch(type)
 782         {
 783                 DO_TYPE(PTL_EVENT_GET_START);
 784                 DO_TYPE(PTL_EVENT_GET_END);
 785                 DO_TYPE(PTL_EVENT_PUT_START);
 786                 DO_TYPE(PTL_EVENT_PUT_END);
 787                 DO_TYPE(PTL_EVENT_REPLY_START);
 788                 DO_TYPE(PTL_EVENT_REPLY_END);
 789                 DO_TYPE(PTL_EVENT_ACK);
 790                 DO_TYPE(PTL_EVENT_SEND_START);
 791                 DO_TYPE(PTL_EVENT_SEND_END);
 792                 DO_TYPE(PTL_EVENT_UNLINK);
 793         default:
 794                 return "<unknown event type>";
 795         }
 796 #undef DO_TYPE
 797 }
 798
 799 const char *ptllnd_msgtype2str(int type)
 800 {
 801 #define DO_TYPE(x) case x: return #x;
 802         switch(type)
 803         {
 804                 DO_TYPE(PTLLND_MSG_TYPE_INVALID);
 805                 DO_TYPE(PTLLND_MSG_TYPE_PUT);
 806                 DO_TYPE(PTLLND_MSG_TYPE_GET);
 807                 DO_TYPE(PTLLND_MSG_TYPE_IMMEDIATE);
 808                 DO_TYPE(PTLLND_MSG_TYPE_HELLO);
 809                 DO_TYPE(PTLLND_MSG_TYPE_NOOP);
 810                 DO_TYPE(PTLLND_MSG_TYPE_NAK);
 811         default:
 812                 return "<unknown msg type>";
 813         }
 814 #undef DO_TYPE
 815 }
 816
 817 const char *ptllnd_errtype2str(int type)
 818 {
 819 #define DO_TYPE(x) case x: return #x;
 820         switch(type)
 821         {
 822                 DO_TYPE(PTL_OK);
 823                 DO_TYPE(PTL_SEGV);
 824                 DO_TYPE(PTL_NO_SPACE);
 825                 DO_TYPE(PTL_ME_IN_USE);
 826                 DO_TYPE(PTL_NAL_FAILED);
 827                 DO_TYPE(PTL_NO_INIT);
 828                 DO_TYPE(PTL_IFACE_DUP);
 829                 DO_TYPE(PTL_IFACE_INVALID);
 830                 DO_TYPE(PTL_HANDLE_INVALID);
 831                 DO_TYPE(PTL_MD_INVALID);
 832                 DO_TYPE(PTL_ME_INVALID);
 833                 DO_TYPE(PTL_PROCESS_INVALID);
 834                 DO_TYPE(PTL_PT_INDEX_INVALID);
 835                 DO_TYPE(PTL_SR_INDEX_INVALID);
 836                 DO_TYPE(PTL_EQ_INVALID);
 837                 DO_TYPE(PTL_EQ_DROPPED);
 838                 DO_TYPE(PTL_EQ_EMPTY);
 839                 DO_TYPE(PTL_MD_NO_UPDATE);
 840                 DO_TYPE(PTL_FAIL);
 841                 DO_TYPE(PTL_AC_INDEX_INVALID);
 842                 DO_TYPE(PTL_MD_ILLEGAL);
 843                 DO_TYPE(PTL_ME_LIST_TOO_LONG);
 844                 DO_TYPE(PTL_MD_IN_USE);
 845                 DO_TYPE(PTL_NI_INVALID);
 846                 DO_TYPE(PTL_PID_INVALID);
 847                 DO_TYPE(PTL_PT_FULL);
 848                 DO_TYPE(PTL_VAL_FAILED);
 849                 DO_TYPE(PTL_NOT_IMPLEMENTED);
 850                 DO_TYPE(PTL_NO_ACK);
 851                 DO_TYPE(PTL_EQ_IN_USE);
 852                 DO_TYPE(PTL_PID_IN_USE);
 853                 DO_TYPE(PTL_INV_EQ_SIZE);
 854                 DO_TYPE(PTL_AGAIN);
 855         default:
 856                 return "<unknown error type>";
 857         }
 858 #undef DO_TYPE
 859 }