lnet/klnds/socklnd/socklnd_cb.c

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