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 (%u allocated)\n",
 462                               counter, conn, atomic_read(&portal_kmemory));
 463
 464                 /* Queue on ksnd_enomem_conns for retry after a timeout */
 465                 spin_lock_irqsave(&ksocknal_data.ksnd_reaper_lock, flags);
 466
 467                 /* enomem list takes over scheduler's ref... */
 468                 LASSERT (conn->ksnc_tx_scheduled);
 469                 list_add_tail(&conn->ksnc_tx_list,
 470                               &ksocknal_data.ksnd_enomem_conns);
 471                 if (!cfs_time_aftereq(cfs_time_add(cfs_time_current(),
 472                                                    SOCKNAL_ENOMEM_RETRY),
 473                                    ksocknal_data.ksnd_reaper_waketime))
 474                         cfs_waitq_signal (&ksocknal_data.ksnd_reaper_waitq);
 475
 476                 spin_unlock_irqrestore(&ksocknal_data.ksnd_reaper_lock, flags);
 477                 return (rc);
 478         }
 479
 480         /* Actual error */
 481         LASSERT (rc < 0);
 482
 483         if (!conn->ksnc_closing) {
 484                 switch (rc) {
 485                 case -ECONNRESET:
 486                         LCONSOLE_WARN("Host %u.%u.%u.%u reset our connection "
 487                                       "while we were sending data; it may have "
 488                                       "rebooted.\n",
 489                                       HIPQUAD(conn->ksnc_ipaddr));
 490                         break;
 491                 default:
 492                         LCONSOLE_WARN("There was an unexpected network error "
 493                                       "while writing to %u.%u.%u.%u: %d.\n",
 494                                       HIPQUAD(conn->ksnc_ipaddr), rc);
 495                         break;
 496                 }
 497                 CERROR("[%p] Error %d on write to "LPX64
 498                        " ip %d.%d.%d.%d:%d\n", conn, rc,
 499                        conn->ksnc_peer->ksnp_nid,
 500                        HIPQUAD(conn->ksnc_ipaddr),
 501                        conn->ksnc_port);
 502         }
 503
 504         ksocknal_close_conn_and_siblings (conn, rc);
 505         ksocknal_tx_launched (tx);
 506
 507         return (rc);
 508 }
 509
 510 void
 511 ksocknal_launch_autoconnect_locked (ksock_route_t *route)
 512 {
 513         unsigned long     flags;
 514
 515         /* called holding write lock on ksnd_global_lock */
 516         LASSERT (!route->ksnr_connecting);
 517
 518         route->ksnr_connecting = 1;             /* scheduling conn for autoconnectd */
 519         atomic_inc (&route->ksnr_refcount);     /* extra ref for autoconnectd */
 520
 521         spin_lock_irqsave (&ksocknal_data.ksnd_autoconnectd_lock, flags);
 522
 523         list_add_tail (&route->ksnr_connect_list,
 524                        &ksocknal_data.ksnd_autoconnectd_routes);
 525         cfs_waitq_signal (&ksocknal_data.ksnd_autoconnectd_waitq);
 526
 527         spin_unlock_irqrestore (&ksocknal_data.ksnd_autoconnectd_lock, flags);
 528 }
 529
 530 ksock_peer_t *
 531 ksocknal_find_target_peer_locked (ksock_tx_t *tx, ptl_nid_t nid)
 532 {
 533         char          ipbuf[PTL_NALFMT_SIZE];
 534         ptl_nid_t     target_nid;
 535         int           rc;
 536         ksock_peer_t *peer = ksocknal_find_peer_locked (nid);
 537
 538         if (peer != NULL)
 539                 return (peer);
 540
 541         if (tx->tx_isfwd) {
 542                 CERROR ("Can't send packet to "LPX64
 543                        " %s: routed target is not a peer\n",
 544                         nid, portals_nid2str(SOCKNAL, nid, ipbuf));
 545                 return (NULL);
 546         }
 547
 548         rc = kpr_lookup (&ksocknal_data.ksnd_router, nid, tx->tx_nob,
 549                          &target_nid);
 550         if (rc != 0) {
 551                 CERROR ("Can't route to "LPX64" %s: router error %d\n",
 552                         nid, portals_nid2str(SOCKNAL, nid, ipbuf), rc);
 553                 return (NULL);
 554         }
 555
 556         peer = ksocknal_find_peer_locked (target_nid);
 557         if (peer != NULL)
 558                 return (peer);
 559
 560         CERROR ("Can't send packet to "LPX64" %s: no peer entry\n",
 561                 target_nid, portals_nid2str(SOCKNAL, target_nid, ipbuf));
 562         return (NULL);
 563 }
 564
 565 ksock_conn_t *
 566 ksocknal_find_conn_locked (ksock_tx_t *tx, ksock_peer_t *peer)
 567 {
 568         struct list_head *tmp;
 569         ksock_conn_t     *typed = NULL;
 570         int               tnob  = 0;
 571         ksock_conn_t     *fallback = NULL;
 572         int               fnob     = 0;
 573         ksock_conn_t     *conn;
 574
 575         list_for_each (tmp, &peer->ksnp_conns) {
 576                 ksock_conn_t *c = list_entry(tmp, ksock_conn_t, ksnc_list);
 577 #if SOCKNAL_ROUND_ROBIN
 578                 const int     nob = 0;
 579 #else
 580                 int           nob = atomic_read(&c->ksnc_tx_nob) +
 581                                         SOCK_WMEM_QUEUED(c->ksnc_sock);
 582 #endif
 583                 LASSERT (!c->ksnc_closing);
 584
 585                 if (fallback == NULL || nob < fnob) {
 586                         fallback = c;
 587                         fnob     = nob;
 588                 }
 589
 590                 if (!ksocknal_tunables.ksnd_typed_conns)
 591                         continue;
 592
 593                 switch (c->ksnc_type) {
 594                 default:
 595                         CERROR("ksnc_type bad: %u\n", c->ksnc_type);
 596                         LBUG();
 597                 case SOCKNAL_CONN_ANY:
 598                         break;
 599                 case SOCKNAL_CONN_BULK_IN:
 600                         continue;
 601                 case SOCKNAL_CONN_BULK_OUT:
 602                         if (tx->tx_nob < ksocknal_tunables.ksnd_min_bulk)
 603                                 continue;
 604                         break;
 605                 case SOCKNAL_CONN_CONTROL:
 606                         if (tx->tx_nob >= ksocknal_tunables.ksnd_min_bulk)
 607                                 continue;
 608                         break;
 609                 }
 610
 611                 if (typed == NULL || nob < tnob) {
 612                         typed = c;
 613                         tnob  = nob;
 614                 }
 615         }
 616
 617         /* prefer the typed selection */
 618         conn = (typed != NULL) ? typed : fallback;
 619
 620 #if SOCKNAL_ROUND_ROBIN
 621         if (conn != NULL) {
 622                 /* round-robin all else being equal */
 623                 list_del (&conn->ksnc_list);
 624                 list_add_tail (&conn->ksnc_list, &peer->ksnp_conns);
 625         }
 626 #endif
 627         return conn;
 628 }
 629
 630 void
 631 ksocknal_queue_tx_locked (ksock_tx_t *tx, ksock_conn_t *conn)
 632 {
 633         unsigned long  flags;
 634         ksock_sched_t *sched = conn->ksnc_scheduler;
 635
 636         /* called holding global lock (read or irq-write) and caller may
 637          * not have dropped this lock between finding conn and calling me,
 638          * so we don't need the {get,put}connsock dance to deref
 639          * ksnc_sock... */
 640         LASSERT(!conn->ksnc_closing);
 641         LASSERT(tx->tx_resid == tx->tx_nob);
 642
 643         CDEBUG (D_NET, "Sending to "LPX64" ip %d.%d.%d.%d:%d\n",
 644                 conn->ksnc_peer->ksnp_nid,
 645                 HIPQUAD(conn->ksnc_ipaddr),
 646                 conn->ksnc_port);
 647
 648         atomic_add (tx->tx_nob, &conn->ksnc_tx_nob);
 649         tx->tx_conn = conn;
 650
 651 #if SOCKNAL_ZC
 652         zccd_init (&tx->tx_zccd, ksocknal_zc_callback);
 653         /* NB this sets 1 ref on zccd, so the callback can only occur after
 654          * I've released this ref. */
 655 #endif
 656         spin_lock_irqsave (&sched->kss_lock, flags);
 657
 658         if (list_empty(&conn->ksnc_tx_queue) &&
 659             SOCK_WMEM_QUEUED(conn->ksnc_sock) == 0) {
 660                 /* First packet starts the timeout */
 661                 conn->ksnc_tx_deadline = cfs_time_shift(ksocknal_tunables.ksnd_io_timeout);
 662                 conn->ksnc_tx_bufnob = 0;
 663                 mb();    /* order with adding to tx_queue */
 664         }
 665
 666         list_add_tail (&tx->tx_list, &conn->ksnc_tx_queue);
 667
 668         if (conn->ksnc_tx_ready &&      /* able to send */
 669             !conn->ksnc_tx_scheduled) { /* not scheduled to send */
 670                 /* +1 ref for scheduler */
 671                 atomic_inc (&conn->ksnc_refcount);
 672                 list_add_tail (&conn->ksnc_tx_list,
 673                                &sched->kss_tx_conns);
 674                 conn->ksnc_tx_scheduled = 1;
 675                 cfs_waitq_signal (&sched->kss_waitq);
 676         }
 677
 678         spin_unlock_irqrestore (&sched->kss_lock, flags);
 679 }
 680
 681 ksock_route_t *
 682 ksocknal_find_connectable_route_locked (ksock_peer_t *peer)
 683 {
 684         struct list_head  *tmp;
 685         ksock_route_t     *route;
 686         int                bits;
 687
 688         list_for_each (tmp, &peer->ksnp_routes) {
 689                 route = list_entry (tmp, ksock_route_t, ksnr_list);
 690                 bits  = route->ksnr_connected;
 691
 692                 if (ksocknal_tunables.ksnd_typed_conns) {
 693                         /* All typed connections established? */
 694                         if ((bits & KSNR_TYPED_ROUTES) == KSNR_TYPED_ROUTES)
 695                                 continue;
 696                 } else {
 697                         /* Untyped connection established? */
 698                         if ((bits & (1 << SOCKNAL_CONN_ANY)) != 0)
 699                                 continue;
 700                 }
 701
 702                 /* connection being established? */
 703                 if (route->ksnr_connecting)
 704                         continue;
 705
 706                 /* too soon to retry this guy? */
 707                 if (!cfs_time_aftereq (cfs_time_current(), route->ksnr_timeout))
 708                         continue;
 709
 710                 return (route);
 711         }
 712
 713         return (NULL);
 714 }
 715
 716 ksock_route_t *
 717 ksocknal_find_connecting_route_locked (ksock_peer_t *peer)
 718 {
 719         struct list_head  *tmp;
 720         ksock_route_t     *route;
 721
 722         list_for_each (tmp, &peer->ksnp_routes) {
 723                 route = list_entry (tmp, ksock_route_t, ksnr_list);
 724
 725                 if (route->ksnr_connecting)
 726                         return (route);
 727         }
 728
 729         return (NULL);
 730 }
 731
 732 int
 733 ksocknal_launch_packet (ksock_tx_t *tx, ptl_nid_t nid)
 734 {
 735         unsigned long     flags;
 736         ksock_peer_t     *peer;
 737         ksock_conn_t     *conn;
 738         ksock_route_t    *route;
 739         rwlock_t         *g_lock;
 740
 741         /* Ensure the frags we've been given EXACTLY match the number of
 742          * bytes we want to send.  Many TCP/IP stacks disregard any total
 743          * size parameters passed to them and just look at the frags.
 744          *
 745          * We always expect at least 1 mapped fragment containing the
 746          * complete portals header. */
 747         LASSERT (lib_iov_nob (tx->tx_niov, tx->tx_iov) +
 748                  lib_kiov_nob (tx->tx_nkiov, tx->tx_kiov) == tx->tx_nob);
 749         LASSERT (tx->tx_niov >= 1);
 750         LASSERT (tx->tx_iov[0].iov_len >= sizeof (ptl_hdr_t));
 751
 752         CDEBUG (D_NET, "packet %p type %d, nob %d niov %d nkiov %d\n",
 753                 tx, ((ptl_hdr_t *)tx->tx_iov[0].iov_base)->type,
 754                 tx->tx_nob, tx->tx_niov, tx->tx_nkiov);
 755
 756         tx->tx_conn = NULL;                     /* only set when assigned a conn */
 757         tx->tx_resid = tx->tx_nob;
 758         tx->tx_hdr = (ptl_hdr_t *)tx->tx_iov[0].iov_base;
 759
 760         g_lock = &ksocknal_data.ksnd_global_lock;
 761 #if !SOCKNAL_ROUND_ROBIN
 762         read_lock (g_lock);
 763
 764         peer = ksocknal_find_target_peer_locked (tx, nid);
 765         if (peer == NULL) {
 766                 read_unlock (g_lock);
 767                 return (-EHOSTUNREACH);
 768         }
 769
 770         if (ksocknal_find_connectable_route_locked(peer) == NULL) {
 771                 conn = ksocknal_find_conn_locked (tx, peer);
 772                 if (conn != NULL) {
 773                         /* I've got no autoconnect routes that need to be
 774                          * connecting and I do have an actual connection... */
 775                         ksocknal_queue_tx_locked (tx, conn);
 776                         read_unlock (g_lock);
 777                         return (0);
 778                 }
 779         }
 780
 781         /* I'll need a write lock... */
 782         read_unlock (g_lock);
 783 #endif
 784         write_lock_irqsave(g_lock, flags);
 785
 786         peer = ksocknal_find_target_peer_locked (tx, nid);
 787         if (peer == NULL) {
 788                 write_unlock_irqrestore(g_lock, flags);
 789                 return (-EHOSTUNREACH);
 790         }
 791
 792         for (;;) {
 793                 /* launch any/all autoconnections that need it */
 794                 route = ksocknal_find_connectable_route_locked (peer);
 795                 if (route == NULL)
 796                         break;
 797
 798                 ksocknal_launch_autoconnect_locked (route);
 799         }
 800
 801         conn = ksocknal_find_conn_locked (tx, peer);
 802         if (conn != NULL) {
 803                 /* Connection exists; queue message on it */
 804                 ksocknal_queue_tx_locked (tx, conn);
 805                 write_unlock_irqrestore (g_lock, flags);
 806                 return (0);
 807         }
 808
 809         route = ksocknal_find_connecting_route_locked (peer);
 810         if (route != NULL) {
 811                 /* At least 1 connection is being established; queue the
 812                  * message... */
 813                 list_add_tail (&tx->tx_list, &peer->ksnp_tx_queue);
 814                 write_unlock_irqrestore (g_lock, flags);
 815                 return (0);
 816         }
 817
 818         write_unlock_irqrestore (g_lock, flags);
 819         return (-EHOSTUNREACH);
 820 }
 821
 822 ptl_err_t
 823 ksocknal_sendmsg(lib_nal_t     *nal,
 824                  void         *private,
 825                  lib_msg_t    *cookie,
 826                  ptl_hdr_t    *hdr,
 827                  int           type,
 828                  ptl_nid_t     nid,
 829                  ptl_pid_t     pid,
 830                  unsigned int  payload_niov,
 831                  struct iovec *payload_iov,
 832                  ptl_kiov_t   *payload_kiov,
 833                  size_t        payload_offset,
 834                  size_t        payload_nob)
 835 {
 836         ksock_ltx_t  *ltx;
 837         int           desc_size;
 838         int           rc;
 839
 840         /* NB 'private' is different depending on what we're sending.
 841          * Just ignore it... */
 842
 843         CDEBUG(D_NET, "sending "LPSZ" bytes in %d frags to nid:"LPX64
 844                " pid %d\n", payload_nob, payload_niov, nid , pid);
 845
 846         LASSERT (payload_nob == 0 || payload_niov > 0);
 847         LASSERT (payload_niov <= PTL_MD_MAX_IOV);
 848
 849         /* It must be OK to kmap() if required */
 850         LASSERT (payload_kiov == NULL || !in_interrupt ());
 851         /* payload is either all vaddrs or all pages */
 852         LASSERT (!(payload_kiov != NULL && payload_iov != NULL));
 853
 854         if (payload_iov != NULL)
 855                 desc_size = offsetof(ksock_ltx_t, ltx_iov[1 + payload_niov]);
 856         else
 857                 desc_size = offsetof(ksock_ltx_t, ltx_kiov[payload_niov]);
 858
 859         if (in_interrupt() ||
 860             type == PTL_MSG_ACK ||
 861             type == PTL_MSG_REPLY) {
 862                 /* Can't block if in interrupt or responding to an incoming
 863                  * message */
 864                 PORTAL_ALLOC_ATOMIC(ltx, desc_size);
 865         } else {
 866                 PORTAL_ALLOC(ltx, desc_size);
 867         }
 868
 869         if (ltx == NULL) {
 870                 CERROR("Can't allocate tx desc type %d size %d %s\n",
 871                        type, desc_size, in_interrupt() ? "(intr)" : "");
 872                 return (PTL_NO_SPACE);
 873         }
 874
 875         atomic_inc(&ksocknal_data.ksnd_nactive_ltxs);
 876
 877         ltx->ltx_desc_size = desc_size;
 878
 879         /* We always have 1 mapped frag for the header */
 880         ltx->ltx_tx.tx_iov = ltx->ltx_iov;
 881         ltx->ltx_iov[0].iov_base = &ltx->ltx_hdr;
 882         ltx->ltx_iov[0].iov_len = sizeof(*hdr);
 883         ltx->ltx_hdr = *hdr;
 884
 885         ltx->ltx_private = private;
 886         ltx->ltx_cookie = cookie;
 887
 888         ltx->ltx_tx.tx_isfwd = 0;
 889         ltx->ltx_tx.tx_nob = sizeof (*hdr) + payload_nob;
 890
 891         if (payload_iov != NULL) {
 892                 /* payload is all mapped */
 893                 ltx->ltx_tx.tx_kiov  = NULL;
 894                 ltx->ltx_tx.tx_nkiov = 0;
 895
 896                 ltx->ltx_tx.tx_niov =
 897                         1 + lib_extract_iov(payload_niov, &ltx->ltx_iov[1],
 898                                             payload_niov, payload_iov,
 899                                             payload_offset, payload_nob);
 900         } else {
 901                 /* payload is all pages */
 902                 ltx->ltx_tx.tx_niov = 1;
 903
 904                 ltx->ltx_tx.tx_kiov = ltx->ltx_kiov;
 905                 ltx->ltx_tx.tx_nkiov =
 906                         lib_extract_kiov(payload_niov, ltx->ltx_kiov,
 907                                          payload_niov, payload_kiov,
 908                                          payload_offset, payload_nob);
 909         }
 910
 911         rc = ksocknal_launch_packet(&ltx->ltx_tx, nid);
 912         if (rc == 0)
 913                 return (PTL_OK);
 914
 915         ksocknal_free_ltx(ltx);
 916         return (PTL_FAIL);
 917 }
 918
 919 ptl_err_t
 920 ksocknal_send (lib_nal_t *nal, void *private, lib_msg_t *cookie,
 921                ptl_hdr_t *hdr, int type, ptl_nid_t nid, ptl_pid_t pid,
 922                unsigned int payload_niov, struct iovec *payload_iov,
 923                size_t payload_offset, size_t payload_len)
 924 {
 925         return (ksocknal_sendmsg(nal, private, cookie,
 926                                  hdr, type, nid, pid,
 927                                  payload_niov, payload_iov, NULL,
 928                                  payload_offset, payload_len));
 929 }
 930
 931 ptl_err_t
 932 ksocknal_send_pages (lib_nal_t *nal, void *private, lib_msg_t *cookie,
 933                      ptl_hdr_t *hdr, int type, ptl_nid_t nid, ptl_pid_t pid,
 934                      unsigned int payload_niov, ptl_kiov_t *payload_kiov,
 935                      size_t payload_offset, size_t payload_len)
 936 {
 937         return (ksocknal_sendmsg(nal, private, cookie,
 938                                  hdr, type, nid, pid,
 939                                  payload_niov, NULL, payload_kiov,
 940                                  payload_offset, payload_len));
 941 }
 942
 943 void
 944 ksocknal_fwd_packet (void *arg, kpr_fwd_desc_t *fwd)
 945 {
 946         ptl_nid_t     nid = fwd->kprfd_gateway_nid;
 947         ksock_ftx_t  *ftx = (ksock_ftx_t *)&fwd->kprfd_scratch;
 948         int           rc;
 949
 950         CDEBUG (D_NET, "Forwarding [%p] -> "LPX64" ("LPX64"))\n", fwd,
 951                 fwd->kprfd_gateway_nid, fwd->kprfd_target_nid);
 952
 953         /* I'm the gateway; must be the last hop */
 954         if (nid == ksocknal_lib.libnal_ni.ni_pid.nid)
 955                 nid = fwd->kprfd_target_nid;
 956
 957         /* setup iov for hdr */
 958         ftx->ftx_iov.iov_base = fwd->kprfd_hdr;
 959         ftx->ftx_iov.iov_len = sizeof(ptl_hdr_t);
 960
 961         ftx->ftx_tx.tx_isfwd = 1;                  /* This is a forwarding packet */
 962         ftx->ftx_tx.tx_nob   = sizeof(ptl_hdr_t) + fwd->kprfd_nob;
 963         ftx->ftx_tx.tx_niov  = 1;
 964         ftx->ftx_tx.tx_iov   = &ftx->ftx_iov;
 965         ftx->ftx_tx.tx_nkiov = fwd->kprfd_niov;
 966         ftx->ftx_tx.tx_kiov  = fwd->kprfd_kiov;
 967
 968         rc = ksocknal_launch_packet (&ftx->ftx_tx, nid);
 969         if (rc != 0)
 970                 kpr_fwd_done (&ksocknal_data.ksnd_router, fwd, rc);
 971 }
 972
 973 int
 974 ksocknal_thread_start (int (*fn)(void *arg), void *arg)
 975 {
 976         long          pid = cfs_kernel_thread (fn, arg, 0);
 977         unsigned long flags;
 978
 979         if (pid < 0)
 980                 return ((int)pid);
 981
 982         write_lock_irqsave(&ksocknal_data.ksnd_global_lock, flags);
 983         ksocknal_data.ksnd_nthreads++;
 984         write_unlock_irqrestore(&ksocknal_data.ksnd_global_lock, flags);
 985         return (0);
 986 }
 987
 988 void
 989 ksocknal_thread_fini (void)
 990 {
 991         unsigned long flags;
 992
 993         write_lock_irqsave(&ksocknal_data.ksnd_global_lock, flags);
 994         ksocknal_data.ksnd_nthreads--;
 995         write_unlock_irqrestore(&ksocknal_data.ksnd_global_lock, flags);
 996 }
 997
 998 void
 999 ksocknal_fmb_callback (void *arg, int error)
