drivers/staging/lustre/lnet/klnds/o2iblnd/o2iblnd.h

   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.sun.com/software/products/lustre/docs/GPLv2.pdf
  19  *
  20  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  21  * CA 95054 USA or visit www.sun.com if you need additional information or
  22  * have any questions.
  23  *
  24  * GPL HEADER END
  25  */
  26 /*
  27  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
  28  * Use is subject to license terms.
  29  *
  30  * Copyright (c) 2011, 2012, Intel Corporation.
  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/klnds/o2iblnd/o2iblnd.h
  37  *
  38  * Author: Eric Barton <eric@bartonsoftware.com>
  39  */
  40
  41 #include <linux/module.h>
  42 #include <linux/kernel.h>
  43 #include <linux/mm.h>
  44 #include <linux/string.h>
  45 #include <linux/stat.h>
  46 #include <linux/errno.h>
  47 #include <linux/unistd.h>
  48 #include <linux/uio.h>
  49 #include <linux/uaccess.h>
  50
  51 #include <linux/io.h>
  52
  53 #include <linux/fs.h>
  54 #include <linux/file.h>
  55 #include <linux/list.h>
  56 #include <linux/kmod.h>
  57 #include <linux/sysctl.h>
  58 #include <linux/pci.h>
  59
  60 #include <net/sock.h>
  61 #include <linux/in.h>
  62
  63 #define DEBUG_SUBSYSTEM S_LND
  64
  65 #include "../../../include/linux/libcfs/libcfs.h"
  66 #include "../../../include/linux/lnet/lnet.h"
  67 #include "../../../include/linux/lnet/lib-lnet.h"
  68
  69 #include <rdma/rdma_cm.h>
  70 #include <rdma/ib_cm.h>
  71 #include <rdma/ib_verbs.h>
  72 #include <rdma/ib_fmr_pool.h>
  73
  74 #define IBLND_PEER_HASH_SIZE            101     /* # peer lists */
  75 /* # scheduler loops before reschedule */
  76 #define IBLND_RESCHED                   100
  77
  78 #define IBLND_N_SCHED                   2
  79 #define IBLND_N_SCHED_HIGH              4
  80
  81 typedef struct {
  82         int *kib_dev_failover;           /* HCA failover */
  83         unsigned int *kib_service;       /* IB service number */
  84         int *kib_min_reconnect_interval; /* first failed connection retry... */
  85         int *kib_max_reconnect_interval; /* exponentially increasing to this */
  86         int *kib_cksum;                  /* checksum kib_msg_t? */
  87         int *kib_timeout;                /* comms timeout (seconds) */
  88         int *kib_keepalive;              /* keepalive timeout (seconds) */
  89         int *kib_ntx;                    /* # tx descs */
  90         int *kib_credits;                /* # concurrent sends */
  91         int *kib_peertxcredits;          /* # concurrent sends to 1 peer */
  92         int *kib_peerrtrcredits;         /* # per-peer router buffer credits */
  93         int *kib_peercredits_hiw;        /* # when eagerly to return credits */
  94         int *kib_peertimeout;            /* seconds to consider peer dead */
  95         char **kib_default_ipif;         /* default IPoIB interface */
  96         int *kib_retry_count;
  97         int *kib_rnr_retry_count;
  98         int *kib_concurrent_sends;       /* send work queue sizing */
  99         int *kib_ib_mtu;                 /* IB MTU */
 100         int *kib_map_on_demand;          /* map-on-demand if RD has more */
 101                                          /* fragments than this value, 0 */
 102                                          /* disable map-on-demand */
 103         int *kib_fmr_pool_size;          /* # FMRs in pool */
 104         int *kib_fmr_flush_trigger;      /* When to trigger FMR flush */
 105         int *kib_fmr_cache;              /* enable FMR pool cache? */
 106         int *kib_require_priv_port;      /* accept only privileged ports */
 107         int *kib_use_priv_port; /* use privileged port for active connect */
 108         int *kib_nscheds;                /* # threads on each CPT */
 109 } kib_tunables_t;
 110
 111 extern kib_tunables_t  kiblnd_tunables;
 112
 113 #define IBLND_MSG_QUEUE_SIZE_V1   8 /* V1 only : # messages/RDMAs in-flight */
 114 #define IBLND_CREDIT_HIGHWATER_V1 7 /* V1 only : when eagerly to return credits */
 115
 116 #define IBLND_CREDITS_DEFAULT     8 /* default # of peer credits */
 117 #define IBLND_CREDITS_MAX         ((typeof(((kib_msg_t *) 0)->ibm_credits)) - 1)  /* Max # of peer credits */
 118
 119 #define IBLND_MSG_QUEUE_SIZE(v)    ((v) == IBLND_MSG_VERSION_1 ? \
 120                                      IBLND_MSG_QUEUE_SIZE_V1 :   \
 121                                      *kiblnd_tunables.kib_peertxcredits) /* # messages/RDMAs in-flight */
 122 #define IBLND_CREDITS_HIGHWATER(v) ((v) == IBLND_MSG_VERSION_1 ? \
 123                                      IBLND_CREDIT_HIGHWATER_V1 : \
 124                                      *kiblnd_tunables.kib_peercredits_hiw) /* when eagerly to return credits */
 125
 126 #define kiblnd_rdma_create_id(cb, dev, ps, qpt) rdma_create_id(&init_net, \
 127                                                                cb, dev, \
 128                                                                ps, qpt)
 129
 130 static inline int
 131 kiblnd_concurrent_sends_v1(void)
 132 {
 133         if (*kiblnd_tunables.kib_concurrent_sends > IBLND_MSG_QUEUE_SIZE_V1 * 2)
 134                 return IBLND_MSG_QUEUE_SIZE_V1 * 2;
 135
 136         if (*kiblnd_tunables.kib_concurrent_sends < IBLND_MSG_QUEUE_SIZE_V1 / 2)
 137                 return IBLND_MSG_QUEUE_SIZE_V1 / 2;
 138
 139         return *kiblnd_tunables.kib_concurrent_sends;
 140 }
 141
 142 #define IBLND_CONCURRENT_SENDS(v)  ((v) == IBLND_MSG_VERSION_1 ? \
 143                                      kiblnd_concurrent_sends_v1() : \
 144                                      *kiblnd_tunables.kib_concurrent_sends)
 145 /* 2 OOB shall suffice for 1 keepalive and 1 returning credits */
 146 #define IBLND_OOB_CAPABLE(v)       ((v) != IBLND_MSG_VERSION_1)
 147 #define IBLND_OOB_MSGS(v)          (IBLND_OOB_CAPABLE(v) ? 2 : 0)
 148
 149 #define IBLND_MSG_SIZE        (4<<10)            /* max size of queued messages (inc hdr) */
 150 #define IBLND_MAX_RDMA_FRAGS     LNET_MAX_IOV      /* max # of fragments supported */
 151 #define IBLND_CFG_RDMA_FRAGS       (*kiblnd_tunables.kib_map_on_demand != 0 ? \
 152                                     *kiblnd_tunables.kib_map_on_demand :      \
 153                                      IBLND_MAX_RDMA_FRAGS)  /* max # of fragments configured by user */
 154 #define IBLND_RDMA_FRAGS(v)     ((v) == IBLND_MSG_VERSION_1 ? \
 155                                      IBLND_MAX_RDMA_FRAGS : IBLND_CFG_RDMA_FRAGS)
 156
 157 /************************/
 158 /* derived constants... */
 159 /* Pools (shared by connections on each CPT) */
 160 /* These pools can grow at runtime, so don't need give a very large value */
 161 #define IBLND_TX_POOL                   256
 162 #define IBLND_FMR_POOL                  256
 163 #define IBLND_FMR_POOL_FLUSH            192
 164
 165 /* TX messages (shared by all connections) */
 166 #define IBLND_TX_MSGS()     (*kiblnd_tunables.kib_ntx)
 167
 168 /* RX messages (per connection) */
 169 #define IBLND_RX_MSGS(v)            (IBLND_MSG_QUEUE_SIZE(v) * 2 + IBLND_OOB_MSGS(v))
 170 #define IBLND_RX_MSG_BYTES(v)       (IBLND_RX_MSGS(v) * IBLND_MSG_SIZE)
 171 #define IBLND_RX_MSG_PAGES(v)      ((IBLND_RX_MSG_BYTES(v) + PAGE_SIZE - 1) / PAGE_SIZE)
 172
 173 /* WRs and CQEs (per connection) */
 174 #define IBLND_RECV_WRS(v)           IBLND_RX_MSGS(v)
 175 #define IBLND_SEND_WRS(v)         ((IBLND_RDMA_FRAGS(v) + 1) * IBLND_CONCURRENT_SENDS(v))
 176 #define IBLND_CQ_ENTRIES(v)      (IBLND_RECV_WRS(v) + IBLND_SEND_WRS(v))
 177
 178 struct kib_hca_dev;
 179
 180 /* o2iblnd can run over aliased interface */
 181 #ifdef IFALIASZ
 182 #define KIB_IFNAME_SIZE       IFALIASZ
 183 #else
 184 #define KIB_IFNAME_SIZE       256
 185 #endif
 186
 187 typedef struct {
 188         struct list_head   ibd_list;            /* chain on kib_devs */
 189         struct list_head   ibd_fail_list;       /* chain on kib_failed_devs */
 190         __u32              ibd_ifip;            /* IPoIB interface IP */
 191
 192         /* IPoIB interface name */
 193         char               ibd_ifname[KIB_IFNAME_SIZE];
 194         int                ibd_nnets;           /* # nets extant */
 195
 196         unsigned long      ibd_next_failover;
 197         int                ibd_failed_failover; /* # failover failures */
 198         unsigned int       ibd_failover;        /* failover in progress */
 199         unsigned int ibd_can_failover; /* IPoIB interface is a bonding master */
 200         struct list_head   ibd_nets;
 201         struct kib_hca_dev *ibd_hdev;
 202 } kib_dev_t;
 203
 204 typedef struct kib_hca_dev {
 205         struct rdma_cm_id  *ibh_cmid;           /* listener cmid */
 206         struct ib_device   *ibh_ibdev;          /* IB device */
 207         int                ibh_page_shift;      /* page shift of current HCA */
 208         int                ibh_page_size;       /* page size of current HCA */
 209         __u64              ibh_page_mask;       /* page mask of current HCA */
 210         int                ibh_mr_shift;        /* bits shift of max MR size */
 211         __u64              ibh_mr_size;         /* size of MR */
 212         int                ibh_nmrs;            /* # of global MRs */
 213         struct ib_mr       **ibh_mrs;           /* global MR */
 214         struct ib_pd       *ibh_pd;             /* PD */
 215         kib_dev_t          *ibh_dev;            /* owner */
 216         atomic_t           ibh_ref;             /* refcount */
 217 } kib_hca_dev_t;
 218
 219 /** # of seconds to keep pool alive */
 220 #define IBLND_POOL_DEADLINE     300
 221 /** # of seconds to retry if allocation failed */
 222 #define IBLND_POOL_RETRY        1
 223
 224 typedef struct {
 225         int                ibp_npages;          /* # pages */
 226         struct page        *ibp_pages[0];       /* page array */
 227 } kib_pages_t;
 228
 229 struct kib_pool;
 230 struct kib_poolset;
 231
 232 typedef int  (*kib_ps_pool_create_t)(struct kib_poolset *ps,
 233                                      int inc, struct kib_pool **pp_po);
 234 typedef void (*kib_ps_pool_destroy_t)(struct kib_pool *po);
 235 typedef void (*kib_ps_node_init_t)(struct kib_pool *po, struct list_head *node);
 236 typedef void (*kib_ps_node_fini_t)(struct kib_pool *po, struct list_head *node);
 237
 238 struct kib_net;
 239
 240 #define IBLND_POOL_NAME_LEN     32
 241
 242 typedef struct kib_poolset {
 243         spinlock_t            ps_lock;            /* serialize */
 244         struct kib_net        *ps_net;            /* network it belongs to */
 245         char                  ps_name[IBLND_POOL_NAME_LEN]; /* pool set name */
 246         struct list_head      ps_pool_list;       /* list of pools */
 247         struct list_head      ps_failed_pool_list;/* failed pool list */
 248         unsigned long         ps_next_retry;      /* time stamp for retry if */
 249                                                   /* failed to allocate */
 250         int                   ps_increasing;      /* is allocating new pool */
 251         int                   ps_pool_size;       /* new pool size */
 252         int                   ps_cpt;             /* CPT id */
 253
 254         kib_ps_pool_create_t  ps_pool_create;     /* create a new pool */
 255         kib_ps_pool_destroy_t ps_pool_destroy;    /* destroy a pool */
 256         kib_ps_node_init_t    ps_node_init; /* initialize new allocated node */
 257         kib_ps_node_fini_t    ps_node_fini;       /* finalize node */
 258 } kib_poolset_t;
 259
 260 typedef struct kib_pool {
 261         struct list_head      po_list;       /* chain on pool list */
 262         struct list_head      po_free_list;  /* pre-allocated node */
 263         kib_poolset_t         *po_owner;     /* pool_set of this pool */
 264         unsigned long         po_deadline;   /* deadline of this pool */
 265         int                   po_allocated;  /* # of elements in use */
 266         int                   po_failed;     /* pool is created on failed HCA */
 267         int                   po_size;       /* # of pre-allocated elements */
 268 } kib_pool_t;
 269
 270 typedef struct {
 271         kib_poolset_t         tps_poolset;        /* pool-set */
 272         __u64                 tps_next_tx_cookie; /* cookie of TX */
 273 } kib_tx_poolset_t;
 274
 275 typedef struct {
 276         kib_pool_t            tpo_pool;           /* pool */
 277         struct kib_hca_dev    *tpo_hdev;          /* device for this pool */
 278         struct kib_tx         *tpo_tx_descs;      /* all the tx descriptors */
 279         kib_pages_t           *tpo_tx_pages;      /* premapped tx msg pages */
 280 } kib_tx_pool_t;
 281
 282 typedef struct {
 283         spinlock_t            fps_lock;            /* serialize */
 284         struct kib_net        *fps_net;            /* IB network */
 285         struct list_head      fps_pool_list;       /* FMR pool list */
 286         struct list_head      fps_failed_pool_list;/* FMR pool list */
 287         __u64                 fps_version;         /* validity stamp */
 288         int                   fps_cpt;             /* CPT id */
 289         int                   fps_pool_size;
 290         int                   fps_flush_trigger;
 291         int                   fps_increasing;      /* is allocating new pool */
 292         unsigned long         fps_next_retry;      /* time stamp for retry if*/
 293                                                    /* failed to allocate */
 294 } kib_fmr_poolset_t;
 295
 296 typedef struct {
 297         struct list_head      fpo_list;            /* chain on pool list */
 298         struct kib_hca_dev    *fpo_hdev;           /* device for this pool */
 299         kib_fmr_poolset_t     *fpo_owner;          /* owner of this pool */
 300         struct ib_fmr_pool    *fpo_fmr_pool;       /* IB FMR pool */
 301         unsigned long         fpo_deadline;        /* deadline of this pool */
 302         int                   fpo_failed;          /* fmr pool is failed */
 303         int                   fpo_map_count;       /* # of mapped FMR */
 304 } kib_fmr_pool_t;
 305
 306 typedef struct {
 307         struct ib_pool_fmr    *fmr_pfmr;           /* IB pool fmr */
 308         kib_fmr_pool_t        *fmr_pool;           /* pool of FMR */
 309 } kib_fmr_t;
 310
 311 typedef struct kib_net {
 312         struct list_head      ibn_list;       /* chain on kib_dev_t::ibd_nets */
 313         __u64                 ibn_incarnation;/* my epoch */
 314         int                   ibn_init;       /* initialisation state */
 315         int                   ibn_shutdown;   /* shutting down? */
 316
 317         atomic_t              ibn_npeers;     /* # peers extant */
 318         atomic_t              ibn_nconns;     /* # connections extant */
 319
 320         kib_tx_poolset_t      **ibn_tx_ps;    /* tx pool-set */
 321         kib_fmr_poolset_t     **ibn_fmr_ps;   /* fmr pool-set */
 322
 323         kib_dev_t             *ibn_dev;       /* underlying IB device */
 324 } kib_net_t;
 325
 326 #define KIB_THREAD_SHIFT                16
 327 #define KIB_THREAD_ID(cpt, tid)         ((cpt) << KIB_THREAD_SHIFT | (tid))
 328 #define KIB_THREAD_CPT(id)              ((id) >> KIB_THREAD_SHIFT)
 329 #define KIB_THREAD_TID(id)              ((id) & ((1UL << KIB_THREAD_SHIFT) - 1))
 330
 331 struct kib_sched_info {
 332         spinlock_t         ibs_lock;     /* serialise */
 333         wait_queue_head_t  ibs_waitq;    /* schedulers sleep here */
 334         struct list_head   ibs_conns;    /* conns to check for rx completions */
 335         int                ibs_nthreads; /* number of scheduler threads */
 336         int                ibs_nthreads_max; /* max allowed scheduler threads */
 337         int                ibs_cpt;      /* CPT id */
 338 };
 339
 340 typedef struct {
 341         int               kib_init;           /* initialisation state */
 342         int               kib_shutdown;       /* shut down? */
 343         struct list_head  kib_devs;           /* IB devices extant */
 344         struct list_head  kib_failed_devs;    /* list head of failed devices */
 345         wait_queue_head_t kib_failover_waitq; /* schedulers sleep here */
 346         atomic_t kib_nthreads;                /* # live threads */
 347         rwlock_t kib_global_lock;    /* stabilize net/dev/peer/conn ops */
 348         struct list_head *kib_peers; /* hash table of all my known peers */
 349         int  kib_peer_hash_size;     /* size of kib_peers */
 350         void *kib_connd; /* the connd task (serialisation assertions) */
 351         struct list_head kib_connd_conns;   /* connections to setup/teardown */
 352         struct list_head kib_connd_zombies; /* connections with zero refcount */
 353         wait_queue_head_t kib_connd_waitq;  /* connection daemon sleeps here */
 354         spinlock_t kib_connd_lock;          /* serialise */
 355         struct ib_qp_attr kib_error_qpa;    /* QP->ERROR */
 356         struct kib_sched_info **kib_scheds; /* percpt data for schedulers */
 357 } kib_data_t;
 358
 359 #define IBLND_INIT_NOTHING 0
 360 #define IBLND_INIT_DATA    1
 361 #define IBLND_INIT_ALL     2
 362
 363 /************************************************************************
 364  * IB Wire message format.
 365  * These are sent in sender's byte order (i.e. receiver flips).
 366  */
 367
 368 typedef struct kib_connparams {
 369         __u16        ibcp_queue_depth;
 370         __u16        ibcp_max_frags;
 371         __u32        ibcp_max_msg_size;
 372 } WIRE_ATTR kib_connparams_t;
 373
 374 typedef struct {
 375         lnet_hdr_t   ibim_hdr;        /* portals header */
 376         char         ibim_payload[0]; /* piggy-backed payload */
 377 } WIRE_ATTR kib_immediate_msg_t;
 378
 379 typedef struct {
 380         __u32        rf_nob;          /* # bytes this frag */
 381         __u64        rf_addr;         /* CAVEAT EMPTOR: misaligned!! */
 382 } WIRE_ATTR kib_rdma_frag_t;
 383
 384 typedef struct {
 385         __u32           rd_key;       /* local/remote key */
 386         __u32           rd_nfrags;    /* # fragments */
 387         kib_rdma_frag_t rd_frags[0];  /* buffer frags */
 388 } WIRE_ATTR kib_rdma_desc_t;
 389
 390 typedef struct {
 391         lnet_hdr_t      ibprm_hdr;    /* portals header */
 392         __u64           ibprm_cookie; /* opaque completion cookie */
 393 } WIRE_ATTR kib_putreq_msg_t;
 394
 395 typedef struct {
 396         __u64           ibpam_src_cookie; /* reflected completion cookie */
 397         __u64           ibpam_dst_cookie; /* opaque completion cookie */
 398         kib_rdma_desc_t ibpam_rd;         /* sender's sink buffer */
 399 } WIRE_ATTR kib_putack_msg_t;
 400
 401 typedef struct {
 402         lnet_hdr_t      ibgm_hdr;     /* portals header */
 403         __u64           ibgm_cookie;  /* opaque completion cookie */
 404         kib_rdma_desc_t ibgm_rd;      /* rdma descriptor */
 405 } WIRE_ATTR kib_get_msg_t;
 406
 407 typedef struct {
 408         __u64           ibcm_cookie;  /* opaque completion cookie */
 409         __s32           ibcm_status;  /* < 0 failure: >= 0 length */
 410 } WIRE_ATTR kib_completion_msg_t;
 411
 412 typedef struct {
 413         /* First 2 fields fixed FOR ALL TIME */
 414         __u32           ibm_magic;    /* I'm an ibnal message */
 415         __u16           ibm_version;  /* this is my version number */
 416
 417         __u8            ibm_type;     /* msg type */
 418         __u8            ibm_credits;  /* returned credits */
 419         __u32           ibm_nob;      /* # bytes in whole message */
 420         __u32           ibm_cksum;    /* checksum (0 == no checksum) */
 421         __u64           ibm_srcnid;   /* sender's NID */
 422         __u64           ibm_srcstamp; /* sender's incarnation */
 423         __u64           ibm_dstnid;   /* destination's NID */
 424         __u64           ibm_dststamp; /* destination's incarnation */
 425
 426         union {
 427                 kib_connparams_t     connparams;
 428                 kib_immediate_msg_t  immediate;
 429                 kib_putreq_msg_t     putreq;
 430                 kib_putack_msg_t     putack;
 431                 kib_get_msg_t        get;
 432                 kib_completion_msg_t completion;
 433         } WIRE_ATTR ibm_u;
 434 } WIRE_ATTR kib_msg_t;
 435
 436 #define IBLND_MSG_MAGIC     LNET_PROTO_IB_MAGIC /* unique magic */
 437
 438 #define IBLND_MSG_VERSION_1 0x11
 439 #define IBLND_MSG_VERSION_2 0x12
 440 #define IBLND_MSG_VERSION   IBLND_MSG_VERSION_2
 441
 442 #define IBLND_MSG_CONNREQ   0xc0        /* connection request */
 443 #define IBLND_MSG_CONNACK   0xc1        /* connection acknowledge */
 444 #define IBLND_MSG_NOOP      0xd0        /* nothing (just credits) */
 445 #define IBLND_MSG_IMMEDIATE 0xd1        /* immediate */
 446 #define IBLND_MSG_PUT_REQ   0xd2        /* putreq (src->sink) */
 447 #define IBLND_MSG_PUT_NAK   0xd3        /* completion (sink->src) */
 448 #define IBLND_MSG_PUT_ACK   0xd4        /* putack (sink->src) */
 449 #define IBLND_MSG_PUT_DONE  0xd5        /* completion (src->sink) */
 450 #define IBLND_MSG_GET_REQ   0xd6        /* getreq (sink->src) */
 451 #define IBLND_MSG_GET_DONE  0xd7        /* completion (src->sink: all OK) */
 452
 453 typedef struct {
 454         __u32            ibr_magic;       /* sender's magic */
 455         __u16            ibr_version;     /* sender's version */
 456         __u8             ibr_why;         /* reject reason */
 457         __u8             ibr_padding;     /* padding */
 458         __u64            ibr_incarnation; /* incarnation of peer */
 459         kib_connparams_t ibr_cp;          /* connection parameters */
 460 } WIRE_ATTR kib_rej_t;
 461
 462 /* connection rejection reasons */
 463 #define IBLND_REJECT_CONN_RACE      1 /* You lost connection race */
 464 #define IBLND_REJECT_NO_RESOURCES   2 /* Out of memory/conns etc */
 465 #define IBLND_REJECT_FATAL          3 /* Anything else */
 466 #define IBLND_REJECT_CONN_UNCOMPAT  4 /* incompatible version peer */
 467 #define IBLND_REJECT_CONN_STALE     5 /* stale peer */
 468 #define IBLND_REJECT_RDMA_FRAGS     6 /* Fatal: peer's rdma frags can't match */
 469                                       /* mine */
 470 #define IBLND_REJECT_MSG_QUEUE_SIZE 7 /* Fatal: peer's msg queue size can't */
 471                                       /* match mine */
 472
 473 /***********************************************************************/
 474
 475 typedef struct kib_rx                         /* receive message */
 476 {
 477         struct list_head       rx_list;       /* queue for attention */
 478         struct kib_conn        *rx_conn;      /* owning conn */
 479         int                    rx_nob; /* # bytes received (-1 while posted) */
 480         enum ib_wc_status      rx_status;     /* completion status */
 481         kib_msg_t              *rx_msg;       /* message buffer (host vaddr) */
 482         __u64                  rx_msgaddr;    /* message buffer (I/O addr) */
 483         DECLARE_PCI_UNMAP_ADDR(rx_msgunmap);  /* for dma_unmap_single() */
 484         struct ib_recv_wr      rx_wrq;        /* receive work item... */
 485         struct ib_sge          rx_sge;        /* ...and its memory */
 486 } kib_rx_t;
 487
 488 #define IBLND_POSTRX_DONT_POST    0 /* don't post */
 489 #define IBLND_POSTRX_NO_CREDIT    1 /* post: no credits */
 490 #define IBLND_POSTRX_PEER_CREDIT  2 /* post: give peer back 1 credit */
 491 #define IBLND_POSTRX_RSRVD_CREDIT 3 /* post: give self back 1 reserved credit */
 492
 493 typedef struct kib_tx                         /* transmit message */
 494 {
 495         struct list_head      tx_list; /* queue on idle_txs ibc_tx_queue etc. */
 496         kib_tx_pool_t         *tx_pool;       /* pool I'm from */
 497         struct kib_conn       *tx_conn;       /* owning conn */
 498         short                 tx_sending;     /* # tx callbacks outstanding */
 499         short                 tx_queued;      /* queued for sending */
 500         short                 tx_waiting;     /* waiting for peer */
 501         int                   tx_status;      /* LNET completion status */
 502         unsigned long         tx_deadline;    /* completion deadline */
 503         __u64                 tx_cookie;      /* completion cookie */
 504         lnet_msg_t *tx_lntmsg[2]; /* lnet msgs to finalize on completion */
 505         kib_msg_t             *tx_msg;        /* message buffer (host vaddr) */
 506         __u64                 tx_msgaddr;     /* message buffer (I/O addr) */
 507         DECLARE_PCI_UNMAP_ADDR(tx_msgunmap);  /* for dma_unmap_single() */
 508         int                   tx_nwrq;        /* # send work items */
 509         struct ib_rdma_wr     *tx_wrq;        /* send work items... */
 510         struct ib_sge         *tx_sge;        /* ...and their memory */
 511         kib_rdma_desc_t       *tx_rd;         /* rdma descriptor */
 512         int                   tx_nfrags;      /* # entries in... */
 513         struct scatterlist    *tx_frags;      /* dma_map_sg descriptor */
 514         __u64                 *tx_pages;      /* rdma phys page addrs */
 515         kib_fmr_t             fmr;            /* FMR */
 516         int                   tx_dmadir;      /* dma direction */
 517 } kib_tx_t;
 518
 519 typedef struct kib_connvars {
 520         kib_msg_t cv_msg; /* connection-in-progress variables */
 521 } kib_connvars_t;
 522
 523 typedef struct kib_conn {
 524         struct kib_sched_info *ibc_sched;      /* scheduler information */
 525         struct kib_peer       *ibc_peer;       /* owning peer */
 526         kib_hca_dev_t         *ibc_hdev;       /* HCA bound on */
 527         struct list_head ibc_list;             /* stash on peer's conn list */
 528         struct list_head      ibc_sched_list;  /* schedule for attention */
 529         __u16                 ibc_version;     /* version of connection */
 530         __u64                 ibc_incarnation; /* which instance of the peer */
 531         atomic_t              ibc_refcount;    /* # users */
 532         int                   ibc_state;       /* what's happening */
 533         int                   ibc_nsends_posted; /* # uncompleted sends */
 534         int                   ibc_noops_posted;  /* # uncompleted NOOPs */
 535         int                   ibc_credits;     /* # credits I have */
 536         int                   ibc_outstanding_credits; /* # credits to return */
 537         int                   ibc_reserved_credits; /* # ACK/DONE msg credits */
 538         int                   ibc_comms_error; /* set on comms error */
 539         unsigned int          ibc_nrx:16;      /* receive buffers owned */
 540         unsigned int          ibc_scheduled:1; /* scheduled for attention */
 541         unsigned int          ibc_ready:1;     /* CQ callback fired */
 542         unsigned long         ibc_last_send;   /* time of last send */
 543         struct list_head      ibc_connd_list;  /* link chain for */
 544                                                /* kiblnd_check_conns only */
 545         struct list_head ibc_early_rxs; /* rxs completed before ESTABLISHED */
 546         struct list_head ibc_tx_noops;         /* IBLND_MSG_NOOPs for */
 547                                                /* IBLND_MSG_VERSION_1 */
 548         struct list_head ibc_tx_queue;         /* sends that need a credit */
 549         struct list_head ibc_tx_queue_nocred;  /* sends that don't need a */
 550                                                /* credit */
 551         struct list_head ibc_tx_queue_rsrvd;   /* sends that need to */
 552                                                /* reserve an ACK/DONE msg */
 553         struct list_head ibc_active_txs; /* active tx awaiting completion */
 554         spinlock_t            ibc_lock;        /* serialise */
 555         kib_rx_t              *ibc_rxs;        /* the rx descs */
 556         kib_pages_t           *ibc_rx_pages;   /* premapped rx msg pages */
 557
 558         struct rdma_cm_id     *ibc_cmid;       /* CM id */
 559         struct ib_cq          *ibc_cq;         /* completion queue */
 560
 561         kib_connvars_t        *ibc_connvars; /* in-progress connection state */
 562 } kib_conn_t;
 563
 564 #define IBLND_CONN_INIT           0      /* being initialised */
 565 #define IBLND_CONN_ACTIVE_CONNECT 1      /* active sending req */
 566 #define IBLND_CONN_PASSIVE_WAIT   2      /* passive waiting for rtu */
 567 #define IBLND_CONN_ESTABLISHED    3      /* connection established */
 568 #define IBLND_CONN_CLOSING        4      /* being closed */
 569 #define IBLND_CONN_DISCONNECTED   5      /* disconnected */
 570
 571 typedef struct kib_peer {
 572         struct list_head ibp_list;        /* stash on global peer list */
 573         lnet_nid_t       ibp_nid;         /* who's on the other end(s) */
 574         lnet_ni_t        *ibp_ni;         /* LNet interface */
 575         atomic_t         ibp_refcount;    /* # users */
 576         struct list_head ibp_conns;       /* all active connections */
 577         struct list_head ibp_tx_queue;    /* msgs waiting for a conn */
 578         __u16            ibp_version;     /* version of peer */
 579         __u64            ibp_incarnation; /* incarnation of peer */
 580         int              ibp_connecting;  /* current active connection attempts
 581                                            */
 582         int              ibp_accepting;   /* current passive connection attempts
 583                                            */
 584         int              ibp_error;       /* errno on closing this peer */
 585         unsigned long    ibp_last_alive;  /* when (in jiffies) I was last alive
 586                                            */
 587 } kib_peer_t;
 588
 589 extern kib_data_t kiblnd_data;
 590
 591 void kiblnd_hdev_destroy(kib_hca_dev_t *hdev);
 592
 593 static inline void
 594 kiblnd_hdev_addref_locked(kib_hca_dev_t *hdev)
 595 {
 596         LASSERT(atomic_read(&hdev->ibh_ref) > 0);
 597         atomic_inc(&hdev->ibh_ref);
 598 }
 599
 600 static inline void
 601 kiblnd_hdev_decref(kib_hca_dev_t *hdev)
 602 {
 603         LASSERT(atomic_read(&hdev->ibh_ref) > 0);
 604         if (atomic_dec_and_test(&hdev->ibh_ref))
 605                 kiblnd_hdev_destroy(hdev);
 606 }
 607
 608 static inline int
 609 kiblnd_dev_can_failover(kib_dev_t *dev)
 610 {
 611         if (!list_empty(&dev->ibd_fail_list)) /* already scheduled */
 612                 return 0;
 613
 614         if (*kiblnd_tunables.kib_dev_failover == 0) /* disabled */
 615                 return 0;
 616
 617         if (*kiblnd_tunables.kib_dev_failover > 1) /* force failover */
 618                 return 1;
 619
 620         return dev->ibd_can_failover;
 621 }
 622
 623 #define kiblnd_conn_addref(conn)                                \
 624 do {                                                        \
 625         CDEBUG(D_NET, "conn[%p] (%d)++\n",                    \
 626                (conn), atomic_read(&(conn)->ibc_refcount)); \
 627         atomic_inc(&(conn)->ibc_refcount);                \
 628 } while (0)
 629
 630 #define kiblnd_conn_decref(conn)                                        \
 631 do {                                                                    \
 632         unsigned long flags;                                            \
 633                                                                         \
 634         CDEBUG(D_NET, "conn[%p] (%d)--\n",                              \
 635                (conn), atomic_read(&(conn)->ibc_refcount));             \
 636         LASSERT_ATOMIC_POS(&(conn)->ibc_refcount);                      \
 637         if (atomic_dec_and_test(&(conn)->ibc_refcount)) {               \
 638                 spin_lock_irqsave(&kiblnd_data.kib_connd_lock, flags);  \
 639                 list_add_tail(&(conn)->ibc_list,                        \
 640                                   &kiblnd_data.kib_connd_zombies);      \
 641                 wake_up(&kiblnd_data.kib_connd_waitq);          \
 642                 spin_unlock_irqrestore(&kiblnd_data.kib_connd_lock, flags);\
 643         }                                                               \
 644 } while (0)
 645
 646 #define kiblnd_peer_addref(peer)                                \
 647 do {                                                        \
 648         CDEBUG(D_NET, "peer[%p] -> %s (%d)++\n",                \
 649                (peer), libcfs_nid2str((peer)->ibp_nid),  \
 650                atomic_read(&(peer)->ibp_refcount));     \
 651         atomic_inc(&(peer)->ibp_refcount);                \
 652 } while (0)
 653
 654 #define kiblnd_peer_decref(peer)                                \
 655 do {                                                        \
 656         CDEBUG(D_NET, "peer[%p] -> %s (%d)--\n",                \
 657                (peer), libcfs_nid2str((peer)->ibp_nid),  \
 658                atomic_read(&(peer)->ibp_refcount));     \
 659         LASSERT_ATOMIC_POS(&(peer)->ibp_refcount);            \
 660         if (atomic_dec_and_test(&(peer)->ibp_refcount))     \
 661                 kiblnd_destroy_peer(peer);                    \
 662 } while (0)
 663
 664 static inline struct list_head *
 665 kiblnd_nid2peerlist(lnet_nid_t nid)
 666 {
 667         unsigned int hash =
 668                 ((unsigned int)nid) % kiblnd_data.kib_peer_hash_size;
 669
 670         return &kiblnd_data.kib_peers[hash];
 671 }
 672
 673 static inline int
 674 kiblnd_peer_active(kib_peer_t *peer)
 675 {
 676         /* Am I in the peer hash table? */
 677         return !list_empty(&peer->ibp_list);
 678 }
 679
 680 static inline kib_conn_t *
 681 kiblnd_get_conn_locked(kib_peer_t *peer)
 682 {
 683         LASSERT(!list_empty(&peer->ibp_conns));
 684
 685         /* just return the first connection */
 686         return list_entry(peer->ibp_conns.next, kib_conn_t, ibc_list);
 687 }
 688
 689 static inline int
 690 kiblnd_send_keepalive(kib_conn_t *conn)
 691 {
 692         return (*kiblnd_tunables.kib_keepalive > 0) &&
 693                 cfs_time_after(jiffies, conn->ibc_last_send +
 694                                *kiblnd_tunables.kib_keepalive*HZ);
 695 }
 696
 697 static inline int
 698 kiblnd_need_noop(kib_conn_t *conn)
 699 {
 700         LASSERT(conn->ibc_state >= IBLND_CONN_ESTABLISHED);
 701
 702         if (conn->ibc_outstanding_credits <
 703             IBLND_CREDITS_HIGHWATER(conn->ibc_version) &&
 704             !kiblnd_send_keepalive(conn))
 705                 return 0; /* No need to send NOOP */
 706
 707         if (IBLND_OOB_CAPABLE(conn->ibc_version)) {
 708                 if (!list_empty(&conn->ibc_tx_queue_nocred))
 709                         return 0; /* NOOP can be piggybacked */
 710
 711                 /* No tx to piggyback NOOP onto or no credit to send a tx */
 712                 return (list_empty(&conn->ibc_tx_queue) ||
 713                         conn->ibc_credits == 0);
 714         }
 715
 716         if (!list_empty(&conn->ibc_tx_noops) || /* NOOP already queued */
 717             !list_empty(&conn->ibc_tx_queue_nocred) || /* piggyback NOOP */
 718             conn->ibc_credits == 0)                 /* no credit */
 719                 return 0;
 720
 721         if (conn->ibc_credits == 1 &&      /* last credit reserved for */
 722             conn->ibc_outstanding_credits == 0) /* giving back credits */
 723                 return 0;
 724
 725         /* No tx to piggyback NOOP onto or no credit to send a tx */
 726         return (list_empty(&conn->ibc_tx_queue) || conn->ibc_credits == 1);
 727 }
 728
 729 static inline void
 730 kiblnd_abort_receives(kib_conn_t *conn)
 731 {
 732         ib_modify_qp(conn->ibc_cmid->qp,
 733                      &kiblnd_data.kib_error_qpa, IB_QP_STATE);
 734 }
 735
 736 static inline const char *
 737 kiblnd_queue2str(kib_conn_t *conn, struct list_head *q)
 738 {
 739         if (q == &conn->ibc_tx_queue)
 740                 return "tx_queue";
 741
 742         if (q == &conn->ibc_tx_queue_rsrvd)
 743                 return "tx_queue_rsrvd";
 744
 745         if (q == &conn->ibc_tx_queue_nocred)
 746                 return "tx_queue_nocred";
 747
 748         if (q == &conn->ibc_active_txs)
 749                 return "active_txs";
 750
 751         LBUG();
 752         return NULL;
 753 }
 754
 755 /* CAVEAT EMPTOR: We rely on descriptor alignment to allow us to use the */
 756 /* lowest bits of the work request id to stash the work item type. */
 757
 758 #define IBLND_WID_TX    0
 759 #define IBLND_WID_RDMA  1
 760 #define IBLND_WID_RX    2
 761 #define IBLND_WID_MASK  3UL
 762
 763 static inline __u64
 764 kiblnd_ptr2wreqid(void *ptr, int type)
 765 {
 766         unsigned long lptr = (unsigned long)ptr;
 767
 768         LASSERT((lptr & IBLND_WID_MASK) == 0);
 769         LASSERT((type & ~IBLND_WID_MASK) == 0);
 770         return (__u64)(lptr | type);
 771 }
 772
 773 static inline void *
 774 kiblnd_wreqid2ptr(__u64 wreqid)
 775 {
 776         return (void *)(((unsigned long)wreqid) & ~IBLND_WID_MASK);
 777 }
 778
 779 static inline int
 780 kiblnd_wreqid2type(__u64 wreqid)
 781 {
 782         return wreqid & IBLND_WID_MASK;
 783 }
 784
 785 static inline void
 786 kiblnd_set_conn_state(kib_conn_t *conn, int state)
 787 {
 788         conn->ibc_state = state;
 789         mb();
 790 }
 791
 792 static inline void
 793 kiblnd_init_msg(kib_msg_t *msg, int type, int body_nob)
 794 {
 795         msg->ibm_type = type;
 796         msg->ibm_nob  = offsetof(kib_msg_t, ibm_u) + body_nob;
 797 }
 798
 799 static inline int
 800 kiblnd_rd_size(kib_rdma_desc_t *rd)
 801 {
 802         int   i;
 803         int   size;
 804
 805         for (i = size = 0; i < rd->rd_nfrags; i++)
 806                 size += rd->rd_frags[i].rf_nob;
 807
 808         return size;
 809 }
 810
 811 static inline __u64
 812 kiblnd_rd_frag_addr(kib_rdma_desc_t *rd, int index)
 813 {
 814         return rd->rd_frags[index].rf_addr;
 815 }
 816
 817 static inline __u32
 818 kiblnd_rd_frag_size(kib_rdma_desc_t *rd, int index)
 819 {
 820         return rd->rd_frags[index].rf_nob;
 821 }
 822
 823 static inline __u32
 824 kiblnd_rd_frag_key(kib_rdma_desc_t *rd, int index)
 825 {
 826         return rd->rd_key;
 827 }
 828
 829 static inline int
 830 kiblnd_rd_consume_frag(kib_rdma_desc_t *rd, int index, __u32 nob)
 831 {
 832         if (nob < rd->rd_frags[index].rf_nob) {
 833                 rd->rd_frags[index].rf_addr += nob;
 834                 rd->rd_frags[index].rf_nob  -= nob;
 835         } else {
 836                 index++;
 837         }
 838
 839         return index;
 840 }
 841
 842 static inline int
 843 kiblnd_rd_msg_size(kib_rdma_desc_t *rd, int msgtype, int n)
 844 {
 845         LASSERT(msgtype == IBLND_MSG_GET_REQ ||
 846                 msgtype == IBLND_MSG_PUT_ACK);
 847
 848         return msgtype == IBLND_MSG_GET_REQ ?
 849                offsetof(kib_get_msg_t, ibgm_rd.rd_frags[n]) :
 850                offsetof(kib_putack_msg_t, ibpam_rd.rd_frags[n]);
 851 }
 852
 853 static inline __u64
 854 kiblnd_dma_mapping_error(struct ib_device *dev, u64 dma_addr)
 855 {
 856         return ib_dma_mapping_error(dev, dma_addr);
 857 }
 858
 859 static inline __u64 kiblnd_dma_map_single(struct ib_device *dev,
 860                                           void *msg, size_t size,
 861                                           enum dma_data_direction direction)
 862 {
 863         return ib_dma_map_single(dev, msg, size, direction);
 864 }
 865
 866 static inline void kiblnd_dma_unmap_single(struct ib_device *dev,
 867                                            __u64 addr, size_t size,
 868                                           enum dma_data_direction direction)
 869 {
 870         ib_dma_unmap_single(dev, addr, size, direction);
 871 }
 872
 873 #define KIBLND_UNMAP_ADDR_SET(p, m, a)  do {} while (0)
 874 #define KIBLND_UNMAP_ADDR(p, m, a)      (a)
 875
 876 static inline int kiblnd_dma_map_sg(struct ib_device *dev,
 877                                     struct scatterlist *sg, int nents,
 878                                     enum dma_data_direction direction)
 879 {
 880         return ib_dma_map_sg(dev, sg, nents, direction);
 881 }
 882
 883 static inline void kiblnd_dma_unmap_sg(struct ib_device *dev,
 884                                        struct scatterlist *sg, int nents,
 885                                        enum dma_data_direction direction)
 886 {
 887         ib_dma_unmap_sg(dev, sg, nents, direction);
 888 }
 889
 890 static inline __u64 kiblnd_sg_dma_address(struct ib_device *dev,
 891                                           struct scatterlist *sg)
 892 {
 893         return ib_sg_dma_address(dev, sg);
 894 }
 895
 896 static inline unsigned int kiblnd_sg_dma_len(struct ib_device *dev,
 897                                              struct scatterlist *sg)
 898 {
 899         return ib_sg_dma_len(dev, sg);
 900 }
 901
 902 /* XXX We use KIBLND_CONN_PARAM(e) as writable buffer, it's not strictly */
 903 /* right because OFED1.2 defines it as const, to use it we have to add */
 904 /* (void *) cast to overcome "const" */
 905
 906 #define KIBLND_CONN_PARAM(e)     ((e)->param.conn.private_data)
 907 #define KIBLND_CONN_PARAM_LEN(e) ((e)->param.conn.private_data_len)
 908
 909 struct ib_mr *kiblnd_find_rd_dma_mr(kib_hca_dev_t *hdev,
 910                                     kib_rdma_desc_t *rd);
 911 struct ib_mr *kiblnd_find_dma_mr(kib_hca_dev_t *hdev,
 912                                  __u64 addr, __u64 size);
 913 void kiblnd_map_rx_descs(kib_conn_t *conn);
 914 void kiblnd_unmap_rx_descs(kib_conn_t *conn);
 915 void kiblnd_pool_free_node(kib_pool_t *pool, struct list_head *node);
 916 struct list_head *kiblnd_pool_alloc_node(kib_poolset_t *ps);
 917
 918 int  kiblnd_fmr_pool_map(kib_fmr_poolset_t *fps, __u64 *pages,
 919                          int npages, __u64 iov, kib_fmr_t *fmr);
 920 void kiblnd_fmr_pool_unmap(kib_fmr_t *fmr, int status);
 921
 922 int  kiblnd_startup(lnet_ni_t *ni);
 923 void kiblnd_shutdown(lnet_ni_t *ni);
 924 int  kiblnd_ctl(lnet_ni_t *ni, unsigned int cmd, void *arg);
 925 void kiblnd_query(struct lnet_ni *ni, lnet_nid_t nid, unsigned long *when);
 926
 927 int  kiblnd_tunables_init(void);
 928 void kiblnd_tunables_fini(void);
 929
 930 int  kiblnd_connd(void *arg);
 931 int  kiblnd_scheduler(void *arg);
 932 int  kiblnd_thread_start(int (*fn)(void *arg), void *arg, char *name);
 933 int  kiblnd_failover_thread(void *arg);
 934
 935 int  kiblnd_alloc_pages(kib_pages_t **pp, int cpt, int npages);
 936 void kiblnd_free_pages(kib_pages_t *p);
 937
 938 int  kiblnd_cm_callback(struct rdma_cm_id *cmid,
 939                         struct rdma_cm_event *event);
 940 int  kiblnd_translate_mtu(int value);
 941
 942 int  kiblnd_dev_failover(kib_dev_t *dev);
 943 int  kiblnd_create_peer(lnet_ni_t *ni, kib_peer_t **peerp, lnet_nid_t nid);
 944 void kiblnd_destroy_peer(kib_peer_t *peer);
 945 void kiblnd_destroy_dev(kib_dev_t *dev);
 946 void kiblnd_unlink_peer_locked(kib_peer_t *peer);
 947 void kiblnd_peer_alive(kib_peer_t *peer);
 948 kib_peer_t *kiblnd_find_peer_locked(lnet_nid_t nid);
 949 void kiblnd_peer_connect_failed(kib_peer_t *peer, int active, int error);
 950 int  kiblnd_close_stale_conns_locked(kib_peer_t *peer,
 951                                       int version, __u64 incarnation);
 952 int  kiblnd_close_peer_conns_locked(kib_peer_t *peer, int why);
 953
 954 void kiblnd_connreq_done(kib_conn_t *conn, int status);
 955 kib_conn_t *kiblnd_create_conn(kib_peer_t *peer, struct rdma_cm_id *cmid,
 956                                 int state, int version);
 957 void kiblnd_destroy_conn(kib_conn_t *conn);
 958 void kiblnd_close_conn(kib_conn_t *conn, int error);
 959 void kiblnd_close_conn_locked(kib_conn_t *conn, int error);
 960
 961 int  kiblnd_init_rdma(kib_conn_t *conn, kib_tx_t *tx, int type,
 962                        int nob, kib_rdma_desc_t *dstrd, __u64 dstcookie);
 963
 964 void kiblnd_launch_tx(lnet_ni_t *ni, kib_tx_t *tx, lnet_nid_t nid);
 965 void kiblnd_queue_tx_locked(kib_tx_t *tx, kib_conn_t *conn);
 966 void kiblnd_queue_tx(kib_tx_t *tx, kib_conn_t *conn);
 967 void kiblnd_init_tx_msg(lnet_ni_t *ni, kib_tx_t *tx, int type, int body_nob);
 968 void kiblnd_txlist_done(lnet_ni_t *ni, struct list_head *txlist,
 969                          int status);
 970 void kiblnd_check_sends (kib_conn_t *conn);
 971
 972 void kiblnd_qp_event(struct ib_event *event, void *arg);
 973 void kiblnd_cq_event(struct ib_event *event, void *arg);
 974 void kiblnd_cq_completion(struct ib_cq *cq, void *arg);
 975
 976 void kiblnd_pack_msg(lnet_ni_t *ni, kib_msg_t *msg, int version,
 977                       int credits, lnet_nid_t dstnid, __u64 dststamp);
 978 int  kiblnd_unpack_msg(kib_msg_t *msg, int nob);
 979 int  kiblnd_post_rx(kib_rx_t *rx, int credit);
 980
 981 int  kiblnd_send(lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg);
 982 int  kiblnd_recv(lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg, int delayed,
 983                  unsigned int niov, struct kvec *iov, lnet_kiov_t *kiov,
 984                  unsigned int offset, unsigned int mlen, unsigned int rlen);