lnet/klnds/socklnd/socklnd_cb.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  * Copyright (C) 2001, 2002 Cluster File Systems, Inc.
   5  *   Author: Zach Brown <zab@zabbo.net>
   6  *   Author: Peter J. Braam <braam@clusterfs.com>
   7  *   Author: Phil Schwan <phil@clusterfs.com>
   8  *   Author: Eric Barton <eric@bartonsoftware.com>
   9  *
  10  *   This file is part of Portals, http://www.sf.net/projects/sandiaportals/
  11  *
  12  *   Portals is free software; you can redistribute it and/or
  13  *   modify it under the terms of version 2 of the GNU General Public
  14  *   License as published by the Free Software Foundation.
  15  *
  16  *   Portals is distributed in the hope that it will be useful,
  17  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  *   GNU General Public License for more details.
  20  *
  21  *   You should have received a copy of the GNU General Public License
  22  *   along with Portals; if not, write to the Free Software
  23  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  24  */
  25
  26 #include "socknal.h"
  27
  28 /*
  29  *  LIB functions follow
  30  *
  31  */
  32 int
  33 ksocknal_dist(lib_nal_t *nal, ptl_nid_t nid, unsigned long *dist)
  34 {
  35         /* I would guess that if ksocknal_get_peer (nid) == NULL,
  36            and we're not routing, then 'nid' is very distant :) */
  37         if (nal->libnal_ni.ni_pid.nid == nid) {
  38                 *dist = 0;
  39         } else {
  40                 *dist = 1;
  41         }
  42
  43         return 0;
  44 }
  45
  46 void
  47 ksocknal_free_ltx (ksock_ltx_t *ltx)
  48 {
  49         atomic_dec(&ksocknal_data.ksnd_nactive_ltxs);
  50         PORTAL_FREE(ltx, ltx->ltx_desc_size);
  51 }
  52
  53 int
  54 ksocknal_send_iov (ksock_conn_t *conn, ksock_tx_t *tx)
  55 {
  56         struct iovec  *iov = tx->tx_iov;
  57         int    nob;
  58         int    rc;
  59
  60         LASSERT (tx->tx_niov > 0);
  61
  62         /* Never touch tx->tx_iov inside ksocknal_lib_send_iov() */
  63         rc = ksocknal_lib_send_iov(conn, tx);
  64
  65         if (rc <= 0)                            /* sent nothing? */
  66                 return (rc);
  67
  68         nob = rc;
  69         LASSERT (nob <= tx->tx_resid);
  70         tx->tx_resid -= nob;
  71
  72         /* "consume" iov */
  73         do {
  74                 LASSERT (tx->tx_niov > 0);
  75
  76                 if (nob < iov->iov_len) {
  77                         iov->iov_base = (void *)(((unsigned long)(iov->iov_base)) + nob);
  78                         iov->iov_len -= nob;
  79                         return (rc);
  80                 }
  81
  82                 nob -= iov->iov_len;
  83                 tx->tx_iov = ++iov;
  84                 tx->tx_niov--;
  85         } while (nob != 0);
  86
  87         return (rc);
  88 }
  89
  90 int
  91 ksocknal_send_kiov (ksock_conn_t *conn, ksock_tx_t *tx)
  92 {
  93         ptl_kiov_t    *kiov = tx->tx_kiov;
  94         int     nob;
  95         int     rc;
  96
  97         LASSERT (tx->tx_niov == 0);
  98         LASSERT (tx->tx_nkiov > 0);
  99
 100         /* Never touch tx->tx_kiov inside ksocknal_lib_send_kiov() */
 101         rc = ksocknal_lib_send_kiov(conn, tx);
 102
 103         if (rc <= 0)                            /* sent nothing? */
 104                 return (rc);
 105
 106         nob = rc;
 107         LASSERT (nob <= tx->tx_resid);
 108         tx->tx_resid -= nob;
 109
 110         /* "consume" kiov */
 111         do {
 112                 LASSERT(tx->tx_nkiov > 0);
 113
 114                 if (nob < kiov->kiov_len) {
 115                         kiov->kiov_offset += nob;
 116                         kiov->kiov_len -= nob;
 117                         return rc;
 118                 }
 119
 120                 nob -= kiov->kiov_len;
 121                 tx->tx_kiov = ++kiov;
 122                 tx->tx_nkiov--;
 123         } while (nob != 0);
 124
 125         return (rc);
 126 }
 127
 128 int
 129 ksocknal_transmit (ksock_conn_t *conn, ksock_tx_t *tx)
 130 {
 131         int      rc;
 132         int      bufnob;
 133
 134         if (ksocknal_data.ksnd_stall_tx != 0) {
 135                 set_current_state (TASK_UNINTERRUPTIBLE);
 136                 schedule_timeout (cfs_time_seconds(ksocknal_data.ksnd_stall_tx));
 137         }
 138
 139         LASSERT (tx->tx_resid != 0);
 140
 141         rc = ksocknal_getconnsock (conn);
 142         if (rc != 0) {
 143                 LASSERT (conn->ksnc_closing);
 144                 return (-ESHUTDOWN);
 145         }
 146
 147         do {
 148                 if (ksocknal_data.ksnd_enomem_tx > 0) {
 149                         /* testing... */
 150                         ksocknal_data.ksnd_enomem_tx--;
 151                         rc = -EAGAIN;
 152                 } else if (tx->tx_niov != 0) {
 153                         rc = ksocknal_send_iov (conn, tx);
 154                 } else {
 155                         rc = ksocknal_send_kiov (conn, tx);
 156                 }
 157
 158                 bufnob = SOCK_WMEM_QUEUED(conn->ksnc_sock);
 159                 if (rc > 0)                     /* sent something? */
 160                         conn->ksnc_tx_bufnob += rc; /* account it */
 161
 162                 if (bufnob < conn->ksnc_tx_bufnob) {
 163                         /* allocated send buffer bytes < computed; infer
 164                          * something got ACKed */
 165                         conn->ksnc_tx_deadline = cfs_time_shift(ksocknal_tunables.ksnd_io_timeout);
 166                         conn->ksnc_peer->ksnp_last_alive = cfs_time_current();
 167                         conn->ksnc_tx_bufnob = bufnob;
 168                         mb();
 169                 }
 170
 171                 if (rc <= 0) { /* Didn't write anything? */
 172                         unsigned long  flags;
 173                         ksock_sched_t *sched;
 174
 175                         if (rc == 0) /* some stacks return 0 instead of -EAGAIN */
 176                                 rc = -EAGAIN;
 177
 178                         if (rc != -EAGAIN)
 179                                 break;
 180
 181                         /* Check if EAGAIN is due to memory pressure */
 182
 183                         sched = conn->ksnc_scheduler;
 184                         spin_lock_irqsave(&sched->kss_lock, flags);
 185
 186                         if (!SOCK_TEST_NOSPACE(conn->ksnc_sock) &&
 187                             !conn->ksnc_tx_ready) {
 188                                 /* SOCK_NOSPACE is set when the socket fills
 189                                  * and cleared in the write_space callback
 190                                  * (which also sets ksnc_tx_ready).  If
 191                                  * SOCK_NOSPACE and ksnc_tx_ready are BOTH
 192                                  * zero, I didn't fill the socket and
 193                                  * write_space won't reschedule me, so I
 194                                  * return -ENOMEM to get my caller to retry
 195                                  * after a timeout */
 196                                 rc = -ENOMEM;
 197                         }
 198
 199                         spin_unlock_irqrestore(&sched->kss_lock, flags);
 200                         break;
 201                 }
 202
 203                 /* socket's wmem_queued now includes 'rc' bytes */
 204                 atomic_sub (rc, &conn->ksnc_tx_nob);
 205                 rc = 0;
 206
 207         } while (tx->tx_resid != 0);
 208
 209         ksocknal_putconnsock (conn);
 210         return (rc);
 211 }
 212
 213 int
 214 ksocknal_recv_iov (ksock_conn_t *conn)
 215 {
 216         struct iovec *iov = conn->ksnc_rx_iov;
 217         int     nob;
 218         int     rc;
 219
 220         LASSERT (conn->ksnc_rx_niov > 0);
 221
 222         /* Never touch conn->ksnc_rx_iov or change connection
 223          * status inside ksocknal_lib_recv_iov */
 224         rc = ksocknal_lib_recv_iov(conn);
 225
 226         if (rc <= 0)
 227                 return (rc);
 228
 229         /* received something... */
 230         nob = rc;
 231
 232         conn->ksnc_peer->ksnp_last_alive = cfs_time_current();
 233         conn->ksnc_rx_deadline = cfs_time_shift (ksocknal_tunables.ksnd_io_timeout);
 234         mb();                           /* order with setting rx_started */
 235         conn->ksnc_rx_started = 1;
 236
 237         conn->ksnc_rx_nob_wanted -= nob;
 238         conn->ksnc_rx_nob_left -= nob;
 239
 240         do {
 241                 LASSERT (conn->ksnc_rx_niov > 0);
 242
 243                 if (nob < iov->iov_len) {
 244                         iov->iov_len -= nob;
 245                         iov->iov_base = (void *)(((unsigned long)iov->iov_base) + nob);
 246                         return (-EAGAIN);
 247                 }
 248
 249                 nob -= iov->iov_len;
 250                 conn->ksnc_rx_iov = ++iov;
 251                 conn->ksnc_rx_niov--;
 252         } while (nob != 0);
 253
 254         return (rc);
 255 }
 256
 257 int
 258 ksocknal_recv_kiov (ksock_conn_t *conn)
 259 {
 260         ptl_kiov_t   *kiov = conn->ksnc_rx_kiov;
 261         int     nob;
 262         int     rc;
 263         LASSERT (conn->ksnc_rx_nkiov > 0);
 264
 265         /* Never touch conn->ksnc_rx_kiov or change connection
 266          * status inside ksocknal_lib_recv_iov */
 267         rc = ksocknal_lib_recv_kiov(conn);
 268
 269         if (rc <= 0)
 270                 return (rc);
 271
 272         /* received something... */
 273         nob = rc;
 274
 275         conn->ksnc_peer->ksnp_last_alive = cfs_time_current();
 276         conn->ksnc_rx_deadline = cfs_time_shift (ksocknal_tunables.ksnd_io_timeout);
 277         mb();                           /* order with setting rx_started */
 278         conn->ksnc_rx_started = 1;
 279
 280         conn->ksnc_rx_nob_wanted -= nob;
 281         conn->ksnc_rx_nob_left -= nob;
 282
 283         do {
 284                 LASSERT (conn->ksnc_rx_nkiov > 0);
 285
 286                 if (nob < kiov->kiov_len) {
 287                         kiov->kiov_offset += nob;
 288                         kiov->kiov_len -= nob;
 289                         return -EAGAIN;
 290                 }
 291
 292                 nob -= kiov->kiov_len;
 293                 conn->ksnc_rx_kiov = ++kiov;
 294                 conn->ksnc_rx_nkiov--;
 295         } while (nob != 0);
 296
 297         return 1;
 298 }
 299
 300 int
 301 ksocknal_receive (ksock_conn_t *conn)
 302 {
 303         /* Return 1 on success, 0 on EOF, < 0 on error.
 304          * Caller checks ksnc_rx_nob_wanted to determine
 305          * progress/completion. */
 306         int     rc;
 307         ENTRY;
 308
 309         if (ksocknal_data.ksnd_stall_rx != 0) {
 310                 set_current_state (TASK_UNINTERRUPTIBLE);
 311                 schedule_timeout(cfs_time_seconds (ksocknal_data.ksnd_stall_rx));
 312         }
 313
 314         rc = ksocknal_getconnsock (conn);
 315         if (rc != 0) {
 316                 LASSERT (conn->ksnc_closing);
 317                 return (-ESHUTDOWN);
 318         }
 319
 320         for (;;) {
 321                 if (conn->ksnc_rx_niov != 0)
 322                         rc = ksocknal_recv_iov (conn);
 323                 else
 324                         rc = ksocknal_recv_kiov (conn);
 325
 326                 if (rc <= 0) {
 327                         /* error/EOF or partial receive */
 328                         if (rc == -EAGAIN) {
 329                                 rc = 1;
 330                         } else if (rc == 0 && conn->ksnc_rx_started) {
 331                                 /* EOF in the middle of a message */
 332                                 rc = -EPROTO;
 333                         }
 334                         break;
 335                 }
 336
 337                 /* Completed a fragment */
 338
 339                 if (conn->ksnc_rx_nob_wanted == 0) {
 340                         /* Completed a message segment (header or payload) */
 341                         if ((ksocknal_tunables.ksnd_eager_ack & conn->ksnc_type) != 0 &&
 342                             (conn->ksnc_rx_state ==  SOCKNAL_RX_BODY ||
 343                              conn->ksnc_rx_state == SOCKNAL_RX_BODY_FWD)) {
 344                                 /* Remind the socket to ack eagerly... */
 345                                 ksocknal_lib_eager_ack(conn);
 346                         }
 347                         rc = 1;
 348                         break;
 349                 }
 350         }
 351
 352         ksocknal_putconnsock (conn);
 353         RETURN (rc);
 354 }
 355
 356 #if SOCKNAL_ZC
 357 void
 358 ksocknal_zc_callback (zccd_t *zcd)
 359 {
 360         ksock_tx_t    *tx = KSOCK_ZCCD_2_TX(zcd);
 361         ksock_sched_t *sched = tx->tx_conn->ksnc_scheduler;
 362         unsigned long  flags;
 363         ENTRY;
 364
 365         /* Schedule tx for cleanup (can't do it now due to lock conflicts) */
 366
 367         spin_lock_irqsave (&sched->kss_lock, flags);
 368
 369         list_add_tail (&tx->tx_list, &sched->kss_zctxdone_list);
 370         cfs_waitq_signal (&sched->kss_waitq);
 371
 372         spin_unlock_irqrestore (&sched->kss_lock, flags);
 373         EXIT;
 374 }
 375 #endif
 376
 377 void
 378 ksocknal_tx_done (ksock_tx_t *tx, int asynch)
 379 {
 380         ksock_ltx_t   *ltx;
 381         ENTRY;
 382
 383         if (tx->tx_conn != NULL) {
 384 #if SOCKNAL_ZC
 385                 /* zero copy completion isn't always from
 386                  * process_transmit() so it needs to keep a ref on
 387                  * tx_conn... */
 388                 if (asynch)
 389                         ksocknal_put_conn (tx->tx_conn);
 390 #else
 391                 LASSERT (!asynch);
 392 #endif
 393         }
 394
 395         if (tx->tx_isfwd) {             /* was a forwarded packet? */
 396                 kpr_fwd_done (&ksocknal_data.ksnd_router,
 397                               KSOCK_TX_2_KPR_FWD_DESC (tx),
 398                               (tx->tx_resid == 0) ? 0 : -ECONNABORTED);
 399                 EXIT;
 400                 return;
 401         }
 402
 403         /* local send */
 404         ltx = KSOCK_TX_2_KSOCK_LTX (tx);
 405
 406         lib_finalize (&ksocknal_lib, ltx->ltx_private, ltx->ltx_cookie,
 407                       (tx->tx_resid == 0) ? PTL_OK : PTL_FAIL);
 408
 409         ksocknal_free_ltx (ltx);
 410         EXIT;
 411 }
 412
 413 void
 414 ksocknal_tx_launched (ksock_tx_t *tx)
 415 {
 416 #if SOCKNAL_ZC
 417         if (atomic_read (&tx->tx_zccd.zccd_count) != 1) {
 418                 ksock_conn_t  *conn = tx->tx_conn;
 419
 420                 /* zccd skbufs are still in-flight.  First take a ref on
 421                  * conn, so it hangs about for ksocknal_tx_done... */
 422                 atomic_inc (&conn->ksnc_refcount);
 423
 424                 /* ...then drop the initial ref on zccd, so the zero copy
 425                  * callback can occur */
 426                 zccd_put (&tx->tx_zccd);
 427                 return;
 428         }
 429 #endif
 430         /* Any zero-copy-ness (if any) has completed; I can complete the
 431          * transmit now, avoiding an extra schedule */
 432         ksocknal_tx_done (tx, 0);
 433 }
 434
 435 int
 436 ksocknal_process_transmit (ksock_conn_t *conn, ksock_tx_t *tx)
 437 {
 438         unsigned long  flags;
 439         int            rc;
 440
 441         rc = ksocknal_transmit (conn, tx);
 442
 443         CDEBUG (D_NET, "send(%d) %d\n", tx->tx_resid, rc);
 444
 445         if (tx->tx_resid == 0) {
 446                 /* Sent everything OK */
 447                 LASSERT (rc == 0);
 448
 449                 ksocknal_tx_launched (tx);
 450                 return (0);
 451         }
 452
 453         if (rc == -EAGAIN)
 454                 return (rc);
 455
 456         if (rc == -ENOMEM) {
 457                 static int counter;
 458
 459                 counter++;   /* exponential backoff warnings */
 460                 if ((counter & (-counter)) == counter)
 461                         CWARN("%d ENOMEM tx %p\n", counter, conn);
 462
 463                 /* Queue on ksnd_enomem_conns for retry after a timeout */
 464                 spin_lock_irqsave(&ksocknal_data.ksnd_reaper_lock, flags);
 465
 466                 /* enomem list takes over scheduler's ref... */
 467                 LASSERT (conn->ksnc_tx_scheduled);
 468                 list_add_tail(&conn->ksnc_tx_list,
 469                               &ksocknal_data.ksnd_enomem_conns);
 470                 if (!cfs_time_aftereq(cfs_time_add(cfs_time_current(),
 471                                                    SOCKNAL_ENOMEM_RETRY),
 472                                    ksocknal_data.ksnd_reaper_waketime))
 473                         cfs_waitq_signal (&ksocknal_data.ksnd_reaper_waitq);
 474
 475                 spin_unlock_irqrestore(&ksocknal_data.ksnd_reaper_lock, flags);
 476                 return (rc);
 477         }
 478
 479         /* Actual error */
 480         LASSERT (rc < 0);
 481
 482         if (!conn->ksnc_closing)
 483                 CERROR("[%p] Error %d on write to "LPX64
 484                        " ip %d.%d.%d.%d:%d\n", conn, rc,
 485                        conn->ksnc_peer->ksnp_nid,
 486                        HIPQUAD(conn->ksnc_ipaddr),
 487                        conn->ksnc_port);
 488
 489         ksocknal_close_conn_and_siblings (conn, rc);
 490         ksocknal_tx_launched (tx);
 491
 492         return (rc);
 493 }
 494
 495 void
 496 ksocknal_launch_autoconnect_locked (ksock_route_t *route)
 497 {
 498         unsigned long     flags;
 499
 500         /* called holding write lock on ksnd_global_lock */
 501
 502         LASSERT (!route->ksnr_deleted);
 503         LASSERT ((route->ksnr_connected & (1 << SOCKNAL_CONN_ANY)) == 0);
 504         LASSERT ((route->ksnr_connected & KSNR_TYPED_ROUTES) != KSNR_TYPED_ROUTES);
 505         LASSERT (route->ksnr_connecting == 0);
 506
 507         if (ksocknal_tunables.ksnd_typed_conns)
 508                 route->ksnr_connecting =
 509                         KSNR_TYPED_ROUTES & ~route->ksnr_connected;
 510         else
 511                 route->ksnr_connecting = (1 << SOCKNAL_CONN_ANY);
 512
 513         atomic_inc (&route->ksnr_refcount);     /* extra ref for asynchd */
 514
 515         spin_lock_irqsave (&ksocknal_data.ksnd_autoconnectd_lock, flags);
 516
 517         list_add_tail (&route->ksnr_connect_list,
 518                        &ksocknal_data.ksnd_autoconnectd_routes);
 519         cfs_waitq_signal (&ksocknal_data.ksnd_autoconnectd_waitq);
 520
 521         spin_unlock_irqrestore (&ksocknal_data.ksnd_autoconnectd_lock, flags);
 522 }
 523
 524 ksock_peer_t *
 525 ksocknal_find_target_peer_locked (ksock_tx_t *tx, ptl_nid_t nid)
 526 {
 527         char          ipbuf[PTL_NALFMT_SIZE];
 528         ptl_nid_t     target_nid;
 529         int           rc;
 530         ksock_peer_t *peer = ksocknal_find_peer_locked (nid);
 531
 532         if (peer != NULL)
 533                 return (peer);
 534
 535         if (tx->tx_isfwd) {
 536                 CERROR ("Can't send packet to "LPX64
 537                        " %s: routed target is not a peer\n",
 538                         nid, portals_nid2str(SOCKNAL, nid, ipbuf));
 539                 return (NULL);
 540         }
 541
 542         rc = kpr_lookup (&ksocknal_data.ksnd_router, nid, tx->tx_nob,
 543                          &target_nid);
 544         if (rc != 0) {
 545                 CERROR ("Can't route to "LPX64" %s: router error %d\n",
 546                         nid, portals_nid2str(SOCKNAL, nid, ipbuf), rc);
 547                 return (NULL);
 548         }
 549
 550         peer = ksocknal_find_peer_locked (target_nid);
 551         if (peer != NULL)
 552                 return (peer);
 553
 554         CERROR ("Can't send packet to "LPX64" %s: no peer entry\n",
 555                 target_nid, portals_nid2str(SOCKNAL, target_nid, ipbuf));
 556         return (NULL);
 557 }
 558
 559 ksock_conn_t *
 560 ksocknal_find_conn_locked (ksock_tx_t *tx, ksock_peer_t *peer)
 561 {
 562         struct list_head *tmp;
 563         ksock_conn_t     *typed = NULL;
 564         int               tnob  = 0;
 565         ksock_conn_t     *fallback = NULL;
 566         int               fnob     = 0;
 567         ksock_conn_t     *conn;
 568
 569         list_for_each (tmp, &peer->ksnp_conns) {
 570                 ksock_conn_t *c = list_entry(tmp, ksock_conn_t, ksnc_list);
 571 #if SOCKNAL_ROUND_ROBIN
 572                 const int     nob = 0;
 573 #else
 574                 int           nob = atomic_read(&c->ksnc_tx_nob) +
 575                                         SOCK_WMEM_QUEUED(c->ksnc_sock);
 576 #endif
 577                 LASSERT (!c->ksnc_closing);
 578
 579                 if (fallback == NULL || nob < fnob) {
 580                         fallback = c;
 581                         fnob     = nob;
 582                 }
 583
 584                 if (!ksocknal_tunables.ksnd_typed_conns)
 585                         continue;
 586
 587                 switch (c->ksnc_type) {
 588                 default:
 589                         LBUG();
 590                 case SOCKNAL_CONN_ANY:
 591                         break;
 592                 case SOCKNAL_CONN_BULK_IN:
 593                         continue;
 594                 case SOCKNAL_CONN_BULK_OUT:
 595                         if (tx->tx_nob < ksocknal_tunables.ksnd_min_bulk)
 596                                 continue;
 597                         break;
 598                 case SOCKNAL_CONN_CONTROL:
 599                         if (tx->tx_nob >= ksocknal_tunables.ksnd_min_bulk)
 600                                 continue;
 601                         break;
 602                 }
 603
 604                 if (typed == NULL || nob < tnob) {
 605                         typed = c;
 606                         tnob  = nob;
 607                 }
 608         }
 609
 610         /* prefer the typed selection */
 611         conn = (typed != NULL) ? typed : fallback;
 612
 613 #if SOCKNAL_ROUND_ROBIN
 614         if (conn != NULL) {
 615                 /* round-robin all else being equal */
 616                 list_del (&conn->ksnc_list);
 617                 list_add_tail (&conn->ksnc_list, &peer->ksnp_conns);
 618         }
 619 #endif
 620         return conn;
 621 }
 622
 623 void
 624 ksocknal_queue_tx_locked (ksock_tx_t *tx, ksock_conn_t *conn)
 625 {
 626         unsigned long  flags;
 627         ksock_sched_t *sched = conn->ksnc_scheduler;
 628
 629         /* called holding global lock (read or irq-write) and caller may
 630          * not have dropped this lock between finding conn and calling me,
 631          * so we don't need the {get,put}connsock dance to deref
 632          * ksnc_sock... */
 633         LASSERT(!conn->ksnc_closing);
 634         LASSERT(tx->tx_resid == tx->tx_nob);
 635
 636         CDEBUG (D_NET, "Sending to "LPX64" ip %d.%d.%d.%d:%d\n",
 637                 conn->ksnc_peer->ksnp_nid,
 638                 HIPQUAD(conn->ksnc_ipaddr),
 639                 conn->ksnc_port);
 640
 641         atomic_add (tx->tx_nob, &conn->ksnc_tx_nob);
 642         tx->tx_conn = conn;
 643
 644 #if SOCKNAL_ZC
 645         zccd_init (&tx->tx_zccd, ksocknal_zc_callback);
 646         /* NB this sets 1 ref on zccd, so the callback can only occur after
 647          * I've released this ref. */
 648 #endif
 649         spin_lock_irqsave (&sched->kss_lock, flags);
 650
 651         if (list_empty(&conn->ksnc_tx_queue) &&
 652             SOCK_WMEM_QUEUED(conn->ksnc_sock) == 0) {
 653                 /* First packet starts the timeout */
 654                 conn->ksnc_tx_deadline = cfs_time_shift(ksocknal_tunables.ksnd_io_timeout);
 655                 conn->ksnc_tx_bufnob = 0;
 656                 mb();    /* order with adding to tx_queue */
 657         }
 658
 659         list_add_tail (&tx->tx_list, &conn->ksnc_tx_queue);
 660
 661         if (conn->ksnc_tx_ready &&      /* able to send */
 662             !conn->ksnc_tx_scheduled) { /* not scheduled to send */
 663                 /* +1 ref for scheduler */
 664                 atomic_inc (&conn->ksnc_refcount);
 665                 list_add_tail (&conn->ksnc_tx_list,
 666                                &sched->kss_tx_conns);
 667                 conn->ksnc_tx_scheduled = 1;
 668                 cfs_waitq_signal (&sched->kss_waitq);
 669         }
 670
 671         spin_unlock_irqrestore (&sched->kss_lock, flags);
 672 }
 673
 674 ksock_route_t *
 675 ksocknal_find_connectable_route_locked (ksock_peer_t *peer)
 676 {
 677         struct list_head  *tmp;
 678         ksock_route_t     *route;
 679         int                bits;
 680
 681         list_for_each (tmp, &peer->ksnp_routes) {
 682                 route = list_entry (tmp, ksock_route_t, ksnr_list);
 683                 bits  = route->ksnr_connected;
 684
 685                 /* All typed connections established? */
 686                 if ((bits & KSNR_TYPED_ROUTES) == KSNR_TYPED_ROUTES)
 687                         continue;
 688
 689                 /* Untyped connection established? */
 690                 if ((bits & (1 << SOCKNAL_CONN_ANY)) != 0)
 691                         continue;
 692
 693                 /* connection being established? */
 694                 if (route->ksnr_connecting != 0)
 695                         continue;
 696
 697                 /* too soon to retry this guy? */
 698                 if (!cfs_time_aftereq (cfs_time_current(), route->ksnr_timeout))
 699                         continue;
 700
 701                 return (route);
 702         }
 703
 704         return (NULL);
 705 }
 706
 707 ksock_route_t *
 708 ksocknal_find_connecting_route_locked (ksock_peer_t *peer)
 709 {
 710         struct list_head  *tmp;
 711         ksock_route_t     *route;
 712
 713         list_for_each (tmp, &peer->ksnp_routes) {
 714                 route = list_entry (tmp, ksock_route_t, ksnr_list);
 715
 716                 if (route->ksnr_connecting != 0)
 717                         return (route);
 718         }
 719
 720         return (NULL);
 721 }
 722
 723 int
 724 ksocknal_launch_packet (ksock_tx_t *tx, ptl_nid_t nid)
 725 {
 726         unsigned long     flags;
 727         ksock_peer_t     *peer;
 728         ksock_conn_t     *conn;
 729         ksock_route_t    *route;
 730         rwlock_t         *g_lock;
 731
 732         /* Ensure the frags we've been given EXACTLY match the number of
 733          * bytes we want to send.  Many TCP/IP stacks disregard any total
 734          * size parameters passed to them and just look at the frags.
 735          *
 736          * We always expect at least 1 mapped fragment containing the
 737          * complete portals header. */
 738         LASSERT (lib_iov_nob (tx->tx_niov, tx->tx_iov) +
 739                  lib_kiov_nob (tx->tx_nkiov, tx->tx_kiov) == tx->tx_nob);
 740         LASSERT (tx->tx_niov >= 1);
 741         LASSERT (tx->tx_iov[0].iov_len >= sizeof (ptl_hdr_t));
 742
 743         CDEBUG (D_NET, "packet %p type %d, nob %d niov %d nkiov %d\n",
 744                 tx, ((ptl_hdr_t *)tx->tx_iov[0].iov_base)->type,
 745                 tx->tx_nob, tx->tx_niov, tx->tx_nkiov);
 746
 747         tx->tx_conn = NULL;                     /* only set when assigned a conn */
 748         tx->tx_resid = tx->tx_nob;
 749         tx->tx_hdr = (ptl_hdr_t *)tx->tx_iov[0].iov_base;
 750
 751         g_lock = &ksocknal_data.ksnd_global_lock;
 752 #if !SOCKNAL_ROUND_ROBIN
 753         read_lock (g_lock);
 754
 755         peer = ksocknal_find_target_peer_locked (tx, nid);
 756         if (peer == NULL) {
 757                 read_unlock (g_lock);
 758                 return (-EHOSTUNREACH);
 759         }
 760
 761         if (ksocknal_find_connectable_route_locked(peer) == NULL) {
 762                 conn = ksocknal_find_conn_locked (tx, peer);
 763                 if (conn != NULL) {
 764                         /* I've got no autoconnect routes that need to be
 765                          * connecting and I do have an actual connection... */
 766                         ksocknal_queue_tx_locked (tx, conn);
 767                         read_unlock (g_lock);
 768                         return (0);
 769                 }
 770         }
 771
 772         /* I'll need a write lock... */
 773         read_unlock (g_lock);
 774 #endif
 775         write_lock_irqsave(g_lock, flags);
 776
 777         peer = ksocknal_find_target_peer_locked (tx, nid);
 778         if (peer == NULL) {
 779                 write_unlock_irqrestore(g_lock, flags);
 780                 return (-EHOSTUNREACH);
 781         }
 782
 783         for (;;) {
 784                 /* launch any/all autoconnections that need it */
 785                 route = ksocknal_find_connectable_route_locked (peer);
 786                 if (route == NULL)
 787                         break;
 788
 789                 ksocknal_launch_autoconnect_locked (route);
 790         }
 791
 792         conn = ksocknal_find_conn_locked (tx, peer);
 793         if (conn != NULL) {
 794                 /* Connection exists; queue message on it */
 795                 ksocknal_queue_tx_locked (tx, conn);
 796                 write_unlock_irqrestore (g_lock, flags);
 797                 return (0);
 798         }
 799
 800         route = ksocknal_find_connecting_route_locked (peer);
 801         if (route != NULL) {
 802                 /* At least 1 connection is being established; queue the
 803                  * message... */
 804                 list_add_tail (&tx->tx_list, &peer->ksnp_tx_queue);
 805                 write_unlock_irqrestore (g_lock, flags);
 806                 return (0);
 807         }
 808
 809         write_unlock_irqrestore (g_lock, flags);
 810         return (-EHOSTUNREACH);
 811 }
 812
 813 ptl_err_t
 814 ksocknal_sendmsg(lib_nal_t     *nal,
 815                  void         *private,
 816                  lib_msg_t    *cookie,
 817                  ptl_hdr_t    *hdr,
 818                  int           type,
 819                  ptl_nid_t     nid,
 820                  ptl_pid_t     pid,
 821                  unsigned int  payload_niov,
 822                  struct iovec *payload_iov,
 823                  ptl_kiov_t   *payload_kiov,
 824                  size_t        payload_offset,
 825                  size_t        payload_nob)
 826 {
 827         ksock_ltx_t  *ltx;
 828         int           desc_size;
 829         int           rc;
 830
 831         /* NB 'private' is different depending on what we're sending.
 832          * Just ignore it... */
 833
 834         CDEBUG(D_NET, "sending "LPSZ" bytes in %d frags to nid:"LPX64
 835                " pid %d\n", payload_nob, payload_niov, nid , pid);
 836
 837         LASSERT (payload_nob == 0 || payload_niov > 0);
 838         LASSERT (payload_niov <= PTL_MD_MAX_IOV);
 839
 840         /* It must be OK to kmap() if required */
 841         LASSERT (payload_kiov == NULL || !in_interrupt ());
 842         /* payload is either all vaddrs or all pages */
 843         LASSERT (!(payload_kiov != NULL && payload_iov != NULL));
 844
 845         if (payload_iov != NULL)
 846                 desc_size = offsetof(ksock_ltx_t, ltx_iov[1 + payload_niov]);
 847         else
 848                 desc_size = offsetof(ksock_ltx_t, ltx_kiov[payload_niov]);
 849
 850         if (in_interrupt() ||
 851             type == PTL_MSG_ACK ||
 852             type == PTL_MSG_REPLY) {
 853                 /* Can't block if in interrupt or responding to an incoming
 854                  * message */
 855                 PORTAL_ALLOC_ATOMIC(ltx, desc_size);
 856         } else {
 857                 PORTAL_ALLOC(ltx, desc_size);
 858         }
 859
 860         if (ltx == NULL) {
 861                 CERROR("Can't allocate tx desc type %d size %d %s\n",
 862                        type, desc_size, in_interrupt() ? "(intr)" : "");
 863                 return (PTL_NO_SPACE);
 864         }
 865
 866         atomic_inc(&ksocknal_data.ksnd_nactive_ltxs);
 867
 868         ltx->ltx_desc_size = desc_size;
 869
 870         /* We always have 1 mapped frag for the header */
 871         ltx->ltx_tx.tx_iov = ltx->ltx_iov;
 872         ltx->ltx_iov[0].iov_base = &ltx->ltx_hdr;
 873         ltx->ltx_iov[0].iov_len = sizeof(*hdr);
 874         ltx->ltx_hdr = *hdr;
 875
 876         ltx->ltx_private = private;
 877         ltx->ltx_cookie = cookie;
 878
 879         ltx->ltx_tx.tx_isfwd = 0;
 880         ltx->ltx_tx.tx_nob = sizeof (*hdr) + payload_nob;
 881
 882         if (payload_iov != NULL) {
 883                 /* payload is all mapped */
 884                 ltx->ltx_tx.tx_kiov  = NULL;
 885                 ltx->ltx_tx.tx_nkiov = 0;
 886
 887                 ltx->ltx_tx.tx_niov =
 888                         1 + lib_extract_iov(payload_niov, &ltx->ltx_iov[1],
 889                                             payload_niov, payload_iov,
 890                                             payload_offset, payload_nob);
 891         } else {
 892                 /* payload is all pages */
 893                 ltx->ltx_tx.tx_niov = 1;
 894
 895                 ltx->ltx_tx.tx_kiov = ltx->ltx_kiov;
 896                 ltx->ltx_tx.tx_nkiov =
 897                         lib_extract_kiov(payload_niov, ltx->ltx_kiov,
 898                                          payload_niov, payload_kiov,
 899                                          payload_offset, payload_nob);
 900         }
 901
 902         rc = ksocknal_launch_packet(&ltx->ltx_tx, nid);
 903         if (rc == 0)
 904                 return (PTL_OK);
 905
 906         ksocknal_free_ltx(ltx);
 907         return (PTL_FAIL);
 908 }
 909
 910 ptl_err_t
 911 ksocknal_send (lib_nal_t *nal, void *private, lib_msg_t *cookie,
 912                ptl_hdr_t *hdr, int type, ptl_nid_t nid, ptl_pid_t pid,
 913                unsigned int payload_niov, struct iovec *payload_iov,
 914                size_t payload_offset, size_t payload_len)
 915 {
 916         return (ksocknal_sendmsg(nal, private, cookie,
 917                                  hdr, type, nid, pid,
 918                                  payload_niov, payload_iov, NULL,
 919                                  payload_offset, payload_len));
 920 }
 921
 922 ptl_err_t
 923 ksocknal_send_pages (lib_nal_t *nal, void *private, lib_msg_t *cookie,
 924                      ptl_hdr_t *hdr, int type, ptl_nid_t nid, ptl_pid_t pid,
 925                      unsigned int payload_niov, ptl_kiov_t *payload_kiov,
 926                      size_t payload_offset, size_t payload_len)
 927 {
 928         return (ksocknal_sendmsg(nal, private, cookie,
 929                                  hdr, type, nid, pid,
 930                                  payload_niov, NULL, payload_kiov,
 931                                  payload_offset, payload_len));
 932 }
 933
 934 void
 935 ksocknal_fwd_packet (void *arg, kpr_fwd_desc_t *fwd)
 936 {
 937         ptl_nid_t     nid = fwd->kprfd_gateway_nid;
 938         ksock_ftx_t  *ftx = (ksock_ftx_t *)&fwd->kprfd_scratch;
 939         int           rc;
 940
 941         CDEBUG (D_NET, "Forwarding [%p] -> "LPX64" ("LPX64"))\n", fwd,
 942                 fwd->kprfd_gateway_nid, fwd->kprfd_target_nid);
 943
 944         /* I'm the gateway; must be the last hop */
 945         if (nid == ksocknal_lib.libnal_ni.ni_pid.nid)
 946                 nid = fwd->kprfd_target_nid;
 947
 948         /* setup iov for hdr */
 949         ftx->ftx_iov.iov_base = fwd->kprfd_hdr;
 950         ftx->ftx_iov.iov_len = sizeof(ptl_hdr_t);
 951
 952         ftx->ftx_tx.tx_isfwd = 1;                  /* This is a forwarding packet */
 953         ftx->ftx_tx.tx_nob   = sizeof(ptl_hdr_t) + fwd->kprfd_nob;
 954         ftx->ftx_tx.tx_niov  = 1;
 955         ftx->ftx_tx.tx_iov   = &ftx->ftx_iov;
 956         ftx->ftx_tx.tx_nkiov = fwd->kprfd_niov;
 957         ftx->ftx_tx.tx_kiov  = fwd->kprfd_kiov;
 958
 959         rc = ksocknal_launch_packet (&ftx->ftx_tx, nid);
 960         if (rc != 0)
 961                 kpr_fwd_done (&ksocknal_data.ksnd_router, fwd, rc);
 962 }
 963
 964 int
 965 ksocknal_thread_start (int (*fn)(void *arg), void *arg)
 966 {
 967         long          pid = cfs_kernel_thread (fn, arg, 0);
 968         unsigned long flags;
 969
 970         if (pid < 0)
 971                 return ((int)pid);
 972
 973         write_lock_irqsave(&ksocknal_data.ksnd_global_lock, flags);
 974         ksocknal_data.ksnd_nthreads++;
 975         write_unlock_irqrestore(&ksocknal_data.ksnd_global_lock, flags);
 976         return (0);
 977 }
 978
 979 void
 980 ksocknal_thread_fini (void)
 981 {
 982         unsigned long flags;
 983
 984         write_lock_irqsave(&ksocknal_data.ksnd_global_lock, flags);
 985         ksocknal_data.ksnd_nthreads--;
 986         write_unlock_irqrestore(&ksocknal_data.ksnd_global_lock, flags);
 987 }
 988
 989 void
 990 ksocknal_fmb_callback (void *arg, int error)
 991 {
 992         ksock_fmb_t       *fmb = (ksock_fmb_t *)arg;
 993         ksock_fmb_pool_t  *fmp = fmb->fmb_pool;
 994         ptl_hdr_t         *hdr = &fmb->fmb_hdr;
 995         ksock_conn_t      *conn = NULL;
 996         ksock_sched_t     *sched;
 997         unsigned long      flags;
 998         char               ipbuf[PTL_NALFMT_SIZE];
 999         char               ipbuf2[PTL_NALFMT_SIZE];
1000
1001         if (error != 0)
1002                 CERROR("Failed to route packet from "
1003                        LPX64" %s to "LPX64" %s: %d\n",
1004                        le64_to_cpu(hdr->src_nid),
1005                        portals_nid2str(SOCKNAL, le64_to_cpu(hdr->src_nid), ipbuf),
1006                        le64_to_cpu(hdr->dest_nid),
1007                        portals_nid2str(SOCKNAL, le64_to_cpu(hdr->dest_nid), ipbuf2),
1008                        error);
1009         else
1010                 CDEBUG (D_NET, "routed packet from "LPX64" to "LPX64": OK\n",
1011                         le64_to_cpu(hdr->src_nid), le64_to_cpu(hdr->dest_nid));
1012
1013         /* drop peer ref taken on init */
1014         ksocknal_put_peer (fmb->fmb_peer);
1015
1016         spin_lock_irqsave (&fmp->fmp_lock, flags);
1017
1018         list_add (&fmb->fmb_list, &fmp->fmp_idle_fmbs);
1019         fmp->fmp_nactive_fmbs--;
1020
1021         if (!list_empty (&fmp->fmp_blocked_conns)) {
1022                 conn = list_entry (fmb->fmb_pool->fmp_blocked_conns.next,
1023                                    ksock_conn_t, ksnc_rx_list);
1024                 list_del (&conn->ksnc_rx_list);
1025         }
1026
1027         spin_unlock_irqrestore (&fmp->fmp_lock, flags);
1028
1029         if (conn == NULL)
1030                 return;
1031
1032         CDEBUG (D_NET, "Scheduling conn %p\n", conn);
1033         LASSERT (conn->ksnc_rx_scheduled);
1034         LASSERT (conn->ksnc_rx_state == SOCKNAL_RX_FMB_SLEEP);
1035
1036         conn->ksnc_rx_state = SOCKNAL_RX_GET_FMB;
1037
1038         sched = conn->ksnc_scheduler;
1039
1040         spin_lock_irqsave (&sched->kss_lock, flags);
1041
1042         list_add_tail (&conn->ksnc_rx_list, &sched->kss_rx_conns);
1043         cfs_waitq_signal (&sched->kss_waitq);
1044
1045         spin_unlock_irqrestore (&sched->kss_lock, flags);
1046 }
1047
1048 ksock_fmb_t *
1049 ksocknal_get_idle_fmb (ksock_conn_t *conn)
1050 {
1051         int               payload_nob = conn->ksnc_rx_nob_left;
1052         unsigned long     flags;
1053         ksock_fmb_pool_t *pool;
1054         ksock_fmb_t      *fmb;
1055
1056         LASSERT (conn->ksnc_rx_state == SOCKNAL_RX_GET_FMB);
1057         LASSERT (kpr_routing(&ksocknal_data.ksnd_router));
1058
1059         if (payload_nob <= SOCKNAL_SMALL_FWD_PAGES * CFS_PAGE_SIZE)
1060                 pool = &ksocknal_data.ksnd_small_fmp;
1061         else
1062                 pool = &ksocknal_data.ksnd_large_fmp;
1063
1064         spin_lock_irqsave (&pool->fmp_lock, flags);
1065
1066         if (!list_empty (&pool->fmp_idle_fmbs)) {
1067                 fmb = list_entry(pool->fmp_idle_fmbs.next,
1068                                  ksock_fmb_t, fmb_list);
1069                 list_del (&fmb->fmb_list);
1070                 pool->fmp_nactive_fmbs++;
1071                 spin_unlock_irqrestore (&pool->fmp_lock, flags);
1072
1073                 return (fmb);
1074         }
1075
1076         /* deschedule until fmb free */
1077
1078         conn->ksnc_rx_state = SOCKNAL_RX_FMB_SLEEP;
1079
1080         list_add_tail (&conn->ksnc_rx_list,
1081                        &pool->fmp_blocked_conns);
1082
1083         spin_unlock_irqrestore (&pool->fmp_lock, flags);
1084         return (NULL);
1085 }
1086
1087 int
1088 ksocknal_init_fmb (ksock_conn_t *conn, ksock_fmb_t *fmb)
1089 {
1090         int       payload_nob = conn->ksnc_rx_nob_left;
1091         ptl_nid_t dest_nid = le64_to_cpu(conn->ksnc_hdr.dest_nid);
1092         int       niov = 0;
1093         int       nob = payload_nob;
1094
1095         LASSERT (conn->ksnc_rx_scheduled);
1096         LASSERT (conn->ksnc_rx_state == SOCKNAL_RX_GET_FMB);
1097         LASSERT (conn->ksnc_rx_nob_wanted == conn->ksnc_rx_nob_left);
1098         LASSERT (payload_nob >= 0);
1099         LASSERT (payload_nob <= fmb->fmb_pool->fmp_buff_pages * CFS_PAGE_SIZE);
1100         LASSERT (sizeof (ptl_hdr_t) < CFS_PAGE_SIZE);
1101         LASSERT (fmb->fmb_kiov[0].kiov_offset == 0);
1102
1103         /* Take a ref on the conn's peer to prevent module unload before
1104          * forwarding completes. */
1105         fmb->fmb_peer = conn->ksnc_peer;
1106         atomic_inc (&conn->ksnc_peer->ksnp_refcount);
1107
1108         /* Copy the header we just read into the forwarding buffer.  If
1109          * there's payload, start reading reading it into the buffer,
1110          * otherwise the forwarding buffer can be kicked off
1111          * immediately. */
1112         fmb->fmb_hdr = conn->ksnc_hdr;
1113
1114         while (nob > 0) {
1115                 LASSERT (niov < fmb->fmb_pool->fmp_buff_pages);
1116                 LASSERT (fmb->fmb_kiov[niov].kiov_offset == 0);
1117                 fmb->fmb_kiov[niov].kiov_len = MIN (CFS_PAGE_SIZE, nob);
1118                 nob -= CFS_PAGE_SIZE;
1119                 niov++;
1120         }
1121
1122         kpr_fwd_init(&fmb->fmb_fwd, dest_nid, &fmb->fmb_hdr,
1123                      payload_nob, niov, fmb->fmb_kiov,
1124                      ksocknal_fmb_callback, fmb);
1125
1126         if (payload_nob == 0) {         /* got complete packet already */
1127                 CDEBUG (D_NET, "%p "LPX64"->"LPX64" fwd_start (immediate)\n",
1128                         conn, le64_to_cpu(conn->ksnc_hdr.src_nid), dest_nid);
1129
1130                 kpr_fwd_start (&ksocknal_data.ksnd_router, &fmb->fmb_fwd);
1131
1132                 ksocknal_new_packet (conn, 0);  /* on to next packet */
1133                 return (1);
1134         }
1135
1136         conn->ksnc_cookie = fmb;                /* stash fmb for later */
1137         conn->ksnc_rx_state = SOCKNAL_RX_BODY_FWD; /* read in the payload */
1138
1139         /* Set up conn->ksnc_rx_kiov to read the payload into fmb's kiov-ed
1140          * buffer */
1141         LASSERT (niov <= sizeof(conn->ksnc_rx_iov_space)/sizeof(ptl_kiov_t));
1142
1143         conn->ksnc_rx_niov = 0;
1144         conn->ksnc_rx_nkiov = niov;
1145         conn->ksnc_rx_kiov = conn->ksnc_rx_iov_space.kiov;
1146         memcpy(conn->ksnc_rx_kiov, fmb->fmb_kiov, niov * sizeof(ptl_kiov_t));
1147
1148         CDEBUG (D_NET, "%p "LPX64"->"LPX64" %d reading body\n", conn,
1149                 le64_to_cpu(conn->ksnc_hdr.src_nid), dest_nid, payload_nob);
1150         return (0);
1151 }
1152
1153 void
1154 ksocknal_fwd_parse (ksock_conn_t *conn)
1155 {
1156         ksock_peer_t *peer;
1157         ptl_nid_t     dest_nid = le64_to_cpu(conn->ksnc_hdr.dest_nid);
1158         ptl_nid_t     src_nid = le64_to_cpu(conn->ksnc_hdr.src_nid);
1159         int           body_len = le32_to_cpu(conn->ksnc_hdr.payload_length);
1160         char str[PTL_NALFMT_SIZE];
1161         char str2[PTL_NALFMT_SIZE];
1162
1163         CDEBUG (D_NET, "%p "LPX64"->"LPX64" %d parsing header\n", conn,
1164                 src_nid, dest_nid, conn->ksnc_rx_nob_left);
1165
1166         LASSERT (conn->ksnc_rx_state == SOCKNAL_RX_HEADER);
1167         LASSERT (conn->ksnc_rx_scheduled);
1168
1169         if (body_len < 0) {                 /* length corrupt (overflow) */
1170                 CERROR("dropping packet from "LPX64" (%s) for "LPX64" (%s): "
1171                        "packet size %d illegal\n",
1172                        src_nid, portals_nid2str(TCPNAL, src_nid, str),
1173                        dest_nid, portals_nid2str(TCPNAL, dest_nid, str2),
1174                        body_len);
1175
1176                 ksocknal_new_packet (conn, 0);  /* on to new packet */
1177                 return;
1178         }
1179
1180         if (!kpr_routing(&ksocknal_data.ksnd_router)) {    /* not forwarding */
1181                 CERROR("dropping packet from "LPX64" (%s) for "LPX64
1182                        " (%s): not forwarding\n",
1183                        src_nid, portals_nid2str(TCPNAL, src_nid, str),
1184                        dest_nid, portals_nid2str(TCPNAL, dest_nid, str2));
1185                 /* on to new packet (skip this one's body) */
1186                 ksocknal_new_packet (conn, body_len);
1187                 return;
1188         }
1189
1190         if (body_len > PTL_MTU) {      /* too big to forward */
1191                 CERROR ("dropping packet from "LPX64" (%s) for "LPX64
1192                         "(%s): packet size %d too big\n",
1193                         src_nid, portals_nid2str(TCPNAL, src_nid, str),
1194                         dest_nid, portals_nid2str(TCPNAL, dest_nid, str2),
1195                         body_len);
1196                 /* on to new packet (skip this one's body) */
1197                 ksocknal_new_packet (conn, body_len);
1198                 return;
1199         }
1200
1201         /* should have gone direct */
1202         peer = ksocknal_get_peer (conn->ksnc_hdr.dest_nid);
1203         if (peer != NULL) {
1204                 CERROR ("dropping packet from "LPX64" (%s) for "LPX64
1205                         "(%s): target is a peer\n",
1206                         src_nid, portals_nid2str(TCPNAL, src_nid, str),
1207                         dest_nid, portals_nid2str(TCPNAL, dest_nid, str2));
1208                 ksocknal_put_peer (peer);  /* drop ref from get above */
1209
1210                 /* on to next packet (skip this one's body) */
1211                 ksocknal_new_packet (conn, body_len);
1212                 return;
1213         }
1214
1215         conn->ksnc_rx_state = SOCKNAL_RX_GET_FMB;       /* Getting FMB now */
1216         conn->ksnc_rx_nob_left = body_len;              /* stash packet size */
1217         conn->ksnc_rx_nob_wanted = body_len;            /* (no slop) */
1218 }
1219
1220 int
1221 ksocknal_new_packet (ksock_conn_t *conn, int nob_to_skip)
1222 {
1223         static char ksocknal_slop_buffer[4096];
1224
1225         int   nob;
1226         int   niov;
1227         int   skipped;
1228
1229         if (nob_to_skip == 0) {         /* right at next packet boundary now */
1230                 conn->ksnc_rx_started = 0;
1231                 mb ();                          /* racing with timeout thread */
1232
1233                 conn->ksnc_rx_state = SOCKNAL_RX_HEADER;
1234                 conn->ksnc_rx_nob_wanted = sizeof (ptl_hdr_t);
1235                 conn->ksnc_rx_nob_left = sizeof (ptl_hdr_t);
1236
1237                 conn->ksnc_rx_iov = (struct iovec *)&conn->ksnc_rx_iov_space;
1238                 conn->ksnc_rx_iov[0].iov_base = (char *)&conn->ksnc_hdr;
1239                 conn->ksnc_rx_iov[0].iov_len  = sizeof (ptl_hdr_t);
1240                 conn->ksnc_rx_niov = 1;
1241
1242                 conn->ksnc_rx_kiov = NULL;
1243                 conn->ksnc_rx_nkiov = 0;
1244                 return (1);
1245         }
1246
1247         /* Set up to skip as much a possible now.  If there's more left
1248          * (ran out of iov entries) we'll get called again */
1249
1250         conn->ksnc_rx_state = SOCKNAL_RX_SLOP;
1251         conn->ksnc_rx_nob_left = nob_to_skip;
1252         conn->ksnc_rx_iov = (struct iovec *)&conn->ksnc_rx_iov_space;
1253         skipped = 0;
1254         niov = 0;
1255
1256         do {
1257                 nob = MIN (nob_to_skip, sizeof (ksocknal_slop_buffer));
1258
1259                 conn->ksnc_rx_iov[niov].iov_base = ksocknal_slop_buffer;
1260                 conn->ksnc_rx_iov[niov].iov_len  = nob;
1261                 niov++;
1262                 skipped += nob;
1263                 nob_to_skip -=nob;
1264
1265         } while (nob_to_skip != 0 &&    /* mustn't overflow conn's rx iov */
1266                  niov < sizeof(conn->ksnc_rx_iov_space) / sizeof (struct iovec));
1267
1268         conn->ksnc_rx_niov = niov;
1269         conn->ksnc_rx_kiov = NULL;
1270         conn->ksnc_rx_nkiov = 0;
1271         conn->ksnc_rx_nob_wanted = skipped;
1272         return (0);
1273 }
1274
1275 int
1276 ksocknal_process_receive (ksock_conn_t *conn)
1277 {
1278         ksock_fmb_t  *fmb;
1279         int           rc;
1280
1281         LASSERT (atomic_read (&conn->ksnc_refcount) > 0);
1282
1283         /* doesn't need a forwarding buffer */
1284         if (conn->ksnc_rx_state != SOCKNAL_RX_GET_FMB)
1285                 goto try_read;
1286
1287  get_fmb:
1288         fmb = ksocknal_get_idle_fmb (conn);
1289         if (fmb == NULL) {
1290                 /* conn descheduled waiting for idle fmb */
1291                 return (0);
1292         }
1293
1294         if (ksocknal_init_fmb (conn, fmb)) {
1295                 /* packet forwarded */
1296                 return (0);
1297         }
1298
1299  try_read:
1300         /* NB: sched lock NOT held */
1301         LASSERT (conn->ksnc_rx_state == SOCKNAL_RX_HEADER ||
1302                  conn->ksnc_rx_state == SOCKNAL_RX_BODY ||
1303                  conn->ksnc_rx_state == SOCKNAL_RX_BODY_FWD ||
1304                  conn->ksnc_rx_state == SOCKNAL_RX_SLOP);
1305
1306         LASSERT (conn->ksnc_rx_nob_wanted > 0);
1307
1308         rc = ksocknal_receive(conn);
1309
1310         if (rc <= 0) {
1311                 LASSERT (rc != -EAGAIN);
1312
1313                 if (rc == 0)
1314                         CWARN ("[%p] EOF from "LPX64" ip %d.%d.%d.%d:%d\n",
1315                                conn, conn->ksnc_peer->ksnp_nid,
1316                                HIPQUAD(conn->ksnc_ipaddr),
1317                                conn->ksnc_port);
1318                 else if (!conn->ksnc_closing)
1319                         CERROR ("[%p] Error %d on read from "LPX64
1320                                 " ip %d.%d.%d.%d:%d\n",
1321                                 conn, rc, conn->ksnc_peer->ksnp_nid,
1322                                 HIPQUAD(conn->ksnc_ipaddr),
1323                                 conn->ksnc_port);
1324
1325                 ksocknal_close_conn_and_siblings (conn, rc);
1326                 return (rc == 0 ? -ESHUTDOWN : rc);
1327         }
1328
1329         if (conn->ksnc_rx_nob_wanted != 0) {
1330                 /* short read */
1331                 return (-EAGAIN);
1332         }
1333
1334         switch (conn->ksnc_rx_state) {
1335         case SOCKNAL_RX_HEADER:
1336                 if (conn->ksnc_hdr.type != cpu_to_le32(PTL_MSG_HELLO) &&
1337                     le64_to_cpu(conn->ksnc_hdr.dest_nid) !=
1338                     ksocknal_lib.libnal_ni.ni_pid.nid) {
1339                         /* This packet isn't for me */
1340                         ksocknal_fwd_parse (conn);
1341                         switch (conn->ksnc_rx_state) {
1342                         case SOCKNAL_RX_HEADER: /* skipped (zero payload) */
1343                                 return (0);     /* => come back later */
1344                         case SOCKNAL_RX_SLOP:   /* skipping packet's body */
1345                                 goto try_read;  /* => go read it */
1346                         case SOCKNAL_RX_GET_FMB: /* forwarding */
1347                                 goto get_fmb;   /* => go get a fwd msg buffer */
1348                         default:
1349                                 LBUG ();
1350                         }
1351                         /* Not Reached */
1352                 }
1353
1354                 /* sets wanted_len, iovs etc */
1355                 rc = lib_parse(&ksocknal_lib, &conn->ksnc_hdr, conn);
1356
1357                 if (rc != PTL_OK) {
1358                         /* I just received garbage: give up on this conn */
1359                         ksocknal_close_conn_and_siblings (conn, rc);
1360                         return (-EPROTO);
1361                 }
1362
1363                 if (conn->ksnc_rx_nob_wanted != 0) { /* need to get payload? */
1364                         conn->ksnc_rx_state = SOCKNAL_RX_BODY;
1365                         goto try_read;          /* go read the payload */
1366                 }
1367                 /* Fall through (completed packet for me) */
1368
1369         case SOCKNAL_RX_BODY:
1370                 /* payload all received */
1371                 lib_finalize(&ksocknal_lib, NULL, conn->ksnc_cookie, PTL_OK);
1372                 /* Fall through */
1373
1374         case SOCKNAL_RX_SLOP:
1375                 /* starting new packet? */
1376                 if (ksocknal_new_packet (conn, conn->ksnc_rx_nob_left))
1377                         return (0);     /* come back later */
1378                 goto try_read;          /* try to finish reading slop now */
1379
1380         case SOCKNAL_RX_BODY_FWD:
1381                 /* payload all received */
1382                 CDEBUG (D_NET, "%p "LPX64"->"LPX64" %d fwd_start (got body)\n",
1383                         conn, le64_to_cpu(conn->ksnc_hdr.src_nid),
1384                         le64_to_cpu(conn->ksnc_hdr.dest_nid),
1385                         conn->ksnc_rx_nob_left);
1386
1387                 /* forward the packet. NB ksocknal_init_fmb() put fmb into
1388                  * conn->ksnc_cookie */
1389                 fmb = (ksock_fmb_t *)conn->ksnc_cookie;
1390                 kpr_fwd_start (&ksocknal_data.ksnd_router, &fmb->fmb_fwd);
1391
1392                 /* no slop in forwarded packets */
1393                 LASSERT (conn->ksnc_rx_nob_left == 0);
1394
1395                 ksocknal_new_packet (conn, 0);  /* on to next packet */
1396                 return (0);                     /* (later) */
1397
1398         default:
1399                 break;
1400         }
1401
1402         /* Not Reached */
1403         LBUG ();
1404         return (-EINVAL);                       /* keep gcc happy */
1405 }
1406
1407 ptl_err_t
1408 ksocknal_recv (lib_nal_t *nal, void *private, lib_msg_t *msg,
1409                unsigned int niov, struct iovec *iov,
1410                size_t offset, size_t mlen, size_t rlen)
1411 {
1412         ksock_conn_t *conn = (ksock_conn_t *)private;
1413
1414         LASSERT (mlen <= rlen);
1415         LASSERT (niov <= PTL_MD_MAX_IOV);
1416
1417         conn->ksnc_cookie = msg;
1418         conn->ksnc_rx_nob_wanted = mlen;
1419         conn->ksnc_rx_nob_left   = rlen;
1420
1421         conn->ksnc_rx_nkiov = 0;
1422         conn->ksnc_rx_kiov = NULL;
1423         conn->ksnc_rx_iov = conn->ksnc_rx_iov_space.iov;
1424         conn->ksnc_rx_niov =
1425                 lib_extract_iov(PTL_MD_MAX_IOV, conn->ksnc_rx_iov,
1426                                 niov, iov, offset, mlen);
1427
1428         LASSERT (mlen ==
1429                  lib_iov_nob (conn->ksnc_rx_niov, conn->ksnc_rx_iov) +
1430                  lib_kiov_nob (conn->ksnc_rx_nkiov, conn->ksnc_rx_kiov));
1431
1432         return (PTL_OK);
1433 }
1434
1435 ptl_err_t
1436 ksocknal_recv_pages (lib_nal_t *nal, void *private, lib_msg_t *msg,
1437                      unsigned int niov, ptl_kiov_t *kiov,
1438                      size_t offset, size_t mlen, size_t rlen)
1439 {
1440         ksock_conn_t *conn = (ksock_conn_t *)private;
1441
1442         LASSERT (mlen <= rlen);
1443         LASSERT (niov <= PTL_MD_MAX_IOV);
1444
1445         conn->ksnc_cookie = msg;
1446         conn->ksnc_rx_nob_wanted = mlen;
1447         conn->ksnc_rx_nob_left   = rlen;
1448
1449         conn->ksnc_rx_niov = 0;
1450         conn->ksnc_rx_iov  = NULL;
1451         conn->ksnc_rx_kiov = conn->ksnc_rx_iov_space.kiov;
1452         conn->ksnc_rx_nkiov =
1453                 lib_extract_kiov(PTL_MD_MAX_IOV, conn->ksnc_rx_kiov,
1454                                  niov, kiov, offset, mlen);
1455
1456         LASSERT (mlen ==
1457                  lib_iov_nob (conn->ksnc_rx_niov, conn->ksnc_rx_iov) +
1458                  lib_kiov_nob (conn->ksnc_rx_nkiov, conn->ksnc_rx_kiov));
1459
1460         return (PTL_OK);
1461 }
1462
1463 static inline int
1464 ksocknal_sched_cansleep(ksock_sched_t *sched)
1465 {
1466         unsigned long flags;
1467         int           rc;
1468
1469         spin_lock_irqsave(&sched->kss_lock, flags);
1470
1471         rc = (!ksocknal_data.ksnd_shuttingdown &&
1472 #if SOCKNAL_ZC
1473               list_empty(&sched->kss_zctxdone_list) &&
1474 #endif
1475               list_empty(&sched->kss_rx_conns) &&
1476               list_empty(&sched->kss_tx_conns));
1477
1478         spin_unlock_irqrestore(&sched->kss_lock, flags);
1479         return (rc);
1480 }
1481
1482 int ksocknal_scheduler (void *arg)
1483 {
1484         ksock_sched_t     *sched = (ksock_sched_t *)arg;
1485         ksock_conn_t      *conn;
1486         ksock_tx_t        *tx;
1487         unsigned long      flags;
1488         int                rc;
1489         int                nloops = 0;
1490         int                id = sched - ksocknal_data.ksnd_schedulers;
1491         char               name[16];
1492
1493         snprintf (name, sizeof (name),"ksocknald_%02d", id);
1494         kportal_daemonize (name);
1495         kportal_blockallsigs ();
1496
1497 #if (CONFIG_SMP && CPU_AFFINITY)
1498         id = ksocknal_sched2cpu(id);
1499         if (cpu_online(id)) {
1500                 cpumask_t m;
1501                 cpu_set(id, m);
1502                 set_cpus_allowed(current, m);
1503         } else {
1504                 CERROR ("Can't set CPU affinity for %s to %d\n", name, id);
1505         }
1506 #endif /* CONFIG_SMP && CPU_AFFINITY */
1507
1508         spin_lock_irqsave (&sched->kss_lock, flags);
1509
1510         while (!ksocknal_data.ksnd_shuttingdown) {
1511                 int did_something = 0;
1512
1513                 /* Ensure I progress everything semi-fairly */
1514
1515                 if (!list_empty (&sched->kss_rx_conns)) {
1516                         conn = list_entry(sched->kss_rx_conns.next,
1517                                           ksock_conn_t, ksnc_rx_list);
1518                         list_del(&conn->ksnc_rx_list);
1519
1520                         LASSERT(conn->ksnc_rx_scheduled);
1521                         LASSERT(conn->ksnc_rx_ready);
1522
1523                         /* clear rx_ready in case receive isn't complete.
1524                          * Do it BEFORE we call process_recv, since
1525                          * data_ready can set it any time after we release
1526                          * kss_lock. */
1527                         conn->ksnc_rx_ready = 0;
1528                         spin_unlock_irqrestore(&sched->kss_lock, flags);
1529
1530                         rc = ksocknal_process_receive(conn);
1531
1532                         spin_lock_irqsave(&sched->kss_lock, flags);
1533
1534                         /* I'm the only one that can clear this flag */
1535                         LASSERT(conn->ksnc_rx_scheduled);
1536
1537                         /* Did process_receive get everything it wanted? */
1538                         if (rc == 0)
1539                                 conn->ksnc_rx_ready = 1;
1540
1541                         if (conn->ksnc_rx_state == SOCKNAL_RX_FMB_SLEEP ||
1542                             conn->ksnc_rx_state == SOCKNAL_RX_GET_FMB) {
1543                                 /* Conn blocked for a forwarding buffer.
1544                                  * It will get queued for my attention when
1545                                  * one becomes available (and it might just
1546                                  * already have been!).  Meanwhile my ref
1547                                  * on it stays put. */
1548                         } else if (conn->ksnc_rx_ready) {
1549                                 /* reschedule for rx */
1550                                 list_add_tail (&conn->ksnc_rx_list,
1551                                                &sched->kss_rx_conns);
1552                         } else {
1553                                 conn->ksnc_rx_scheduled = 0;
1554                                 /* drop my ref */
1555                                 ksocknal_put_conn(conn);
1556                         }
1557
1558                         did_something = 1;
1559                 }
1560
1561                 if (!list_empty (&sched->kss_tx_conns)) {
1562                         conn = list_entry(sched->kss_tx_conns.next,
1563                                           ksock_conn_t, ksnc_tx_list);
1564                         list_del (&conn->ksnc_tx_list);
1565
1566                         LASSERT(conn->ksnc_tx_scheduled);
1567                         LASSERT(conn->ksnc_tx_ready);
1568                         LASSERT(!list_empty(&conn->ksnc_tx_queue));
1569
1570                         tx = list_entry(conn->ksnc_tx_queue.next,
1571                                         ksock_tx_t, tx_list);
1572                         /* dequeue now so empty list => more to send */
1573                         list_del(&tx->tx_list);
1574
1575                         /* Clear tx_ready in case send isn't complete.  Do
1576                          * it BEFORE we call process_transmit, since
1577                          * write_space can set it any time after we release
1578                          * kss_lock. */
1579                         conn->ksnc_tx_ready = 0;
1580                         spin_unlock_irqrestore (&sched->kss_lock, flags);
1581
1582                         rc = ksocknal_process_transmit(conn, tx);
1583
1584                         spin_lock_irqsave (&sched->kss_lock, flags);
1585
1586                         if (rc == -ENOMEM || rc == -EAGAIN) {
1587                                 /* Incomplete send: replace tx on HEAD of tx_queue */
1588                                 list_add (&tx->tx_list, &conn->ksnc_tx_queue);
1589                         } else {
1590                                 /* Complete send; assume space for more */
1591                                 conn->ksnc_tx_ready = 1;
1592                         }
1593
1594                         if (rc == -ENOMEM) {
1595                                 /* Do nothing; after a short timeout, this
1596                                  * conn will be reposted on kss_tx_conns. */
1597                         } else if (conn->ksnc_tx_ready &&
1598                                    !list_empty (&conn->ksnc_tx_queue)) {
1599                                 /* reschedule for tx */
1600                                 list_add_tail (&conn->ksnc_tx_list,
1601                                                &sched->kss_tx_conns);
1602                         } else {
1603                                 conn->ksnc_tx_scheduled = 0;
1604                                 /* drop my ref */
1605                                 ksocknal_put_conn (conn);
1606                         }
1607
1608                         did_something = 1;
1609                 }
1610 #if SOCKNAL_ZC
1611                 if (!list_empty (&sched->kss_zctxdone_list)) {
1612                         ksock_tx_t *tx =
1613                                 list_entry(sched->kss_zctxdone_list.next,
1614                                            ksock_tx_t, tx_list);
1615                         did_something = 1;
1616
1617                         list_del (&tx->tx_list);
1618                         spin_unlock_irqrestore (&sched->kss_lock, flags);
1619
1620                         ksocknal_tx_done (tx, 1);
1621
1622                         spin_lock_irqsave (&sched->kss_lock, flags);
1623                 }
1624 #endif
1625                 if (!did_something ||           /* nothing to do */
1626                     ++nloops == SOCKNAL_RESCHED) { /* hogging CPU? */
1627                         spin_unlock_irqrestore (&sched->kss_lock, flags);
1628
1629                         nloops = 0;
1630
1631                         if (!did_something) {   /* wait for something to do */
1632                                 rc = wait_event_interruptible (sched->kss_waitq,
1633                                                                !ksocknal_sched_cansleep(sched));
1634                                 LASSERT (rc == 0);
1635                         } else
1636                                our_cond_resched();
1637
1638                         spin_lock_irqsave (&sched->kss_lock, flags);
1639                 }
1640         }
1641
1642         spin_unlock_irqrestore (&sched->kss_lock, flags);
1643         ksocknal_thread_fini ();
1644         return (0);
1645 }
1646
1647 /*
1648  * Add connection to kss_rx_conns of scheduler
1649  * and wakeup the scheduler.
1650  */
1651 void ksocknal_read_callback (ksock_conn_t *conn)
1652 {
1653         ksock_sched_t *sched;
1654         unsigned long  flags;
1655         ENTRY;
1656
1657         sched = conn->ksnc_scheduler;
1658
1659         spin_lock_irqsave (&sched->kss_lock, flags);
1660
1661         conn->ksnc_rx_ready = 1;
1662
1663         if (!conn->ksnc_rx_scheduled) {  /* not being progressed */
1664                 list_add_tail(&conn->ksnc_rx_list,
1665                               &sched->kss_rx_conns);
1666                 conn->ksnc_rx_scheduled = 1;
1667                 /* extra ref for scheduler */
1668                 atomic_inc (&conn->ksnc_refcount);
1669
1670                 cfs_waitq_signal (&sched->kss_waitq);
1671         }
1672         spin_unlock_irqrestore (&sched->kss_lock, flags);
1673
1674         EXIT;
1675 }
1676
1677 /*
1678  * Add connection to kss_tx_conns of scheduler
1679  * and wakeup the scheduler.
1680  */
1681 void ksocknal_write_callback (ksock_conn_t *conn)
1682 {
1683         ksock_sched_t *sched;
1684         unsigned long  flags;
1685         ENTRY;
1686
1687         sched = conn->ksnc_scheduler;
1688
1689         spin_lock_irqsave (&sched->kss_lock, flags);
1690
1691         conn->ksnc_tx_ready = 1;
1692
1693         if (!conn->ksnc_tx_scheduled && // not being progressed
1694             !list_empty(&conn->ksnc_tx_queue)){//packets to send
1695                 list_add_tail (&conn->ksnc_tx_list,
1696                                &sched->kss_tx_conns);
1697                 conn->ksnc_tx_scheduled = 1;
1698                 /* extra ref for scheduler */
1699                 atomic_inc (&conn->ksnc_refcount);
1700
1701                 cfs_waitq_signal (&sched->kss_waitq);
1702         }
1703
1704         spin_unlock_irqrestore (&sched->kss_lock, flags);
1705
1706         EXIT;
1707 }
1708
1709 int
1710 ksocknal_sock_write (struct socket *sock, void *buffer, int nob)
1711 {
1712         return ksocknal_lib_sock_write(sock, buffer, nob);
1713 }
1714
1715 int
1716 ksocknal_sock_read (struct socket *sock, void *buffer, int nob)
1717 {
1718         return ksocknal_lib_sock_read(sock, buffer, nob);
1719 }
1720
1721 int
1722 ksocknal_send_hello (ksock_conn_t *conn, __u32 *ipaddrs, int nipaddrs)
1723 {
1724         /* CAVEAT EMPTOR: this byte flips 'ipaddrs' */
1725         struct socket      *sock = conn->ksnc_sock;
1726         ptl_hdr_t           hdr;
1727         ptl_magicversion_t *hmv = (ptl_magicversion_t *)&hdr.dest_nid;
1728         int                 i;
1729         int                 rc;
1730
1731         LASSERT (conn->ksnc_type != SOCKNAL_CONN_NONE);
1732         LASSERT (nipaddrs <= SOCKNAL_MAX_INTERFACES);
1733
1734         /* No need for getconnsock/putconnsock */
1735         LASSERT (!conn->ksnc_closing);
1736
1737         LASSERT (sizeof (*hmv) == sizeof (hdr.dest_nid));
1738         hmv->magic         = cpu_to_le32 (PORTALS_PROTO_MAGIC);
1739         hmv->version_major = cpu_to_le16 (PORTALS_PROTO_VERSION_MAJOR);
1740         hmv->version_minor = cpu_to_le16 (PORTALS_PROTO_VERSION_MINOR);
1741
1742         hdr.src_nid        = cpu_to_le64 (ksocknal_lib.libnal_ni.ni_pid.nid);
1743         hdr.type           = cpu_to_le32 (PTL_MSG_HELLO);
1744         hdr.payload_length = cpu_to_le32 (nipaddrs * sizeof(*ipaddrs));
1745
1746         hdr.msg.hello.type = cpu_to_le32 (conn->ksnc_type);
1747         hdr.msg.hello.incarnation =
1748                 cpu_to_le64 (ksocknal_data.ksnd_incarnation);
1749
1750         /* Receiver is eager */
1751         rc = ksocknal_sock_write (sock, &hdr, sizeof(hdr));
1752         if (rc != 0) {
1753                 CERROR ("Error %d sending HELLO hdr to %u.%u.%u.%u/%d\n",
1754                         rc, HIPQUAD(conn->ksnc_ipaddr), conn->ksnc_port);
1755                 return (rc);
1756         }
1757
1758         if (nipaddrs == 0)
1759                 return (0);
1760
1761         for (i = 0; i < nipaddrs; i++) {
1762                 ipaddrs[i] = __cpu_to_le32 (ipaddrs[i]);
1763         }
1764
1765         rc = ksocknal_sock_write (sock, ipaddrs, nipaddrs * sizeof(*ipaddrs));
1766         if (rc != 0)
1767                 CERROR ("Error %d sending HELLO payload (%d)"
1768                         " to %u.%u.%u.%u/%d\n", rc, nipaddrs,
1769                         HIPQUAD(conn->ksnc_ipaddr), conn->ksnc_port);
1770         return (rc);
1771 }
1772
1773 int
1774 ksocknal_invert_type(int type)
1775 {
1776         switch (type)
1777         {
1778         case SOCKNAL_CONN_ANY:
1779         case SOCKNAL_CONN_CONTROL:
1780                 return (type);
1781         case SOCKNAL_CONN_BULK_IN:
1782                 return SOCKNAL_CONN_BULK_OUT;
1783         case SOCKNAL_CONN_BULK_OUT:
1784                 return SOCKNAL_CONN_BULK_IN;
1785         default:
1786                 return (SOCKNAL_CONN_NONE);
1787         }
1788 }
1789
1790 int
1791 ksocknal_recv_hello (ksock_conn_t *conn, ptl_nid_t *nid,
1792                      __u64 *incarnation, __u32 *ipaddrs)
1793 {
1794         struct socket      *sock = conn->ksnc_sock;
1795         int                 rc;
1796         int                 nips;
1797         int                 i;
1798         int                 type;
1799         ptl_hdr_t           hdr;
1800         ptl_magicversion_t *hmv;
1801
1802         hmv = (ptl_magicversion_t *)&hdr.dest_nid;
1803         LASSERT (sizeof (*hmv) == sizeof (hdr.dest_nid));
1804
1805         rc = ksocknal_sock_read (sock, hmv, sizeof (*hmv));
1806         if (rc != 0) {
1807                 CERROR ("Error %d reading HELLO from %u.%u.%u.%u\n",
1808                         rc, HIPQUAD(conn->ksnc_ipaddr));
1809                 return (rc);
1810         }
1811
1812         if (hmv->magic != le32_to_cpu (PORTALS_PROTO_MAGIC)) {
1813                 CERROR ("Bad magic %#08x (%#08x expected) from %u.%u.%u.%u\n",
1814                         __cpu_to_le32 (hmv->magic), PORTALS_PROTO_MAGIC,
1815                         HIPQUAD(conn->ksnc_ipaddr));
1816                 return (-EPROTO);
1817         }
1818
1819         if (hmv->version_major != cpu_to_le16 (PORTALS_PROTO_VERSION_MAJOR) ||
1820             hmv->version_minor != cpu_to_le16 (PORTALS_PROTO_VERSION_MINOR)) {
1821                 CERROR ("Incompatible protocol version %d.%d (%d.%d expected)"
1822                         " from %u.%u.%u.%u\n",
1823                         le16_to_cpu (hmv->version_major),
1824                         le16_to_cpu (hmv->version_minor),
1825                         PORTALS_PROTO_VERSION_MAJOR,
1826                         PORTALS_PROTO_VERSION_MINOR,
1827                         HIPQUAD(conn->ksnc_ipaddr));
1828                 return (-EPROTO);
1829         }
1830
1831 #if (PORTALS_PROTO_VERSION_MAJOR != 1)
1832 # error "This code only understands protocol version 1.x"
1833 #endif
1834         /* version 1 sends magic/version as the dest_nid of a 'hello'
1835          * header, followed by payload full of interface IP addresses.
1836          * Read the rest of it in now... */
1837
1838         rc = ksocknal_sock_read (sock, hmv + 1, sizeof (hdr) - sizeof (*hmv));
1839         if (rc != 0) {
1840                 CERROR ("Error %d reading rest of HELLO hdr from %u.%u.%u.%u\n",
1841                         rc, HIPQUAD(conn->ksnc_ipaddr));
1842                 return (rc);
1843         }
1844
1845         /* ...and check we got what we expected */
1846         if (hdr.type != cpu_to_le32 (PTL_MSG_HELLO)) {
1847                 CERROR ("Expecting a HELLO hdr,"
1848                         " but got type %d from %u.%u.%u.%u\n",
1849                         le32_to_cpu (hdr.type),
1850                         HIPQUAD(conn->ksnc_ipaddr));
1851                 return (-EPROTO);
1852         }
1853
1854         if (le64_to_cpu(hdr.src_nid) == PTL_NID_ANY) {
1855                 CERROR("Expecting a HELLO hdr with a NID, but got PTL_NID_ANY"
1856                        "from %u.%u.%u.%u\n", HIPQUAD(conn->ksnc_ipaddr));
1857                 return (-EPROTO);
1858         }
1859
1860         if (*nid == PTL_NID_ANY) {              /* don't know peer's nid yet */
1861                 *nid = le64_to_cpu(hdr.src_nid);
1862         } else if (*nid != le64_to_cpu (hdr.src_nid)) {
1863                 CERROR ("Connected to nid "LPX64"@%u.%u.%u.%u "
1864                         "but expecting "LPX64"\n",
1865                         le64_to_cpu (hdr.src_nid),
1866                         HIPQUAD(conn->ksnc_ipaddr), *nid);
1867                 return (-EPROTO);
1868         }
1869
1870         type = __le32_to_cpu(hdr.msg.hello.type);
1871
1872         if (conn->ksnc_type == SOCKNAL_CONN_NONE) {
1873                 /* I've accepted this connection; peer determines type */
1874                 conn->ksnc_type = ksocknal_invert_type(type);
1875                 if (conn->ksnc_type == SOCKNAL_CONN_NONE) {
1876                         CERROR ("Unexpected type %d from "LPX64"@%u.%u.%u.%u\n",
1877                                 type, *nid, HIPQUAD(conn->ksnc_ipaddr));
1878                         return (-EPROTO);
1879                 }
1880         } else if (ksocknal_invert_type(type) != conn->ksnc_type) {
1881                 CERROR ("Mismatched types: me %d, "LPX64"@%u.%u.%u.%u %d\n",
1882                         conn->ksnc_type, *nid, HIPQUAD(conn->ksnc_ipaddr),
1883                         le32_to_cpu(hdr.msg.hello.type));
1884                 return (-EPROTO);
1885         }
1886
1887         *incarnation = le64_to_cpu(hdr.msg.hello.incarnation);
1888
1889         nips = __le32_to_cpu (hdr.payload_length) / sizeof (__u32);
1890
1891         if (nips > SOCKNAL_MAX_INTERFACES ||
1892             nips * sizeof(__u32) != __le32_to_cpu (hdr.payload_length)) {
1893                 CERROR("Bad payload length %d from "LPX64"@%u.%u.%u.%u\n",
1894                        __le32_to_cpu (hdr.payload_length),
1895                        *nid, HIPQUAD(conn->ksnc_ipaddr));
1896         }
1897
1898         if (nips == 0)
1899                 return (0);
1900
1901         rc = ksocknal_sock_read (sock, ipaddrs, nips * sizeof(*ipaddrs));
1902         if (rc != 0) {
1903                 CERROR ("Error %d reading IPs from "LPX64"@%u.%u.%u.%u\n",
1904                         rc, *nid, HIPQUAD(conn->ksnc_ipaddr));
1905                 return (rc);
1906         }
1907
1908         for (i = 0; i < nips; i++) {
1909                 ipaddrs[i] = __le32_to_cpu(ipaddrs[i]);
1910
1911                 if (ipaddrs[i] == 0) {
1912                         CERROR("Zero IP[%d] from "LPX64"@%u.%u.%u.%u\n",
1913                                i, *nid, HIPQUAD(conn->ksnc_ipaddr));
1914                         return (-EPROTO);
1915                 }
1916         }
1917
1918         return (nips);
1919 }
1920
1921 int
1922 ksocknal_get_conn_tunables (ksock_conn_t *conn, int *txmem, int *rxmem, int *nagle)
1923 {
1924         return ksocknal_lib_get_conn_tunables(conn, txmem, rxmem, nagle);
1925 }
1926
1927 int
1928 ksocknal_connect_peer (ksock_route_t *route, int type)
1929 {
1930         struct socket      *sock;
1931         int                 rc;
1932         int                 port;
1933         int                 may_retry;
1934
1935         /* Iterate through reserved ports.  When typed connections are
1936          * used, we will need to bind to multiple ports, but we only know
1937          * this at connect time.  But, by that time we've already called
1938          * bind() so we need a new socket. */
1939
1940         for (port = 1023; port > 512; --port) {
1941
1942                 rc = ksocknal_lib_connect_sock(&sock, &may_retry, route, port);
1943
1944                 if (rc == 0) {
1945                         rc = ksocknal_create_conn(route, sock, type);
1946                         cfs_put_file(KSN_SOCK2FILE(sock));
1947                         return rc;
1948                 }
1949
1950                 if (!may_retry)
1951                         return rc;
1952         }
1953
1954         CERROR("Out of ports trying to bind to a reserved port\n");
1955         return (-EADDRINUSE);
1956 }
1957
1958 void
1959 ksocknal_autoconnect (ksock_route_t *route)
1960 {
1961         CFS_LIST_HEAD    (zombies);
1962         ksock_tx_t       *tx;
1963         ksock_peer_t     *peer;
1964         unsigned long     flags;
1965         int               rc;
1966         int               type;
1967
1968         for (;;) {
1969                 for (type = 0; type < SOCKNAL_CONN_NTYPES; type++)
1970                         if ((route->ksnr_connecting & (1 << type)) != 0)
1971                                 break;
1972                 LASSERT (type < SOCKNAL_CONN_NTYPES);
1973
1974                 rc = ksocknal_connect_peer (route, type);
1975                 if (rc != 0)
1976                         break;
1977
1978                 /* successfully autoconnected: create_conn did the
1979                  * route/conn binding and scheduled any blocked packets */
1980
1981                 if (route->ksnr_connecting == 0) {
1982                         /* No more connections required */
1983                         return;
1984                 }
1985         }
1986
1987         /* Connection attempt failed */
1988
1989         write_lock_irqsave (&ksocknal_data.ksnd_global_lock, flags);
1990
1991         peer = route->ksnr_peer;
1992         route->ksnr_connecting = 0;
1993
1994         /* This is a retry rather than a new connection */
1995         LASSERT (route->ksnr_retry_interval != 0);
1996         route->ksnr_timeout = cfs_time_add(cfs_time_current(),
1997                                            route->ksnr_retry_interval);
1998         route->ksnr_retry_interval = MIN (route->ksnr_retry_interval * 2,
1999                                           SOCKNAL_MAX_RECONNECT_INTERVAL);
2000
2001         if (!list_empty (&peer->ksnp_tx_queue) &&
2002             ksocknal_find_connecting_route_locked (peer) == NULL) {
2003                 LASSERT (list_empty (&peer->ksnp_conns));
2004
2005                 /* None of the connections that the blocked packets are
2006                  * waiting for have been successful.  Complete them now... */
2007                 do {
2008                         tx = list_entry (peer->ksnp_tx_queue.next,
2009                                          ksock_tx_t, tx_list);
2010                         list_del (&tx->tx_list);
2011                         list_add_tail (&tx->tx_list, &zombies);
2012                 } while (!list_empty (&peer->ksnp_tx_queue));
2013         }
2014
2015 #if 0           /* irrelevent with only eager routes */
2016         if (!route->ksnr_deleted) {
2017                 /* make this route least-favourite for re-selection */
2018                 list_del(&route->ksnr_list);
2019                 list_add_tail(&route->ksnr_list, &peer->ksnp_routes);
2020         }
2021 #endif
2022         write_unlock_irqrestore (&ksocknal_data.ksnd_global_lock, flags);
2023
2024         while (!list_empty (&zombies)) {
2025                 char ipbuf[PTL_NALFMT_SIZE];
2026                 char ipbuf2[PTL_NALFMT_SIZE];
2027                 tx = list_entry (zombies.next, ksock_tx_t, tx_list);
2028
2029                 CERROR ("Deleting packet type %d len %d ("LPX64" %s->"LPX64" %s)\n",
2030                         le32_to_cpu (tx->tx_hdr->type),
2031                         le32_to_cpu (tx->tx_hdr->payload_length),
2032                         le64_to_cpu (tx->tx_hdr->src_nid),
2033                         portals_nid2str(SOCKNAL,
2034                                         le64_to_cpu(tx->tx_hdr->src_nid),
2035                                         ipbuf),
2036                         le64_to_cpu (tx->tx_hdr->dest_nid),
2037                         portals_nid2str(SOCKNAL,
2038                                         le64_to_cpu(tx->tx_hdr->src_nid),
2039                                         ipbuf2));
2040
2041                 list_del (&tx->tx_list);
2042                 /* complete now */
2043                 ksocknal_tx_done (tx, 0);
2044         }
2045 }
2046
2047 int
2048 ksocknal_autoconnectd (void *arg)
2049 {
2050         long               id = (long)arg;
2051         char               name[16];
2052         unsigned long      flags;
2053         ksock_route_t     *route;
2054         int                rc;
2055
2056         snprintf (name, sizeof (name), "ksocknal_ad%02ld", id);
2057         kportal_daemonize (name);
2058         kportal_blockallsigs ();
2059
2060         spin_lock_irqsave (&ksocknal_data.ksnd_autoconnectd_lock, flags);
2061
2062         while (!ksocknal_data.ksnd_shuttingdown) {
2063
2064                 if (!list_empty (&ksocknal_data.ksnd_autoconnectd_routes)) {
2065                         route = list_entry (ksocknal_data.ksnd_autoconnectd_routes.next,
2066                                             ksock_route_t, ksnr_connect_list);
2067
2068                         list_del (&route->ksnr_connect_list);
2069                         spin_unlock_irqrestore (&ksocknal_data.ksnd_autoconnectd_lock, flags);
2070
2071                         ksocknal_autoconnect (route);
2072                         ksocknal_put_route (route);
2073
2074                         spin_lock_irqsave(&ksocknal_data.ksnd_autoconnectd_lock,
2075                                           flags);
2076                         continue;
2077                 }
2078
2079                 spin_unlock_irqrestore(&ksocknal_data.ksnd_autoconnectd_lock,
2080                                        flags);
2081
2082                 rc = wait_event_interruptible(ksocknal_data.ksnd_autoconnectd_waitq,
2083                                               ksocknal_data.ksnd_shuttingdown ||
2084                                               !list_empty(&ksocknal_data.ksnd_autoconnectd_routes));
2085
2086                 spin_lock_irqsave(&ksocknal_data.ksnd_autoconnectd_lock, flags);
2087         }
2088
2089         spin_unlock_irqrestore (&ksocknal_data.ksnd_autoconnectd_lock, flags);
2090
2091         ksocknal_thread_fini ();
2092         return (0);
2093 }
2094
2095 ksock_conn_t *
2096 ksocknal_find_timed_out_conn (ksock_peer_t *peer)
2097 {
2098         /* We're called with a shared lock on ksnd_global_lock */
2099         ksock_conn_t      *conn;
2100         struct list_head  *ctmp;
2101
2102         list_for_each (ctmp, &peer->ksnp_conns) {
2103                 conn = list_entry (ctmp, ksock_conn_t, ksnc_list);
2104
2105                 /* Don't need the {get,put}connsock dance to deref ksnc_sock... */
2106                 LASSERT (!conn->ksnc_closing);
2107
2108                 if (SOCK_ERROR(conn->ksnc_sock) != 0) {
2109                         /* Something (e.g. failed keepalive) set the socket error */
2110                         atomic_inc (&conn->ksnc_refcount);
2111                         CERROR ("Socket error %d: "LPX64" %p %d.%d.%d.%d\n",
2112                                 SOCK_ERROR(conn->ksnc_sock), peer->ksnp_nid,
2113                                 conn, HIPQUAD(conn->ksnc_ipaddr));
2114                         return (conn);
2115                 }
2116
2117                 if (conn->ksnc_rx_started &&
2118                     cfs_time_aftereq (cfs_time_current(),
2119                                       conn->ksnc_rx_deadline)) {
2120                         /* Timed out incomplete incoming message */
2121                         atomic_inc (&conn->ksnc_refcount);
2122                         CERROR ("Timed out RX from "LPX64" %p %d.%d.%d.%d\n",
2123                                 peer->ksnp_nid,conn,HIPQUAD(conn->ksnc_ipaddr));
2124                         return (conn);
2125                 }
2126
2127                 if ((!list_empty (&conn->ksnc_tx_queue) ||
2128                      SOCK_WMEM_QUEUED(conn->ksnc_sock) != 0) &&
2129                     cfs_time_aftereq (cfs_time_current(),
2130                                       conn->ksnc_tx_deadline)) {
2131                         /* Timed out messages queued for sending or
2132                          * buffered in the socket's send buffer */
2133                         atomic_inc (&conn->ksnc_refcount);
2134                         CERROR ("Timed out TX to "LPX64" %s%d %p %d.%d.%d.%d\n",
2135                                 peer->ksnp_nid,
2136                                 list_empty (&conn->ksnc_tx_queue) ? "" : "Q ",
2137                                 SOCK_WMEM_QUEUED(conn->ksnc_sock), conn,
2138                                 HIPQUAD(conn->ksnc_ipaddr));
2139                         return (conn);
2140                 }
2141         }
2142
2143         return (NULL);
2144 }
2145
2146 void
2147 ksocknal_check_peer_timeouts (int idx)
2148 {
2149         struct list_head *peers = &ksocknal_data.ksnd_peers[idx];
2150         struct list_head *ptmp;
2151         ksock_peer_t     *peer;
2152         ksock_conn_t     *conn;
2153
2154  again:
2155         /* NB. We expect to have a look at all the peers and not find any
2156          * connections to time out, so we just use a shared lock while we
2157          * take a look... */
2158         read_lock (&ksocknal_data.ksnd_global_lock);
2159
2160         list_for_each (ptmp, peers) {
2161                 peer = list_entry (ptmp, ksock_peer_t, ksnp_list);
2162                 conn = ksocknal_find_timed_out_conn (peer);
2163
2164                 if (conn != NULL) {
2165                         read_unlock (&ksocknal_data.ksnd_global_lock);
2166
2167                         CERROR ("Timeout out conn->"LPX64" ip %d.%d.%d.%d:%d\n",
2168                                 peer->ksnp_nid,
2169                                 HIPQUAD(conn->ksnc_ipaddr),
2170                                 conn->ksnc_port);
2171                         ksocknal_close_conn_and_siblings (conn, -ETIMEDOUT);
2172
2173                         /* NB we won't find this one again, but we can't
2174                          * just proceed with the next peer, since we dropped
2175                          * ksnd_global_lock and it might be dead already! */
2176                         ksocknal_put_conn (conn);
2177                         goto again;
2178                 }
2179         }
2180
2181         read_unlock (&ksocknal_data.ksnd_global_lock);
2182 }
2183
2184 int
2185 ksocknal_reaper (void *arg)
2186 {
2187         cfs_waitlink_t     wait;
2188         unsigned long      flags;
2189         ksock_conn_t      *conn;
2190         ksock_sched_t     *sched;
2191         struct list_head   enomem_conns;
2192         int                nenomem_conns;
2193         cfs_duration_t     timeout;
2194         int                i;
2195         int                peer_index = 0;
2196         cfs_time_t         deadline = cfs_time_current();
2197
2198         kportal_daemonize ("ksocknal_reaper");
2199         kportal_blockallsigs ();
2200
2201         CFS_INIT_LIST_HEAD(&enomem_conns);
2202         cfs_waitlink_init (&wait);
2203
2204         spin_lock_irqsave (&ksocknal_data.ksnd_reaper_lock, flags);
2205
2206         while (!ksocknal_data.ksnd_shuttingdown) {
2207
2208                 if (!list_empty (&ksocknal_data.ksnd_deathrow_conns)) {
2209                         conn = list_entry (ksocknal_data.ksnd_deathrow_conns.next,
2210                                            ksock_conn_t, ksnc_list);
2211                         list_del (&conn->ksnc_list);
2212
2213                         spin_unlock_irqrestore (&ksocknal_data.ksnd_reaper_lock, flags);
2214
2215                         ksocknal_terminate_conn (conn);
2216                         ksocknal_put_conn (conn);
2217
2218                         spin_lock_irqsave (&ksocknal_data.ksnd_reaper_lock, flags);
2219                         continue;
2220                 }
2221
2222                 if (!list_empty (&ksocknal_data.ksnd_zombie_conns)) {
2223                         conn = list_entry (ksocknal_data.ksnd_zombie_conns.next,
2224                                            ksock_conn_t, ksnc_list);
2225                         list_del (&conn->ksnc_list);
2226
2227                         spin_unlock_irqrestore (&ksocknal_data.ksnd_reaper_lock, flags);
2228
2229                         ksocknal_destroy_conn (conn);
2230
2231                         spin_lock_irqsave (&ksocknal_data.ksnd_reaper_lock, flags);
2232                         continue;
2233                 }
2234
2235                 if (!list_empty (&ksocknal_data.ksnd_enomem_conns)) {
2236                         list_add(&enomem_conns, &ksocknal_data.ksnd_enomem_conns);
2237                         list_del_init(&ksocknal_data.ksnd_enomem_conns);
2238                 }
2239
2240                 spin_unlock_irqrestore (&ksocknal_data.ksnd_reaper_lock, flags);
2241
2242                 /* reschedule all the connections that stalled with ENOMEM... */
2243                 nenomem_conns = 0;
2244                 while (!list_empty (&enomem_conns)) {
2245                         conn = list_entry (enomem_conns.next,
2246                                            ksock_conn_t, ksnc_tx_list);
2247                         list_del (&conn->ksnc_tx_list);
2248
2249                         sched = conn->ksnc_scheduler;
2250
2251                         spin_lock_irqsave (&sched->kss_lock, flags);
2252
2253                         LASSERT (conn->ksnc_tx_scheduled);
2254                         conn->ksnc_tx_ready = 1;
2255                         list_add_tail (&conn->ksnc_tx_list, &sched->kss_tx_conns);
2256                         cfs_waitq_signal (&sched->kss_waitq);
2257
2258                         spin_unlock_irqrestore (&sched->kss_lock, flags);
2259                         nenomem_conns++;
2260                 }
2261
2262                 /* careful with the jiffy wrap... */
2263                 while ((timeout = cfs_time_sub(deadline,
2264                                                cfs_time_current())) <= 0) {
2265                         const int n = 4;
2266                         const int p = 1;
2267                         int       chunk = ksocknal_data.ksnd_peer_hash_size;
2268
2269                         /* Time to check for timeouts on a few more peers: I do
2270                          * checks every 'p' seconds on a proportion of the peer
2271                          * table and I need to check every connection 'n' times
2272                          * within a timeout interval, to ensure I detect a
2273                          * timeout on any connection within (n+1)/n times the
2274                          * timeout interval. */
2275
2276                         if (ksocknal_tunables.ksnd_io_timeout > n * p)
2277                                 chunk = (chunk * n * p) /
2278                                         ksocknal_tunables.ksnd_io_timeout;
2279                         if (chunk == 0)
2280                                 chunk = 1;
2281
2282                         for (i = 0; i < chunk; i++) {
2283                                 ksocknal_check_peer_timeouts (peer_index);
2284                                 peer_index = (peer_index + 1) %
2285                                              ksocknal_data.ksnd_peer_hash_size;
2286                         }
2287
2288                         deadline = cfs_time_add(deadline, cfs_time_seconds(p));
2289                 }
2290
2291                 if (nenomem_conns != 0) {
2292                         /* Reduce my timeout if I rescheduled ENOMEM conns.
2293                          * This also prevents me getting woken immediately
2294                          * if any go back on my enomem list. */
2295                         timeout = SOCKNAL_ENOMEM_RETRY;
2296                 }
2297                 ksocknal_data.ksnd_reaper_waketime =
2298                         cfs_time_add(cfs_time_current(), timeout);
2299
2300                 set_current_state (TASK_INTERRUPTIBLE);
2301                 cfs_waitq_add (&ksocknal_data.ksnd_reaper_waitq, &wait);
2302
2303                 if (!ksocknal_data.ksnd_shuttingdown &&
2304                     list_empty (&ksocknal_data.ksnd_deathrow_conns) &&
2305                     list_empty (&ksocknal_data.ksnd_zombie_conns))
2306                         cfs_waitq_timedwait (&wait, timeout);
2307
2308                 set_current_state (TASK_RUNNING);
2309                 cfs_waitq_del (&ksocknal_data.ksnd_reaper_waitq, &wait);
2310
2311                 spin_lock_irqsave (&ksocknal_data.ksnd_reaper_lock, flags);
2312         }
2313
2314         spin_unlock_irqrestore (&ksocknal_data.ksnd_reaper_lock, flags);
2315
2316         ksocknal_thread_fini ();
2317         return (0);
2318 }
2319
2320 lib_nal_t ksocknal_lib = {
2321         libnal_data:       &ksocknal_data,      /* NAL private data */
2322         libnal_send:        ksocknal_send,
2323         libnal_send_pages:  ksocknal_send_pages,
2324         libnal_recv:        ksocknal_recv,
2325         libnal_recv_pages:  ksocknal_recv_pages,
2326         libnal_dist:        ksocknal_dist
2327 };