1000 {
1001         ksock_fmb_t       *fmb = (ksock_fmb_t *)arg;
1002         ksock_fmb_pool_t  *fmp = fmb->fmb_pool;
1003         ptl_hdr_t         *hdr = &fmb->fmb_hdr;
1004         ksock_conn_t      *conn = NULL;
1005         ksock_sched_t     *sched;
1006         unsigned long      flags;
1007         char               ipbuf[PTL_NALFMT_SIZE];
1008         char               ipbuf2[PTL_NALFMT_SIZE];
1009
1010         if (error != 0)
1011                 CERROR("Failed to route packet from "
1012                        LPX64" %s to "LPX64" %s: %d\n",
1013                        le64_to_cpu(hdr->src_nid),
1014                        portals_nid2str(SOCKNAL, le64_to_cpu(hdr->src_nid), ipbuf),
1015                        le64_to_cpu(hdr->dest_nid),
1016                        portals_nid2str(SOCKNAL, le64_to_cpu(hdr->dest_nid), ipbuf2),
1017                        error);
1018         else
1019                 CDEBUG (D_NET, "routed packet from "LPX64" to "LPX64": OK\n",
1020                         le64_to_cpu(hdr->src_nid), le64_to_cpu(hdr->dest_nid));
1021
1022         /* drop peer ref taken on init */
1023         ksocknal_put_peer (fmb->fmb_peer);
1024
1025         spin_lock_irqsave (&fmp->fmp_lock, flags);
1026
1027         list_add (&fmb->fmb_list, &fmp->fmp_idle_fmbs);
1028         fmp->fmp_nactive_fmbs--;
1029
1030         if (!list_empty (&fmp->fmp_blocked_conns)) {
1031                 conn = list_entry (fmb->fmb_pool->fmp_blocked_conns.next,
1032                                    ksock_conn_t, ksnc_rx_list);
1033                 list_del (&conn->ksnc_rx_list);
1034         }
1035
1036         spin_unlock_irqrestore (&fmp->fmp_lock, flags);
1037
1038         if (conn == NULL)
1039                 return;
1040
1041         CDEBUG (D_NET, "Scheduling conn %p\n", conn);
1042         LASSERT (conn->ksnc_rx_scheduled);
1043         LASSERT (conn->ksnc_rx_state == SOCKNAL_RX_FMB_SLEEP);
1044
1045         conn->ksnc_rx_state = SOCKNAL_RX_GET_FMB;
1046
1047         sched = conn->ksnc_scheduler;
1048
1049         spin_lock_irqsave (&sched->kss_lock, flags);
1050
1051         list_add_tail (&conn->ksnc_rx_list, &sched->kss_rx_conns);
1052         cfs_waitq_signal (&sched->kss_waitq);
1053
1054         spin_unlock_irqrestore (&sched->kss_lock, flags);
1055 }
1056
1057 ksock_fmb_t *
1058 ksocknal_get_idle_fmb (ksock_conn_t *conn)
1059 {
1060         int               payload_nob = conn->ksnc_rx_nob_left;
1061         unsigned long     flags;
1062         ksock_fmb_pool_t *pool;
1063         ksock_fmb_t      *fmb;
1064
1065         LASSERT (conn->ksnc_rx_state == SOCKNAL_RX_GET_FMB);
1066         LASSERT (kpr_routing(&ksocknal_data.ksnd_router));
1067
1068         if (payload_nob <= SOCKNAL_SMALL_FWD_PAGES * CFS_PAGE_SIZE)
1069                 pool = &ksocknal_data.ksnd_small_fmp;
1070         else
1071                 pool = &ksocknal_data.ksnd_large_fmp;
1072
1073         spin_lock_irqsave (&pool->fmp_lock, flags);
1074
1075         if (!list_empty (&pool->fmp_idle_fmbs)) {
1076                 fmb = list_entry(pool->fmp_idle_fmbs.next,
1077                                  ksock_fmb_t, fmb_list);
1078                 list_del (&fmb->fmb_list);
1079                 pool->fmp_nactive_fmbs++;
1080                 spin_unlock_irqrestore (&pool->fmp_lock, flags);
1081
1082                 return (fmb);
1083         }
1084
1085         /* deschedule until fmb free */
1086
1087         conn->ksnc_rx_state = SOCKNAL_RX_FMB_SLEEP;
1088
1089         list_add_tail (&conn->ksnc_rx_list,
1090                        &pool->fmp_blocked_conns);
1091
1092         spin_unlock_irqrestore (&pool->fmp_lock, flags);
1093         return (NULL);
1094 }
1095
1096 int
1097 ksocknal_init_fmb (ksock_conn_t *conn, ksock_fmb_t *fmb)
1098 {
1099         int       payload_nob = conn->ksnc_rx_nob_left;
1100         ptl_nid_t dest_nid = le64_to_cpu(conn->ksnc_hdr.dest_nid);
1101         int       niov = 0;
1102         int       nob = payload_nob;
1103
1104         LASSERT (conn->ksnc_rx_scheduled);
1105         LASSERT (conn->ksnc_rx_state == SOCKNAL_RX_GET_FMB);
1106         LASSERT (conn->ksnc_rx_nob_wanted == conn->ksnc_rx_nob_left);
1107         LASSERT (payload_nob >= 0);
1108         LASSERT (payload_nob <= fmb->fmb_pool->fmp_buff_pages * CFS_PAGE_SIZE);
1109         LASSERT (sizeof (ptl_hdr_t) < CFS_PAGE_SIZE);
1110         LASSERT (fmb->fmb_kiov[0].kiov_offset == 0);
1111
1112         /* Take a ref on the conn's peer to prevent module unload before
1113          * forwarding completes. */
1114         fmb->fmb_peer = conn->ksnc_peer;
1115         atomic_inc (&conn->ksnc_peer->ksnp_refcount);
1116
1117         /* Copy the header we just read into the forwarding buffer.  If
1118          * there's payload, start reading reading it into the buffer,
1119          * otherwise the forwarding buffer can be kicked off
1120          * immediately. */
1121         fmb->fmb_hdr = conn->ksnc_hdr;
1122
1123         while (nob > 0) {
1124                 LASSERT (niov < fmb->fmb_pool->fmp_buff_pages);
1125                 LASSERT (fmb->fmb_kiov[niov].kiov_offset == 0);
1126                 fmb->fmb_kiov[niov].kiov_len = MIN (CFS_PAGE_SIZE, nob);
1127                 nob -= CFS_PAGE_SIZE;
1128                 niov++;
1129         }
1130
1131         kpr_fwd_init(&fmb->fmb_fwd, dest_nid, &fmb->fmb_hdr,
1132                      payload_nob, niov, fmb->fmb_kiov,
1133                      ksocknal_fmb_callback, fmb);
1134
1135         if (payload_nob == 0) {         /* got complete packet already */
1136                 CDEBUG (D_NET, "%p "LPX64"->"LPX64" fwd_start (immediate)\n",
1137                         conn, le64_to_cpu(conn->ksnc_hdr.src_nid), dest_nid);
1138
1139                 kpr_fwd_start (&ksocknal_data.ksnd_router, &fmb->fmb_fwd);
1140
1141                 ksocknal_new_packet (conn, 0);  /* on to next packet */
1142                 return (1);
1143         }
1144
1145         conn->ksnc_cookie = fmb;                /* stash fmb for later */
1146         conn->ksnc_rx_state = SOCKNAL_RX_BODY_FWD; /* read in the payload */
1147
1148         /* Set up conn->ksnc_rx_kiov to read the payload into fmb's kiov-ed
1149          * buffer */
1150         LASSERT (niov <= sizeof(conn->ksnc_rx_iov_space)/sizeof(ptl_kiov_t));
1151
1152         conn->ksnc_rx_niov = 0;
1153         conn->ksnc_rx_nkiov = niov;
1154         conn->ksnc_rx_kiov = conn->ksnc_rx_iov_space.kiov;
1155         memcpy(conn->ksnc_rx_kiov, fmb->fmb_kiov, niov * sizeof(ptl_kiov_t));
1156
1157         CDEBUG (D_NET, "%p "LPX64"->"LPX64" %d reading body\n", conn,
1158                 le64_to_cpu(conn->ksnc_hdr.src_nid), dest_nid, payload_nob);
1159         return (0);
1160 }
1161
1162 void
1163 ksocknal_fwd_parse (ksock_conn_t *conn)
1164 {
1165         ksock_peer_t *peer;
1166         ptl_nid_t     dest_nid = le64_to_cpu(conn->ksnc_hdr.dest_nid);
1167         ptl_nid_t     src_nid = le64_to_cpu(conn->ksnc_hdr.src_nid);
1168         int           body_len = le32_to_cpu(conn->ksnc_hdr.payload_length);
1169         char str[PTL_NALFMT_SIZE];
1170         char str2[PTL_NALFMT_SIZE];
1171
1172         CDEBUG (D_NET, "%p "LPX64"->"LPX64" %d parsing header\n", conn,
1173                 src_nid, dest_nid, conn->ksnc_rx_nob_left);
1174
1175         LASSERT (conn->ksnc_rx_state == SOCKNAL_RX_HEADER);
1176         LASSERT (conn->ksnc_rx_scheduled);
1177
1178         if (body_len < 0) {                 /* length corrupt (overflow) */
1179                 CERROR("dropping packet from "LPX64" (%s) for "LPX64" (%s): "
1180                        "packet size %d illegal\n",
1181                        src_nid, portals_nid2str(TCPNAL, src_nid, str),
1182                        dest_nid, portals_nid2str(TCPNAL, dest_nid, str2),
1183                        body_len);
1184
1185                 ksocknal_new_packet (conn, 0);  /* on to new packet */
1186                 return;
1187         }
1188
1189         if (!kpr_routing(&ksocknal_data.ksnd_router)) {    /* not forwarding */
1190                 CERROR("dropping packet from "LPX64" (%s) for "LPX64
1191                        " (%s): not forwarding\n",
1192                        src_nid, portals_nid2str(TCPNAL, src_nid, str),
1193                        dest_nid, portals_nid2str(TCPNAL, dest_nid, str2));
1194                 /* on to new packet (skip this one's body) */
1195                 ksocknal_new_packet (conn, body_len);
1196                 return;
1197         }
1198
1199         if (body_len > PTL_MTU) {      /* too big to forward */
1200                 CERROR ("dropping packet from "LPX64" (%s) for "LPX64
1201                         "(%s): packet size %d too big\n",
1202                         src_nid, portals_nid2str(TCPNAL, src_nid, str),
1203                         dest_nid, portals_nid2str(TCPNAL, dest_nid, str2),
1204                         body_len);
1205                 /* on to new packet (skip this one's body) */
1206                 ksocknal_new_packet (conn, body_len);
1207                 return;
1208         }
1209
1210         /* should have gone direct */
1211         peer = ksocknal_get_peer (conn->ksnc_hdr.dest_nid);
1212         if (peer != NULL) {
1213                 CERROR ("dropping packet from "LPX64" (%s) for "LPX64
1214                         "(%s): target is a peer\n",
1215                         src_nid, portals_nid2str(TCPNAL, src_nid, str),
1216                         dest_nid, portals_nid2str(TCPNAL, dest_nid, str2));
1217                 ksocknal_put_peer (peer);  /* drop ref from get above */
1218
1219                 /* on to next packet (skip this one's body) */
1220                 ksocknal_new_packet (conn, body_len);
1221                 return;
1222         }
1223
1224         conn->ksnc_rx_state = SOCKNAL_RX_GET_FMB;       /* Getting FMB now */
1225         conn->ksnc_rx_nob_left = body_len;              /* stash packet size */
1226         conn->ksnc_rx_nob_wanted = body_len;            /* (no slop) */
1227 }
1228
1229 int
1230 ksocknal_new_packet (ksock_conn_t *conn, int nob_to_skip)
1231 {
1232         static char ksocknal_slop_buffer[4096];
1233
1234         int   nob;
1235         int   niov;
1236         int   skipped;
1237
1238         if (nob_to_skip == 0) {         /* right at next packet boundary now */
1239                 conn->ksnc_rx_started = 0;
1240                 mb ();                          /* racing with timeout thread */
1241
1242                 conn->ksnc_rx_state = SOCKNAL_RX_HEADER;
1243                 conn->ksnc_rx_nob_wanted = sizeof (ptl_hdr_t);
1244                 conn->ksnc_rx_nob_left = sizeof (ptl_hdr_t);
1245
1246                 conn->ksnc_rx_iov = (struct iovec *)&conn->ksnc_rx_iov_space;
1247                 conn->ksnc_rx_iov[0].iov_base = (char *)&conn->ksnc_hdr;
1248                 conn->ksnc_rx_iov[0].iov_len  = sizeof (ptl_hdr_t);
1249                 conn->ksnc_rx_niov = 1;
1250
1251                 conn->ksnc_rx_kiov = NULL;
1252                 conn->ksnc_rx_nkiov = 0;
1253                 return (1);
1254         }
1255
1256         /* Set up to skip as much a possible now.  If there's more left
1257          * (ran out of iov entries) we'll get called again */
1258
1259         conn->ksnc_rx_state = SOCKNAL_RX_SLOP;
1260         conn->ksnc_rx_nob_left = nob_to_skip;
1261         conn->ksnc_rx_iov = (struct iovec *)&conn->ksnc_rx_iov_space;
1262         skipped = 0;
1263         niov = 0;
1264
1265         do {
1266                 nob = MIN (nob_to_skip, sizeof (ksocknal_slop_buffer));
1267
1268                 conn->ksnc_rx_iov[niov].iov_base = ksocknal_slop_buffer;
1269                 conn->ksnc_rx_iov[niov].iov_len  = nob;
1270                 niov++;
1271                 skipped += nob;
1272                 nob_to_skip -=nob;
1273
1274         } while (nob_to_skip != 0 &&    /* mustn't overflow conn's rx iov */
1275                  niov < sizeof(conn->ksnc_rx_iov_space) / sizeof (struct iovec));
1276
1277         conn->ksnc_rx_niov = niov;
1278         conn->ksnc_rx_kiov = NULL;
1279         conn->ksnc_rx_nkiov = 0;
1280         conn->ksnc_rx_nob_wanted = skipped;
1281         return (0);
1282 }
1283
1284 int
1285 ksocknal_process_receive (ksock_conn_t *conn)
1286 {
1287         ksock_fmb_t  *fmb;
1288         int           rc;
1289
1290         LASSERT (atomic_read (&conn->ksnc_refcount) > 0);
1291
1292         /* doesn't need a forwarding buffer */
1293         if (conn->ksnc_rx_state != SOCKNAL_RX_GET_FMB)
1294                 goto try_read;
1295
1296  get_fmb:
1297         fmb = ksocknal_get_idle_fmb (conn);
1298         if (fmb == NULL) {
1299                 /* conn descheduled waiting for idle fmb */
1300                 return (0);
1301         }
1302
1303         if (ksocknal_init_fmb (conn, fmb)) {
1304                 /* packet forwarded */
1305                 return (0);
1306         }
1307
1308  try_read:
1309         /* NB: sched lock NOT held */
1310         LASSERT (conn->ksnc_rx_state == SOCKNAL_RX_HEADER ||
1311                  conn->ksnc_rx_state == SOCKNAL_RX_BODY ||
1312                  conn->ksnc_rx_state == SOCKNAL_RX_BODY_FWD ||
1313                  conn->ksnc_rx_state == SOCKNAL_RX_SLOP);
1314
1315         LASSERT (conn->ksnc_rx_nob_wanted > 0);
1316
1317         rc = ksocknal_receive(conn);
1318
1319         if (rc <= 0) {
1320                 LASSERT (rc != -EAGAIN);
1321
1322                 if (rc == 0)
1323                         CWARN ("[%p] EOF from "LPX64" ip %d.%d.%d.%d:%d\n",
1324                                conn, conn->ksnc_peer->ksnp_nid,
1325                                HIPQUAD(conn->ksnc_ipaddr),
1326                                conn->ksnc_port);
1327                 else if (!conn->ksnc_closing)
1328                         CERROR ("[%p] Error %d on read from "LPX64
1329                                 " ip %d.%d.%d.%d:%d\n",
1330                                 conn, rc, conn->ksnc_peer->ksnp_nid,
1331                                 HIPQUAD(conn->ksnc_ipaddr),
1332                                 conn->ksnc_port);
1333
1334                 ksocknal_close_conn_and_siblings (conn, rc);
1335                 return (rc == 0 ? -ESHUTDOWN : rc);
1336         }
1337
1338         if (conn->ksnc_rx_nob_wanted != 0) {
1339                 /* short read */
1340                 return (-EAGAIN);
1341         }
1342
1343         switch (conn->ksnc_rx_state) {
1344         case SOCKNAL_RX_HEADER:
1345                 if (conn->ksnc_hdr.type != cpu_to_le32(PTL_MSG_HELLO) &&
1346                     le64_to_cpu(conn->ksnc_hdr.dest_nid) !=
1347                     ksocknal_lib.libnal_ni.ni_pid.nid) {
1348                         /* This packet isn't for me */
1349                         ksocknal_fwd_parse (conn);
1350                         switch (conn->ksnc_rx_state) {
1351                         case SOCKNAL_RX_HEADER: /* skipped (zero payload) */
1352                                 return (0);     /* => come back later */
1353                         case SOCKNAL_RX_SLOP:   /* skipping packet's body */
1354                                 goto try_read;  /* => go read it */
1355                         case SOCKNAL_RX_GET_FMB: /* forwarding */
1356                                 goto get_fmb;   /* => go get a fwd msg buffer */
1357                         default:
1358                                 LBUG ();
1359                         }
1360                         /* Not Reached */
1361                 }
1362
1363                 /* sets wanted_len, iovs etc */
1364                 rc = lib_parse(&ksocknal_lib, &conn->ksnc_hdr, conn);
1365
1366                 if (rc != PTL_OK) {
1367                         /* I just received garbage: give up on this conn */
1368                         ksocknal_close_conn_and_siblings (conn, rc);
1369                         return (-EPROTO);
1370                 }
1371
1372                 if (conn->ksnc_rx_nob_wanted != 0) { /* need to get payload? */
1373                         conn->ksnc_rx_state = SOCKNAL_RX_BODY;
1374                         goto try_read;          /* go read the payload */
1375                 }
1376                 /* Fall through (completed packet for me) */
1377
1378         case SOCKNAL_RX_BODY:
1379                 /* payload all received */
1380                 lib_finalize(&ksocknal_lib, NULL, conn->ksnc_cookie, PTL_OK);
1381                 /* Fall through */
1382
1383         case SOCKNAL_RX_SLOP:
1384                 /* starting new packet? */
1385                 if (ksocknal_new_packet (conn, conn->ksnc_rx_nob_left))
1386                         return (0);     /* come back later */
1387                 goto try_read;          /* try to finish reading slop now */
1388
1389         case SOCKNAL_RX_BODY_FWD:
1390                 /* payload all received */
1391                 CDEBUG (D_NET, "%p "LPX64"->"LPX64" %d fwd_start (got body)\n",
1392                         conn, le64_to_cpu(conn->ksnc_hdr.src_nid),
1393                         le64_to_cpu(conn->ksnc_hdr.dest_nid),
1394                         conn->ksnc_rx_nob_left);
1395
1396                 /* forward the packet. NB ksocknal_init_fmb() put fmb into
1397                  * conn->ksnc_cookie */
1398                 fmb = (ksock_fmb_t *)conn->ksnc_cookie;
1399                 kpr_fwd_start (&ksocknal_data.ksnd_router, &fmb->fmb_fwd);
1400
1401                 /* no slop in forwarded packets */
1402                 LASSERT (conn->ksnc_rx_nob_left == 0);
1403
1404                 ksocknal_new_packet (conn, 0);  /* on to next packet */
1405                 return (0);                     /* (later) */
1406
1407         default:
1408                 break;
1409         }
1410
1411         /* Not Reached */
1412         LBUG ();
1413         return (-EINVAL);                       /* keep gcc happy */
1414 }
1415
1416 ptl_err_t
1417 ksocknal_recv (lib_nal_t *nal, void *private, lib_msg_t *msg,
1418                unsigned int niov, struct iovec *iov,
1419                size_t offset, size_t mlen, size_t rlen)
1420 {
1421         ksock_conn_t *conn = (ksock_conn_t *)private;
1422
1423         LASSERT (mlen <= rlen);
1424         LASSERT (niov <= PTL_MD_MAX_IOV);
1425
1426         conn->ksnc_cookie = msg;
1427         conn->ksnc_rx_nob_wanted = mlen;
1428         conn->ksnc_rx_nob_left   = rlen;
1429
1430         conn->ksnc_rx_nkiov = 0;
1431         conn->ksnc_rx_kiov = NULL;
1432         conn->ksnc_rx_iov = conn->ksnc_rx_iov_space.iov;
1433         conn->ksnc_rx_niov =
1434                 lib_extract_iov(PTL_MD_MAX_IOV, conn->ksnc_rx_iov,
1435                                 niov, iov, offset, mlen);
1436
1437         LASSERT (mlen ==
1438                  lib_iov_nob (conn->ksnc_rx_niov, conn->ksnc_rx_iov) +
1439                  lib_kiov_nob (conn->ksnc_rx_nkiov, conn->ksnc_rx_kiov));
1440
1441         return (PTL_OK);
1442 }
1443
1444 ptl_err_t
1445 ksocknal_recv_pages (lib_nal_t *nal, void *private, lib_msg_t *msg,
1446                      unsigned int niov, ptl_kiov_t *kiov,
1447                      size_t offset, size_t mlen, size_t rlen)
1448 {
1449         ksock_conn_t *conn = (ksock_conn_t *)private;
1450
1451         LASSERT (mlen <= rlen);
1452         LASSERT (niov <= PTL_MD_MAX_IOV);
1453
1454         conn->ksnc_cookie = msg;
1455         conn->ksnc_rx_nob_wanted = mlen;
1456         conn->ksnc_rx_nob_left   = rlen;
1457
1458         conn->ksnc_rx_niov = 0;
1459         conn->ksnc_rx_iov  = NULL;
1460         conn->ksnc_rx_kiov = conn->ksnc_rx_iov_space.kiov;
1461         conn->ksnc_rx_nkiov =
1462                 lib_extract_kiov(PTL_MD_MAX_IOV, conn->ksnc_rx_kiov,
1463                                  niov, kiov, offset, mlen);
1464
1465         LASSERT (mlen ==
1466                  lib_iov_nob (conn->ksnc_rx_niov, conn->ksnc_rx_iov) +
1467                  lib_kiov_nob (conn->ksnc_rx_nkiov, conn->ksnc_rx_kiov));
1468
1469         return (PTL_OK);
1470 }
1471
1472 static inline int
1473 ksocknal_sched_cansleep(ksock_sched_t *sched)
1474 {
1475         unsigned long flags;
1476         int           rc;
1477
1478         spin_lock_irqsave(&sched->kss_lock, flags);
1479
1480         rc = (!ksocknal_data.ksnd_shuttingdown &&
1481 #if SOCKNAL_ZC
1482               list_empty(&sched->kss_zctxdone_list) &&
1483 #endif
1484               list_empty(&sched->kss_rx_conns) &&
1485               list_empty(&sched->kss_tx_conns));
1486
1487         spin_unlock_irqrestore(&sched->kss_lock, flags);
1488         return (rc);
1489 }
1490
1491 int ksocknal_scheduler (void *arg)
1492 {
1493         ksock_sched_t     *sched = (ksock_sched_t *)arg;
1494         ksock_conn_t      *conn;
1495         ksock_tx_t        *tx;
1496         unsigned long      flags;
1497         int                rc;
1498         int                nloops = 0;
1499         int                id = sched - ksocknal_data.ksnd_schedulers;
1500         char               name[16];
1501
1502         snprintf (name, sizeof (name),"ksocknald_%02d", id);
1503         kportal_daemonize (name);
1504         kportal_blockallsigs ();
1505
1506 #if (CONFIG_SMP && CPU_AFFINITY)
1507         id = ksocknal_sched2cpu(id);
1508         if (cpu_online(id)) {
1509                 cpumask_t m;
1510                 cpu_set(id, m);
1511                 set_cpus_allowed(current, m);
1512         } else {
1513                 CERROR ("Can't set CPU affinity for %s to %d\n", name, id);
1514         }
1515 #endif /* CONFIG_SMP && CPU_AFFINITY */
1516
1517         spin_lock_irqsave (&sched->kss_lock, flags);
1518
1519         while (!ksocknal_data.ksnd_shuttingdown) {
1520                 int did_something = 0;
1521
1522                 /* Ensure I progress everything semi-fairly */
1523
1524                 if (!list_empty (&sched->kss_rx_conns)) {
1525                         conn = list_entry(sched->kss_rx_conns.next,
1526                                           ksock_conn_t, ksnc_rx_list);
1527                         list_del(&conn->ksnc_rx_list);
1528
1529                         LASSERT(conn->ksnc_rx_scheduled);
1530                         LASSERT(conn->ksnc_rx_ready);
1531
1532                         /* clear rx_ready in case receive isn't complete.
1533                          * Do it BEFORE we call process_recv, since
1534                          * data_ready can set it any time after we release
1535                          * kss_lock. */
1536                         conn->ksnc_rx_ready = 0;
1537                         spin_unlock_irqrestore(&sched->kss_lock, flags);
1538
1539                         rc = ksocknal_process_receive(conn);
1540
1541                         spin_lock_irqsave(&sched->kss_lock, flags);
1542
1543                         /* I'm the only one that can clear this flag */
1544                         LASSERT(conn->ksnc_rx_scheduled);
1545
1546                         /* Did process_receive get everything it wanted? */
1547                         if (rc == 0)
1548                                 conn->ksnc_rx_ready = 1;
1549
1550                         if (conn->ksnc_rx_state == SOCKNAL_RX_FMB_SLEEP ||
1551                             conn->ksnc_rx_state == SOCKNAL_RX_GET_FMB) {
1552                                 /* Conn blocked for a forwarding buffer.
1553                                  * It will get queued for my attention when
1554                                  * one becomes available (and it might just
1555                                  * already have been!).  Meanwhile my ref
1556                                  * on it stays put. */
1557                         } else if (conn->ksnc_rx_ready) {
1558                                 /* reschedule for rx */
1559                                 list_add_tail (&conn->ksnc_rx_list,
1560                                                &sched->kss_rx_conns);
1561                         } else {
1562                                 conn->ksnc_rx_scheduled = 0;
1563                                 /* drop my ref */
1564                                 ksocknal_put_conn(conn);
1565                         }
1566
1567                         did_something = 1;
1568                 }
1569
1570                 if (!list_empty (&sched->kss_tx_conns)) {
1571                         conn = list_entry(sched->kss_tx_conns.next,
1572                                           ksock_conn_t, ksnc_tx_list);
1573                         list_del (&conn->ksnc_tx_list);
1574
1575                         LASSERT(conn->ksnc_tx_scheduled);
1576                         LASSERT(conn->ksnc_tx_ready);
1577                         LASSERT(!list_empty(&conn->ksnc_tx_queue));
1578
1579                         tx = list_entry(conn->ksnc_tx_queue.next,
1580                                         ksock_tx_t, tx_list);
1581                         /* dequeue now so empty list => more to send */
1582                         list_del(&tx->tx_list);
1583
1584                         /* Clear tx_ready in case send isn't complete.  Do
1585                          * it BEFORE we call process_transmit, since
1586                          * write_space can set it any time after we release
1587                          * kss_lock. */
1588                         conn->ksnc_tx_ready = 0;
1589                         spin_unlock_irqrestore (&sched->kss_lock, flags);
1590
1591                         rc = ksocknal_process_transmit(conn, tx);
1592
1593                         spin_lock_irqsave (&sched->kss_lock, flags);
1594
1595                         if (rc == -ENOMEM || rc == -EAGAIN) {
1596                                 /* Incomplete send: replace tx on HEAD of tx_queue */
1597                                 list_add (&tx->tx_list, &conn->ksnc_tx_queue);
1598                         } else {
1599                                 /* Complete send; assume space for more */
1600                                 conn->ksnc_tx_ready = 1;
1601                         }
1602
1603                         if (rc == -ENOMEM) {
1604                                 /* Do nothing; after a short timeout, this
1605                                  * conn will be reposted on kss_tx_conns. */
1606                         } else if (conn->ksnc_tx_ready &&
1607                                    !list_empty (&conn->ksnc_tx_queue)) {
1608                                 /* reschedule for tx */
1609                                 list_add_tail (&conn->ksnc_tx_list,
1610                                                &sched->kss_tx_conns);
1611                         } else {
1612                                 conn->ksnc_tx_scheduled = 0;
1613                                 /* drop my ref */
1614                                 ksocknal_put_conn (conn);
1615                         }
1616
1617                         did_something = 1;
1618                 }
1619 #if SOCKNAL_ZC
1620                 if (!list_empty (&sched->kss_zctxdone_list)) {
1621                         ksock_tx_t *tx =
1622                                 list_entry(sched->kss_zctxdone_list.next,
1623                                            ksock_tx_t, tx_list);
1624                         did_something = 1;
1625
1626                         list_del (&tx->tx_list);
1627                         spin_unlock_irqrestore (&sched->kss_lock, flags);
1628
1629                         ksocknal_tx_done (tx, 1);
1630
1631                         spin_lock_irqsave (&sched->kss_lock, flags);
1632                 }
1633 #endif
1634                 if (!did_something ||           /* nothing to do */
1635                     ++nloops == SOCKNAL_RESCHED) { /* hogging CPU? */
1636                         spin_unlock_irqrestore (&sched->kss_lock, flags);
1637
1638                         nloops = 0;
1639
1640                         if (!did_something) {   /* wait for something to do */
1641                                 rc = wait_event_interruptible (sched->kss_waitq,
1642                                                                !ksocknal_sched_cansleep(sched));
1643                                 LASSERT (rc == 0);
1644                         } else
1645                                our_cond_resched();
1646
1647                         spin_lock_irqsave (&sched->kss_lock, flags);
1648                 }
1649         }
1650
1651         spin_unlock_irqrestore (&sched->kss_lock, flags);
1652         ksocknal_thread_fini ();
1653         return (0);
1654 }
1655
1656 /*
1657  * Add connection to kss_rx_conns of scheduler
1658  * and wakeup the scheduler.
1659  */
1660 void ksocknal_read_callback (ksock_conn_t *conn)
1661 {
1662         ksock_sched_t *sched;
1663         unsigned long  flags;
1664         ENTRY;
1665
1666         sched = conn->ksnc_scheduler;
1667
1668         spin_lock_irqsave (&sched->kss_lock, flags);
1669
1670         conn->ksnc_rx_ready = 1;
1671
1672         if (!conn->ksnc_rx_scheduled) {  /* not being progressed */
1673                 list_add_tail(&conn->ksnc_rx_list,
1674                               &sched->kss_rx_conns);
1675                 conn->ksnc_rx_scheduled = 1;
1676                 /* extra ref for scheduler */
1677                 atomic_inc (&conn->ksnc_refcount);
1678
1679                 cfs_waitq_signal (&sched->kss_waitq);
1680         }
1681         spin_unlock_irqrestore (&sched->kss_lock, flags);
1682
1683         EXIT;
1684 }
1685
1686 /*
1687  * Add connection to kss_tx_conns of scheduler
1688  * and wakeup the scheduler.
1689  */
1690 void ksocknal_write_callback (ksock_conn_t *conn)
1691 {
1692         ksock_sched_t *sched;
1693         unsigned long  flags;
1694         ENTRY;
1695
1696         sched = conn->ksnc_scheduler;
1697
1698         spin_lock_irqsave (&sched->kss_lock, flags);
1699
1700         conn->ksnc_tx_ready = 1;
1701
1702         if (!conn->ksnc_tx_scheduled && // not being progressed
1703             !list_empty(&conn->ksnc_tx_queue)){//packets to send
1704                 list_add_tail (&conn->ksnc_tx_list,
1705                                &sched->kss_tx_conns);
1706                 conn->ksnc_tx_scheduled = 1;
1707                 /* extra ref for scheduler */
1708                 atomic_inc (&conn->ksnc_refcount);
1709
1710                 cfs_waitq_signal (&sched->kss_waitq);
1711         }
1712
1713         spin_unlock_irqrestore (&sched->kss_lock, flags);
1714
1715         EXIT;
1716 }
1717
1718 int
1719 ksocknal_sock_write (struct socket *sock, void *buffer, int nob)
1720 {
1721         return ksocknal_lib_sock_write(sock, buffer, nob);
1722 }
1723
1724 int
1725 ksocknal_sock_read (struct socket *sock, void *buffer, int nob)
1726 {
1727         return ksocknal_lib_sock_read(sock, buffer, nob);
1728 }
1729
1730 int
1731 ksocknal_send_hello (ksock_conn_t *conn, __u32 *ipaddrs, int nipaddrs)
1732 {
1733         /* CAVEAT EMPTOR: this byte flips 'ipaddrs' */
1734         struct socket      *sock = conn->ksnc_sock;
1735         ptl_hdr_t           hdr;
1736         ptl_magicversion_t *hmv = (ptl_magicversion_t *)&hdr.dest_nid;
1737         int                 i;
1738         int                 rc;
1739
1740         LASSERT (conn->ksnc_type != SOCKNAL_CONN_NONE);
1741         LASSERT (nipaddrs <= SOCKNAL_MAX_INTERFACES);
1742
1743         /* No need for getconnsock/putconnsock */
1744         LASSERT (!conn->ksnc_closing);
1745
1746         LASSERT (sizeof (*hmv) == sizeof (hdr.dest_nid));
1747         hmv->magic         = cpu_to_le32 (PORTALS_PROTO_MAGIC);
1748         hmv->version_major = cpu_to_le16 (PORTALS_PROTO_VERSION_MAJOR);
1749         hmv->version_minor = cpu_to_le16 (PORTALS_PROTO_VERSION_MINOR);
1750
1751         hdr.src_nid        = cpu_to_le64 (ksocknal_lib.libnal_ni.ni_pid.nid);
1752         hdr.type           = cpu_to_le32 (PTL_MSG_HELLO);
1753         hdr.payload_length = cpu_to_le32 (nipaddrs * sizeof(*ipaddrs));
1754
1755         hdr.msg.hello.type = cpu_to_le32 (conn->ksnc_type);
1756         hdr.msg.hello.incarnation =
1757                 cpu_to_le64 (ksocknal_data.ksnd_incarnation);
1758
1759         /* Receiver is eager */
1760         rc = ksocknal_sock_write (sock, &hdr, sizeof(hdr));
1761         if (rc != 0) {
1762                 CERROR ("Error %d sending HELLO hdr to %u.%u.%u.%u/%d\n",
1763                         rc, HIPQUAD(conn->ksnc_ipaddr), conn->ksnc_port);
1764                 return (rc);
1765         }
1766
1767         if (nipaddrs == 0)
1768                 return (0);
1769
1770         for (i = 0; i < nipaddrs; i++) {
1771                 ipaddrs[i] = __cpu_to_le32 (ipaddrs[i]);
1772         }
1773
1774         rc = ksocknal_sock_write (sock, ipaddrs, nipaddrs * sizeof(*ipaddrs));
1775         if (rc != 0)
1776                 CERROR ("Error %d sending HELLO payload (%d)"
1777                         " to %u.%u.%u.%u/%d\n", rc, nipaddrs,
1778                         HIPQUAD(conn->ksnc_ipaddr), conn->ksnc_port);
1779         return (rc);
1780 }
1781
1782 int
1783 ksocknal_invert_type(int type)
1784 {
1785         switch (type)
1786         {
1787         case SOCKNAL_CONN_ANY:
1788         case SOCKNAL_CONN_CONTROL:
1789                 return (type);
1790         case SOCKNAL_CONN_BULK_IN:
1791                 return SOCKNAL_CONN_BULK_OUT;
1792         case SOCKNAL_CONN_BULK_OUT:
1793                 return SOCKNAL_CONN_BULK_IN;
1794         default:
1795                 return (SOCKNAL_CONN_NONE);
1796         }
1797 }
1798
1799 int
1800 ksocknal_recv_hello (ksock_conn_t *conn, ptl_nid_t *nid,
1801                      __u64 *incarnation, __u32 *ipaddrs)
1802 {
1803         struct socket      *sock = conn->ksnc_sock;
1804         int                 rc;
1805         int                 nips;
1806         int                 i;
1807         int                 type;
1808         ptl_hdr_t           hdr;
1809         ptl_magicversion_t *hmv;
1810         char                ipbuf[PTL_NALFMT_SIZE];
1811
1812         hmv = (ptl_magicversion_t *)&hdr.dest_nid;
1813         LASSERT (sizeof (*hmv) == sizeof (hdr.dest_nid));
1814
1815         rc = ksocknal_sock_read (sock, hmv, sizeof (*hmv));
1816         if (rc != 0) {
1817                 CERROR ("Error %d reading HELLO from %u.%u.%u.%u\n",
1818                         rc, HIPQUAD(conn->ksnc_ipaddr));
1819                 return (rc);
1820         }
1821
1822         if (hmv->magic != le32_to_cpu (PORTALS_PROTO_MAGIC)) {
1823                 CERROR ("Bad magic %#08x (%#08x expected) from %u.%u.%u.%u\n",
1824                         __cpu_to_le32 (hmv->magic), PORTALS_PROTO_MAGIC,
1825                         HIPQUAD(conn->ksnc_ipaddr));
1826                 return (-EPROTO);
1827         }
1828
1829         if (hmv->version_major != cpu_to_le16 (PORTALS_PROTO_VERSION_MAJOR) ||
1830             hmv->version_minor != cpu_to_le16 (PORTALS_PROTO_VERSION_MINOR)) {
1831                 CERROR ("Incompatible protocol version %d.%d (%d.%d expected)"
1832                         " from %u.%u.%u.%u\n",
1833                         le16_to_cpu (hmv->version_major),
1834                         le16_to_cpu (hmv->version_minor),
1835                         PORTALS_PROTO_VERSION_MAJOR,
1836                         PORTALS_PROTO_VERSION_MINOR,
1837                         HIPQUAD(conn->ksnc_ipaddr));
1838                 return (-EPROTO);
1839         }
1840
1841 #if (PORTALS_PROTO_VERSION_MAJOR != 1)
1842 # error "This code only understands protocol version 1.x"
1843 #endif
1844         /* version 1 sends magic/version as the dest_nid of a 'hello'
1845          * header, followed by payload full of interface IP addresses.
1846          * Read the rest of it in now... */
1847
1848         rc = ksocknal_sock_read (sock, hmv + 1, sizeof (hdr) - sizeof (*hmv));
1849         if (rc != 0) {
1850                 CERROR ("Error %d reading rest of HELLO hdr from %u.%u.%u.%u\n",
1851                         rc, HIPQUAD(conn->ksnc_ipaddr));
1852                 return (rc);
1853         }
1854
1855         /* ...and check we got what we expected */
1856         if (hdr.type != cpu_to_le32 (PTL_MSG_HELLO)) {
1857                 CERROR ("Expecting a HELLO hdr,"
1858                         " but got type %d from %u.%u.%u.%u\n",
1859                         le32_to_cpu (hdr.type),
1860                         HIPQUAD(conn->ksnc_ipaddr));
1861                 return (-EPROTO);
1862         }
1863
1864         if (le64_to_cpu(hdr.src_nid) == PTL_NID_ANY) {
1865                 CERROR("Expecting a HELLO hdr with a NID, but got PTL_NID_ANY"
1866                        "from %u.%u.%u.%u\n", HIPQUAD(conn->ksnc_ipaddr));
1867                 return (-EPROTO);
1868         }
1869
1870         if (*nid == PTL_NID_ANY) {              /* don't know peer's nid yet */
1871                 *nid = le64_to_cpu(hdr.src_nid);
1872         } else if (*nid != le64_to_cpu (hdr.src_nid)) {
1873                 LCONSOLE_ERROR("Connected successfully to nid "LPX64" on host "
1874                                "%u.%u.%u.%u, but they claimed they were nid "
1875                                LPX64" (%s); please check your Lustre "
1876                                "configuration.\n",
1877                                *nid, HIPQUAD(conn->ksnc_ipaddr),
1878                                le64_to_cpu(hdr.src_nid),
1879                                portals_nid2str(SOCKNAL,
1880                                                le64_to_cpu(hdr.src_nid),
1881                                                ipbuf));
1882
1883                 CERROR ("Connected to nid "LPX64"@%u.%u.%u.%u "
1884                         "but expecting "LPX64"\n",
1885                         le64_to_cpu (hdr.src_nid),
1886                         HIPQUAD(conn->ksnc_ipaddr), *nid);
1887                 return (-EPROTO);
1888         }
1889
1890         type = __le32_to_cpu(hdr.msg.hello.type);
1891
1892         if (conn->ksnc_type == SOCKNAL_CONN_NONE) {
1893                 /* I've accepted this connection; peer determines type */
1894                 conn->ksnc_type = ksocknal_invert_type(type);
1895                 if (conn->ksnc_type == SOCKNAL_CONN_NONE) {
1896                         CERROR ("Unexpected type %d from "LPX64"@%u.%u.%u.%u\n",
1897                                 type, *nid, HIPQUAD(conn->ksnc_ipaddr));
1898                         return (-EPROTO);
1899                 }
1900         } else if (ksocknal_invert_type(type) != conn->ksnc_type) {
1901                 CERROR ("Mismatched types: me %d, "LPX64"@%u.%u.%u.%u %d\n",
1902                         conn->ksnc_type, *nid, HIPQUAD(conn->ksnc_ipaddr),
1903                         le32_to_cpu(hdr.msg.hello.type));
1904                 return (-EPROTO);
1905         }
1906
1907         *incarnation = le64_to_cpu(hdr.msg.hello.incarnation);
1908
1909         nips = __le32_to_cpu (hdr.payload_length) / sizeof (__u32);
1910
1911         if (nips > SOCKNAL_MAX_INTERFACES ||
1912             nips * sizeof(__u32) != __le32_to_cpu (hdr.payload_length)) {
1913                 CERROR("Bad payload length %d from "LPX64"@%u.%u.%u.%u\n",
1914                        __le32_to_cpu (hdr.payload_length),
1915                        *nid, HIPQUAD(conn->ksnc_ipaddr));
1916         }
1917
1918         if (nips == 0)
1919                 return (0);
1920
1921         rc = ksocknal_sock_read (sock, ipaddrs, nips * sizeof(*ipaddrs));
1922         if (rc != 0) {
1923                 CERROR ("Error %d reading IPs from "LPX64"@%u.%u.%u.%u\n",
1924                         rc, *nid, HIPQUAD(conn->ksnc_ipaddr));
1925                 return (rc);
1926         }
1927
1928         for (i = 0; i < nips; i++) {
1929                 ipaddrs[i] = __le32_to_cpu(ipaddrs[i]);
1930
1931                 if (ipaddrs[i] == 0) {
1932                         CERROR("Zero IP[%d] from "LPX64"@%u.%u.%u.%u\n",
1933                                i, *nid, HIPQUAD(conn->ksnc_ipaddr));
1934                         return (-EPROTO);
1935                 }
1936         }
1937
1938         return (nips);
1939 }
1940
1941 int
1942 ksocknal_connect_peer (ksock_route_t *route, int type)
1943 {
1944         struct socket      *sock;
1945         int                 rc;
1946         int                 port;
1947         int                 may_retry;
1948
1949         /* Iterate through reserved ports.  When typed connections are
1950          * used, we will need to bind to multiple ports, but we only know
1951          * this at connect time.  But, by that time we've already called
1952          * bind() so we need a new socket. */
1953
1954         for (port = 1023; port > 512; --port) {
1955
1956                 rc = ksocknal_lib_connect_sock(&sock, &may_retry, route, port);
1957
1958                 if (rc == 0) {
1959                         rc = ksocknal_create_conn(route, sock, type);
1960                         cfs_put_file(KSN_SOCK2FILE(sock));
1961                         return rc;
1962                 }
1963
1964                 if (!may_retry)
1965                         return rc;
1966         }
1967
1968         CERROR("Out of ports trying to bind to a reserved port\n");
1969         return (-EADDRINUSE);
1970 }
1971
1972 void
1973 ksocknal_autoconnect (ksock_route_t *route)
1974 {
1975         CFS_LIST_HEAD    (zombies);
1976         ksock_tx_t       *tx;
1977         ksock_peer_t     *peer;
1978         unsigned long     flags;
1979         int               type;
1980         int               mask;
1981         int               rc = 0;
1982
1983         write_lock_irqsave (&ksocknal_data.ksnd_global_lock, flags);
1984
1985         for (;;) {
1986                 if (!ksocknal_tunables.ksnd_typed_conns) {
1987                         if ((route->ksnr_connected & (1<<SOCKNAL_CONN_ANY)) == 0)
1988                                 type = SOCKNAL_CONN_ANY;
1989                         else
1990                                 break;         /* got connected while route queued */
1991                 } else {
1992                         if ((route->ksnr_connected & (1<<SOCKNAL_CONN_CONTROL)) == 0)
1993                                 type = SOCKNAL_CONN_CONTROL;
1994                         else if ((route->ksnr_connected & (1<<SOCKNAL_CONN_BULK_IN)) == 0)
1995                                 type = SOCKNAL_CONN_BULK_IN;
1996                         else if ((route->ksnr_connected & (1<<SOCKNAL_CONN_BULK_OUT)) == 0)
1997                                 type = SOCKNAL_CONN_BULK_OUT;
1998                         else
1999                                 break;         /* got connected while route queued */
2000                 }
2001
2002                 write_unlock_irqrestore (&ksocknal_data.ksnd_global_lock, flags);
2003
2004                 rc = ksocknal_connect_peer (route, type);
2005                 if (rc != 0)
2006                         goto failed;
2007
2008                 write_lock_irqsave (&ksocknal_data.ksnd_global_lock, flags);
2009         }
2010
2011         LASSERT (route->ksnr_connecting);
2012         route->ksnr_connecting = 0;
2013         write_unlock_irqrestore (&ksocknal_data.ksnd_global_lock, flags);
2014         return;
2015
2016  failed:
2017         switch (rc) {
2018         /* "normal" errors */
2019         case -ECONNREFUSED:
2020                 LCONSOLE_ERROR("Connection was refused by host %u.%u.%u.%u on "
2021                                "port %d; check that Lustre is running on that "
2022                                "node.\n",
2023                                HIPQUAD(route->ksnr_ipaddr), route->ksnr_port);
2024                 break;
2025         case -EHOSTUNREACH:
2026         case -ENETUNREACH:
2027                 LCONSOLE_ERROR("Host %u.%u.%u.%u was unreachable; the network "
2028                                "or that node may be down, or Lustre may be "
2029                                "misconfigured.\n",
2030                                HIPQUAD(route->ksnr_ipaddr));
2031                 break;
2032         case -ETIMEDOUT:
2033                 LCONSOLE_ERROR("Connecting to host %u.%u.%u.%u on port %d took "
2034                                "too long; that node may be hung or "
2035                                "experiencing high load.\n",
2036                                HIPQUAD(route->ksnr_ipaddr), route->ksnr_port);
2037                 break;
2038         /* errors that should be rare */
2039         case -EPROTO:
2040                 LCONSOLE_ERROR("Protocol error connecting to host %u.%u.%u.%u "
2041                                "on port %d: Is it running a compatible version"
2042                                " of Lustre?\n",
2043                                HIPQUAD(route->ksnr_ipaddr), route->ksnr_port);
2044                 break;
2045         case -EADDRINUSE:
2046                 LCONSOLE_ERROR("No privileged ports available to connect to "
2047                                "host %u.%u.%u.%u on port %d\n",
2048                                HIPQUAD(route->ksnr_ipaddr), route->ksnr_port);
2049                 break;
2050         default:
2051                 LCONSOLE_ERROR("Unexpected error %d connecting to "
2052                                "host %u.%u.%u.%u on port %d\n", rc,
2053                                HIPQUAD(route->ksnr_ipaddr), route->ksnr_port);
2054                 break;
2055         }
2056
2057         write_lock_irqsave (&ksocknal_data.ksnd_global_lock, flags);
2058
2059         peer = route->ksnr_peer;
2060         LASSERT (route->ksnr_connecting);
2061         route->ksnr_connecting = 0;
2062
2063         /* This is a retry rather than a new connection */
2064         LASSERT (route->ksnr_retry_interval != 0);
2065         route->ksnr_timeout = cfs_time_add(cfs_time_current(),
2066                                            route->ksnr_retry_interval);
2067         route->ksnr_retry_interval = MIN (route->ksnr_retry_interval * 2,
2068                                           SOCKNAL_MAX_RECONNECT_INTERVAL);
2069
2070         if (!list_empty (&peer->ksnp_tx_queue) &&
2071             ksocknal_find_connecting_route_locked (peer) == NULL) {
2072                 LASSERT (list_empty (&peer->ksnp_conns));
2073
2074                 /* None of the connections that the blocked packets are
2075                  * waiting for have been successful.  Complete them now... */
2076                 do {
2077                         tx = list_entry (peer->ksnp_tx_queue.next,
2078                                          ksock_tx_t, tx_list);
2079                         list_del (&tx->tx_list);
2080                         list_add_tail (&tx->tx_list, &zombies);
2081                 } while (!list_empty (&peer->ksnp_tx_queue));
2082         }
2083
2084 #if 0           /* irrelevent with only eager routes */
2085         if (!route->ksnr_deleted) {
2086                 /* make this route least-favourite for re-selection */
2087                 list_del(&route->ksnr_list);
2088                 list_add_tail(&route->ksnr_list, &peer->ksnp_routes);
2089         }
2090 #endif
2091         write_unlock_irqrestore (&ksocknal_data.ksnd_global_lock, flags);
2092
2093         while (!list_empty (&zombies)) {
2094                 char ipbuf[PTL_NALFMT_SIZE];
2095                 char ipbuf2[PTL_NALFMT_SIZE];
2096                 tx = list_entry (zombies.next, ksock_tx_t, tx_list);
2097
2098                 CERROR ("Deleting packet type %d len %d ("LPX64" %s->"LPX64" %s)\n",
2099                         le32_to_cpu (tx->tx_hdr->type),
2100                         le32_to_cpu (tx->tx_hdr->payload_length),
2101                         le64_to_cpu (tx->tx_hdr->src_nid),
2102                         portals_nid2str(SOCKNAL,
2103                                         le64_to_cpu(tx->tx_hdr->src_nid),
2104                                         ipbuf),
2105                         le64_to_cpu (tx->tx_hdr->dest_nid),
2106                         portals_nid2str(SOCKNAL,
2107                                         le64_to_cpu(tx->tx_hdr->src_nid),
2108                                         ipbuf2));
2109
2110                 list_del (&tx->tx_list);
2111                 /* complete now */
2112                 ksocknal_tx_done (tx, 0);
2113         }
2114 }
2115
2116 int
2117 ksocknal_autoconnectd (void *arg)
2118 {
2119         long               id = (long)arg;
2120         char               name[16];
2121         unsigned long      flags;
2122         ksock_route_t     *route;
2123         int                rc;
2124
2125         snprintf (name, sizeof (name), "ksocknal_ad%02ld", id);
2126         kportal_daemonize (name);
2127         kportal_blockallsigs ();
2128
2129         spin_lock_irqsave (&ksocknal_data.ksnd_autoconnectd_lock, flags);
2130
2131         while (!ksocknal_data.ksnd_shuttingdown) {
2132
2133                 if (!list_empty (&ksocknal_data.ksnd_autoconnectd_routes)) {
2134                         route = list_entry (ksocknal_data.ksnd_autoconnectd_routes.next,
2135                                             ksock_route_t, ksnr_connect_list);
2136
2137                         list_del (&route->ksnr_connect_list);
2138                         spin_unlock_irqrestore (&ksocknal_data.ksnd_autoconnectd_lock, flags);
2139
2140                         ksocknal_autoconnect (route);
2141                         ksocknal_put_route (route);
2142
2143                         spin_lock_irqsave(&ksocknal_data.ksnd_autoconnectd_lock,
2144                                           flags);
2145                         continue;
2146                 }
2147
2148                 spin_unlock_irqrestore(&ksocknal_data.ksnd_autoconnectd_lock,
2149                                        flags);
2150
2151                 rc = wait_event_interruptible(ksocknal_data.ksnd_autoconnectd_waitq,
2152                                               ksocknal_data.ksnd_shuttingdown ||
2153                                               !list_empty(&ksocknal_data.ksnd_autoconnectd_routes));
2154
2155                 spin_lock_irqsave(&ksocknal_data.ksnd_autoconnectd_lock, flags);
2156         }
2157
2158         spin_unlock_irqrestore (&ksocknal_data.ksnd_autoconnectd_lock, flags);
2159
2160         ksocknal_thread_fini ();
2161         return (0);
2162 }
2163
2164 ksock_conn_t *
2165 ksocknal_find_timed_out_conn (ksock_peer_t *peer)
2166 {
2167         /* We're called with a shared lock on ksnd_global_lock */
2168         ksock_conn_t      *conn;
2169         struct list_head  *ctmp;
2170
2171         list_for_each (ctmp, &peer->ksnp_conns) {
2172                 conn = list_entry (ctmp, ksock_conn_t, ksnc_list);
2173
2174                 /* Don't need the {get,put}connsock dance to deref ksnc_sock... */
2175                 LASSERT (!conn->ksnc_closing);
2176
2177                 if (SOCK_ERROR(conn->ksnc_sock) != 0) {
2178                         atomic_inc (&conn->ksnc_refcount);
2179
2180                         switch (SOCK_ERROR(conn->ksnc_sock)) {
2181                         case ECONNRESET:
2182                                 LCONSOLE_WARN("A connection with %u.%u.%u.%u "
2183                                               "was reset; they may have "
2184                                               "rebooted.\n",
2185                                               HIPQUAD(conn->ksnc_ipaddr));
2186                                 break;
2187                         case ETIMEDOUT:
2188                                 LCONSOLE_WARN("A connection with %u.%u.%u.%u "
2189                                               "timed out; the network or that "
2190                                               "node may be down.\n",
2191                                               HIPQUAD(conn->ksnc_ipaddr));
2192                                 break;
2193                         default:
2194                                 LCONSOLE_WARN("An unexpected network error "
2195                                               "occurred with %u.%u.%u.%u: %d.\n",
2196                                               HIPQUAD(conn->ksnc_ipaddr),
2197                                               SOCK_ERROR(conn->ksnc_sock));
2198                                 break;
2199                         }
2200
2201                         /* Something (e.g. failed keepalive) set the socket error */
2202                         CERROR ("Socket error %d: "LPX64" %p %d.%d.%d.%d\n",
2203                                 SOCK_ERROR(conn->ksnc_sock), peer->ksnp_nid,
2204                                 conn, HIPQUAD(conn->ksnc_ipaddr));
2205
2206                         return (conn);
2207                 }
2208
2209                 if (conn->ksnc_rx_started &&
2210                     cfs_time_aftereq (cfs_time_current(),
2211                                       conn->ksnc_rx_deadline)) {
2212                         /* Timed out incomplete incoming message */
2213                         atomic_inc (&conn->ksnc_refcount);
2214                         LCONSOLE_ERROR("A timeout occurred receiving data from "
2215                                        "%u.%u.%u.%u; the network or that node "
2216                                        "may be down.\n",
2217                                        HIPQUAD(conn->ksnc_ipaddr));
2218                         CERROR ("Timed out RX from "LPX64" %p %d.%d.%d.%d\n",
2219                                 peer->ksnp_nid,conn,HIPQUAD(conn->ksnc_ipaddr));
2220                         return (conn);
2221                 }
2222
2223                 if ((!list_empty (&conn->ksnc_tx_queue) ||
2224                      SOCK_WMEM_QUEUED(conn->ksnc_sock) != 0) &&
2225                     cfs_time_aftereq (cfs_time_current(),
2226                                       conn->ksnc_tx_deadline)) {
2227                         /* Timed out messages queued for sending or
2228                          * buffered in the socket's send buffer */
2229                         atomic_inc (&conn->ksnc_refcount);
2230                         LCONSOLE_ERROR("A timeout occurred sending data to "
2231                                        "%u.%u.%u.%u; the network or that node "
2232                                        "may be down.\n",
2233                                        HIPQUAD(conn->ksnc_ipaddr));
2234                         CERROR ("Timed out TX to "LPX64" %s%d %p %d.%d.%d.%d\n",
2235                                 peer->ksnp_nid,
2236                                 list_empty (&conn->ksnc_tx_queue) ? "" : "Q ",
2237                                 SOCK_WMEM_QUEUED(conn->ksnc_sock), conn,
2238                                 HIPQUAD(conn->ksnc_ipaddr));
2239                         return (conn);
2240                 }
2241         }
2242
2243         return (NULL);
2244 }
2245
2246 void
2247 ksocknal_check_peer_timeouts (int idx)
2248 {
2249         struct list_head *peers = &ksocknal_data.ksnd_peers[idx];
2250         struct list_head *ptmp;
2251         ksock_peer_t     *peer;
2252         ksock_conn_t     *conn;
2253
2254  again:
2255         /* NB. We expect to have a look at all the peers and not find any
2256          * connections to time out, so we just use a shared lock while we
2257          * take a look... */
2258         read_lock (&ksocknal_data.ksnd_global_lock);
2259
2260         list_for_each (ptmp, peers) {
2261                 peer = list_entry (ptmp, ksock_peer_t, ksnp_list);
2262                 conn = ksocknal_find_timed_out_conn (peer);
2263
2264                 if (conn != NULL) {
2265                         read_unlock (&ksocknal_data.ksnd_global_lock);
2266
2267                         CERROR ("Timeout out conn->"LPX64" ip %d.%d.%d.%d:%d\n",
2268                                 peer->ksnp_nid,
2269                                 HIPQUAD(conn->ksnc_ipaddr),
2270                                 conn->ksnc_port);
2271                         ksocknal_close_conn_and_siblings (conn, -ETIMEDOUT);
2272
2273                         /* NB we won't find this one again, but we can't
2274                          * just proceed with the next peer, since we dropped
2275                          * ksnd_global_lock and it might be dead already! */
2276                         ksocknal_put_conn (conn);
2277                         goto again;
2278                 }
2279         }
2280
2281         read_unlock (&ksocknal_data.ksnd_global_lock);
2282 }
2283
2284 int
2285 ksocknal_reaper (void *arg)
2286 {
2287         cfs_waitlink_t     wait;
2288         unsigned long      flags;
2289         ksock_conn_t      *conn;
2290         ksock_sched_t     *sched;
2291         struct list_head   enomem_conns;
2292         int                nenomem_conns;
2293         cfs_duration_t     timeout;
2294         int                i;
2295         int                peer_index = 0;
2296         cfs_time_t         deadline = cfs_time_current();
2297
2298         kportal_daemonize ("ksocknal_reaper");
2299         kportal_blockallsigs ();
2300
2301         CFS_INIT_LIST_HEAD(&enomem_conns);
2302         cfs_waitlink_init (&wait);
2303
2304         spin_lock_irqsave (&ksocknal_data.ksnd_reaper_lock, flags);
2305
2306         while (!ksocknal_data.ksnd_shuttingdown) {
2307
2308                 if (!list_empty (&ksocknal_data.ksnd_deathrow_conns)) {
2309                         conn = list_entry (ksocknal_data.ksnd_deathrow_conns.next,
2310                                            ksock_conn_t, ksnc_list);
2311                         list_del (&conn->ksnc_list);
2312
2313                         spin_unlock_irqrestore (&ksocknal_data.ksnd_reaper_lock, flags);
2314
2315                         ksocknal_terminate_conn (conn);
2316                         ksocknal_put_conn (conn);
2317
2318                         spin_lock_irqsave (&ksocknal_data.ksnd_reaper_lock, flags);
2319                         continue;
2320                 }
2321
2322                 if (!list_empty (&ksocknal_data.ksnd_zombie_conns)) {
2323                         conn = list_entry (ksocknal_data.ksnd_zombie_conns.next,
2324                                            ksock_conn_t, ksnc_list);
2325                         list_del (&conn->ksnc_list);
2326
2327                         spin_unlock_irqrestore (&ksocknal_data.ksnd_reaper_lock, flags);
2328
2329                         ksocknal_destroy_conn (conn);
2330
2331                         spin_lock_irqsave (&ksocknal_data.ksnd_reaper_lock, flags);
2332                         continue;
2333                 }
2334
2335                 if (!list_empty (&ksocknal_data.ksnd_enomem_conns)) {
2336                         list_add(&enomem_conns, &ksocknal_data.ksnd_enomem_conns);
2337                         list_del_init(&ksocknal_data.ksnd_enomem_conns);
2338                 }
2339
2340                 spin_unlock_irqrestore (&ksocknal_data.ksnd_reaper_lock, flags);
2341
2342                 /* reschedule all the connections that stalled with ENOMEM... */
2343                 nenomem_conns = 0;
2344                 while (!list_empty (&enomem_conns)) {
2345                         conn = list_entry (enomem_conns.next,
2346                                            ksock_conn_t, ksnc_tx_list);
2347                         list_del (&conn->ksnc_tx_list);
2348
2349                         sched = conn->ksnc_scheduler;
2350
2351                         spin_lock_irqsave (&sched->kss_lock, flags);
2352
2353                         LASSERT (conn->ksnc_tx_scheduled);
2354                         conn->ksnc_tx_ready = 1;
2355                         list_add_tail (&conn->ksnc_tx_list, &sched->kss_tx_conns);
2356                         cfs_waitq_signal (&sched->kss_waitq);
2357
2358                         spin_unlock_irqrestore (&sched->kss_lock, flags);
2359                         nenomem_conns++;
2360                 }
2361
2362                 /* careful with the jiffy wrap... */
2363                 while ((timeout = cfs_time_sub(deadline,
2364                                                cfs_time_current())) <= 0) {
2365                         const int n = 4;
2366                         const int p = 1;
2367                         int       chunk = ksocknal_data.ksnd_peer_hash_size;
2368
2369                         /* Time to check for timeouts on a few more peers: I do
2370                          * checks every 'p' seconds on a proportion of the peer
2371                          * table and I need to check every connection 'n' times
2372                          * within a timeout interval, to ensure I detect a
2373                          * timeout on any connection within (n+1)/n times the
2374                          * timeout interval. */
2375
2376                         if (ksocknal_tunables.ksnd_io_timeout > n * p)
2377                                 chunk = (chunk * n * p) /
2378                                         ksocknal_tunables.ksnd_io_timeout;
2379                         if (chunk == 0)
2380                                 chunk = 1;
2381
2382                         for (i = 0; i < chunk; i++) {
2383                                 ksocknal_check_peer_timeouts (peer_index);
2384                                 peer_index = (peer_index + 1) %
2385                                              ksocknal_data.ksnd_peer_hash_size;
2386                         }
2387
2388                         deadline = cfs_time_add(deadline, cfs_time_seconds(p));
2389                 }
2390
2391                 if (nenomem_conns != 0) {
2392                         /* Reduce my timeout if I rescheduled ENOMEM conns.
2393                          * This also prevents me getting woken immediately
2394                          * if any go back on my enomem list. */
2395                         timeout = SOCKNAL_ENOMEM_RETRY;
2396                 }
2397                 ksocknal_data.ksnd_reaper_waketime =
2398                         cfs_time_add(cfs_time_current(), timeout);
2399
2400                 set_current_state (TASK_INTERRUPTIBLE);
2401                 cfs_waitq_add (&ksocknal_data.ksnd_reaper_waitq, &wait);
2402
2403                 if (!ksocknal_data.ksnd_shuttingdown &&
2404                     list_empty (&ksocknal_data.ksnd_deathrow_conns) &&
2405                     list_empty (&ksocknal_data.ksnd_zombie_conns))
2406                         cfs_waitq_timedwait (&wait, timeout);
2407
2408                 set_current_state (TASK_RUNNING);
2409                 cfs_waitq_del (&ksocknal_data.ksnd_reaper_waitq, &wait);
2410
2411                 spin_lock_irqsave (&ksocknal_data.ksnd_reaper_lock, flags);
2412         }
2413
2414         spin_unlock_irqrestore (&ksocknal_data.ksnd_reaper_lock, flags);
2415
2416         ksocknal_thread_fini ();
2417         return (0);
2418 }
2419
2420 lib_nal_t ksocknal_lib = {
2421         libnal_data:       &ksocknal_data,      /* NAL private data */
2422         libnal_send:        ksocknal_send,
2423         libnal_send_pages:  ksocknal_send_pages,
2424         libnal_recv:        ksocknal_recv,
2425         libnal_recv_pages:  ksocknal_recv_pages,
2426         libnal_dist:        ksocknal_dist
2427 };