lnet/klnds/socklnd/socklnd.c

   1 /*
   2  * GPL HEADER START
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 only,
   8  * as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License version 2 for more details (a copy is included
  14  * in the LICENSE file that accompanied this code).
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * version 2 along with this program; If not, see
  18  * http://www.gnu.org/licenses/gpl-2.0.html
  19  *
  20  * GPL HEADER END
  21  */
  22 /*
  23  * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
  24  * Use is subject to license terms.
  25  *
  26  * Copyright (c) 2011, 2017, Intel Corporation.
  27  */
  28 /*
  29  * This file is part of Lustre, http://www.lustre.org/
  30  *
  31  * lnet/klnds/socklnd/socklnd.c
  32  *
  33  * Author: Zach Brown <zab@zabbo.net>
  34  * Author: Peter J. Braam <braam@clusterfs.com>
  35  * Author: Phil Schwan <phil@clusterfs.com>
  36  * Author: Eric Barton <eric@bartonsoftware.com>
  37  */
  38
  39 #include <linux/ethtool.h>
  40 #include <linux/inetdevice.h>
  41 #include "socklnd.h"
  42 #include <linux/sunrpc/addr.h>
  43
  44 static const struct lnet_lnd the_ksocklnd;
  45 struct ksock_nal_data ksocknal_data;
  46
  47 static struct ksock_interface *
  48 ksocknal_ip2iface(struct lnet_ni *ni, struct sockaddr *addr)
  49 {
  50         struct ksock_net *net = ni->ni_data;
  51         struct ksock_interface *iface;
  52
  53         iface = &net->ksnn_interface;
  54
  55         if (rpc_cmp_addr((struct sockaddr *)&iface->ksni_addr, addr))
  56                 return iface;
  57
  58         return NULL;
  59 }
  60
  61 static struct ksock_interface *
  62 ksocknal_index2iface(struct lnet_ni *ni, int index)
  63 {
  64         struct ksock_net *net = ni->ni_data;
  65         struct ksock_interface *iface;
  66
  67         iface = &net->ksnn_interface;
  68
  69         if (iface->ksni_index == index)
  70                 return iface;
  71
  72         return NULL;
  73 }
  74
  75 static int ksocknal_ip2index(struct sockaddr *addr, struct lnet_ni *ni)
  76 {
  77         struct net_device *dev;
  78         int ret = -1;
  79         DECLARE_CONST_IN_IFADDR(ifa);
  80
  81         if (addr->sa_family != AF_INET)
  82                 /* No IPv6 support yet */
  83                 return ret;
  84
  85         rcu_read_lock();
  86         for_each_netdev(ni->ni_net_ns, dev) {
  87                 int flags = dev_get_flags(dev);
  88                 struct in_device *in_dev;
  89
  90                 if (flags & IFF_LOOPBACK) /* skip the loopback IF */
  91                         continue;
  92
  93                 if (!(flags & IFF_UP))
  94                         continue;
  95
  96                 in_dev = __in_dev_get_rcu(dev);
  97                 if (!in_dev)
  98                         continue;
  99
 100                 in_dev_for_each_ifa_rcu(ifa, in_dev) {
 101                         if (ifa->ifa_local ==
 102                             ((struct sockaddr_in *)addr)->sin_addr.s_addr)
 103                                 ret = dev->ifindex;
 104                 }
 105                 endfor_ifa(in_dev);
 106                 if (ret >= 0)
 107                         break;
 108         }
 109         rcu_read_unlock();
 110
 111         return ret;
 112 }
 113
 114 static struct ksock_conn_cb *
 115 ksocknal_create_conn_cb(struct sockaddr *addr)
 116 {
 117         struct ksock_conn_cb *conn_cb;
 118
 119         LIBCFS_ALLOC(conn_cb, sizeof(*conn_cb));
 120         if (!conn_cb)
 121                 return NULL;
 122
 123         refcount_set(&conn_cb->ksnr_refcount, 1);
 124         conn_cb->ksnr_peer = NULL;
 125         conn_cb->ksnr_retry_interval = 0;         /* OK to connect at any time */
 126         rpc_copy_addr((struct sockaddr *)&conn_cb->ksnr_addr, addr);
 127         rpc_set_port((struct sockaddr *)&conn_cb->ksnr_addr,
 128                      rpc_get_port(addr));
 129         conn_cb->ksnr_myiface = -1;
 130         conn_cb->ksnr_scheduled = 0;
 131         conn_cb->ksnr_connecting = 0;
 132         conn_cb->ksnr_connected = 0;
 133         conn_cb->ksnr_deleted = 0;
 134         conn_cb->ksnr_conn_count = 0;
 135         conn_cb->ksnr_ctrl_conn_count = 0;
 136         conn_cb->ksnr_blki_conn_count = 0;
 137         conn_cb->ksnr_blko_conn_count = 0;
 138         conn_cb->ksnr_max_conns = 0;
 139
 140         return conn_cb;
 141 }
 142
 143 void
 144 ksocknal_destroy_conn_cb(struct ksock_conn_cb *conn_cb)
 145 {
 146         LASSERT(refcount_read(&conn_cb->ksnr_refcount) == 0);
 147
 148         if (conn_cb->ksnr_peer)
 149                 ksocknal_peer_decref(conn_cb->ksnr_peer);
 150
 151         LIBCFS_FREE(conn_cb, sizeof(*conn_cb));
 152 }
 153
 154 static struct ksock_peer_ni *
 155 ksocknal_create_peer(struct lnet_ni *ni, struct lnet_process_id id)
 156 {
 157         int cpt = lnet_cpt_of_nid(id.nid, ni);
 158         struct ksock_net *net = ni->ni_data;
 159         struct ksock_peer_ni *peer_ni;
 160
 161         LASSERT(id.nid != LNET_NID_ANY);
 162         LASSERT(id.pid != LNET_PID_ANY);
 163         LASSERT(!in_interrupt());
 164
 165         if (!atomic_inc_unless_negative(&net->ksnn_npeers)) {
 166                 CERROR("Can't create peer_ni: network shutdown\n");
 167                 return ERR_PTR(-ESHUTDOWN);
 168         }
 169
 170         LIBCFS_CPT_ALLOC(peer_ni, lnet_cpt_table(), cpt, sizeof(*peer_ni));
 171         if (!peer_ni) {
 172                 atomic_dec(&net->ksnn_npeers);
 173                 return ERR_PTR(-ENOMEM);
 174         }
 175
 176         peer_ni->ksnp_ni = ni;
 177         peer_ni->ksnp_id = id;
 178         refcount_set(&peer_ni->ksnp_refcount, 1); /* 1 ref for caller */
 179         peer_ni->ksnp_closing = 0;
 180         peer_ni->ksnp_accepting = 0;
 181         peer_ni->ksnp_proto = NULL;
 182         peer_ni->ksnp_last_alive = 0;
 183         peer_ni->ksnp_zc_next_cookie = SOCKNAL_KEEPALIVE_PING + 1;
 184         peer_ni->ksnp_conn_cb = NULL;
 185
 186         INIT_LIST_HEAD(&peer_ni->ksnp_conns);
 187         INIT_LIST_HEAD(&peer_ni->ksnp_tx_queue);
 188         INIT_LIST_HEAD(&peer_ni->ksnp_zc_req_list);
 189         spin_lock_init(&peer_ni->ksnp_lock);
 190
 191         return peer_ni;
 192 }
 193
 194 void
 195 ksocknal_destroy_peer(struct ksock_peer_ni *peer_ni)
 196 {
 197         struct ksock_net *net = peer_ni->ksnp_ni->ni_data;
 198
 199         CDEBUG (D_NET, "peer_ni %s %p deleted\n",
 200                 libcfs_id2str(peer_ni->ksnp_id), peer_ni);
 201
 202         LASSERT(refcount_read(&peer_ni->ksnp_refcount) == 0);
 203         LASSERT(peer_ni->ksnp_accepting == 0);
 204         LASSERT(list_empty(&peer_ni->ksnp_conns));
 205         LASSERT(peer_ni->ksnp_conn_cb == NULL);
 206         LASSERT(list_empty(&peer_ni->ksnp_tx_queue));
 207         LASSERT(list_empty(&peer_ni->ksnp_zc_req_list));
 208
 209         LIBCFS_FREE(peer_ni, sizeof(*peer_ni));
 210
 211         /* NB a peer_ni's connections and conn_cb keep a reference on their
 212          * peer_ni until they are destroyed, so we can be assured that _all_
 213          * state to do with this peer_ni has been cleaned up when its refcount
 214          * drops to zero.
 215          */
 216         if (atomic_dec_and_test(&net->ksnn_npeers))
 217                 wake_up_var(&net->ksnn_npeers);
 218 }
 219
 220 struct ksock_peer_ni *
 221 ksocknal_find_peer_locked(struct lnet_ni *ni, struct lnet_process_id id)
 222 {
 223         struct ksock_peer_ni *peer_ni;
 224
 225         hash_for_each_possible(ksocknal_data.ksnd_peers, peer_ni,
 226                                ksnp_list, id.nid) {
 227                 LASSERT(!peer_ni->ksnp_closing);
 228
 229                 if (peer_ni->ksnp_ni != ni)
 230                         continue;
 231
 232                 if (peer_ni->ksnp_id.nid != id.nid ||
 233                     peer_ni->ksnp_id.pid != id.pid)
 234                         continue;
 235
 236                 CDEBUG(D_NET, "got peer_ni [%p] -> %s (%d)\n",
 237                        peer_ni, libcfs_id2str(id),
 238                        refcount_read(&peer_ni->ksnp_refcount));
 239                 return peer_ni;
 240         }
 241         return NULL;
 242 }
 243
 244 struct ksock_peer_ni *
 245 ksocknal_find_peer(struct lnet_ni *ni, struct lnet_process_id id)
 246 {
 247         struct ksock_peer_ni *peer_ni;
 248
 249         read_lock(&ksocknal_data.ksnd_global_lock);
 250         peer_ni = ksocknal_find_peer_locked(ni, id);
 251         if (peer_ni != NULL)                    /* +1 ref for caller? */
 252                 ksocknal_peer_addref(peer_ni);
 253         read_unlock(&ksocknal_data.ksnd_global_lock);
 254
 255         return (peer_ni);
 256 }
 257
 258 static void
 259 ksocknal_unlink_peer_locked(struct ksock_peer_ni *peer_ni)
 260 {
 261         int i;
 262         struct ksock_interface *iface;
 263
 264         for (i = 0; i < peer_ni->ksnp_n_passive_ips; i++) {
 265                 struct sockaddr_in sa = { .sin_family = AF_INET };
 266                 LASSERT(i < LNET_INTERFACES_NUM);
 267                 sa.sin_addr.s_addr = htonl(peer_ni->ksnp_passive_ips[i]);
 268
 269                 iface = ksocknal_ip2iface(peer_ni->ksnp_ni,
 270                                           (struct sockaddr *)&sa);
 271                 /*
 272                  * All IPs in peer_ni->ksnp_passive_ips[] come from the
 273                  * interface list, therefore the call must succeed.
 274                  */
 275                 LASSERT(iface != NULL);
 276
 277                 CDEBUG(D_NET, "peer_ni=%p iface=%p ksni_nroutes=%d\n",
 278                        peer_ni, iface, iface->ksni_nroutes);
 279                 iface->ksni_npeers--;
 280         }
 281
 282         LASSERT(list_empty(&peer_ni->ksnp_conns));
 283         LASSERT(peer_ni->ksnp_conn_cb == NULL);
 284         LASSERT(!peer_ni->ksnp_closing);
 285         peer_ni->ksnp_closing = 1;
 286         hlist_del(&peer_ni->ksnp_list);
 287         /* lose peerlist's ref */
 288         ksocknal_peer_decref(peer_ni);
 289 }
 290
 291 static int
 292 ksocknal_get_peer_info(struct lnet_ni *ni, int index,
 293                        struct lnet_process_id *id, __u32 *myip, __u32 *peer_ip,
 294                        int *port, int *conn_count, int *share_count)
 295 {
 296         struct ksock_peer_ni *peer_ni;
 297         struct ksock_conn_cb *conn_cb;
 298         int i;
 299         int j;
 300         int rc = -ENOENT;
 301
 302         read_lock(&ksocknal_data.ksnd_global_lock);
 303
 304         hash_for_each(ksocknal_data.ksnd_peers, i, peer_ni, ksnp_list) {
 305
 306                 if (peer_ni->ksnp_ni != ni)
 307                         continue;
 308
 309                 if (peer_ni->ksnp_n_passive_ips == 0 &&
 310                     peer_ni->ksnp_conn_cb == NULL) {
 311                         if (index-- > 0)
 312                                 continue;
 313
 314                         *id = peer_ni->ksnp_id;
 315                         *myip = 0;
 316                         *peer_ip = 0;
 317                         *port = 0;
 318                         *conn_count = 0;
 319                         *share_count = 0;
 320                         rc = 0;
 321                         goto out;
 322                 }
 323
 324                 for (j = 0; j < peer_ni->ksnp_n_passive_ips; j++) {
 325                         if (index-- > 0)
 326                                 continue;
 327
 328                         *id = peer_ni->ksnp_id;
 329                         *myip = peer_ni->ksnp_passive_ips[j];
 330                         *peer_ip = 0;
 331                         *port = 0;
 332                         *conn_count = 0;
 333                         *share_count = 0;
 334                         rc = 0;
 335                         goto out;
 336                 }
 337
 338                 if (peer_ni->ksnp_conn_cb) {
 339                         if (index-- > 0)
 340                                 continue;
 341
 342                         conn_cb = peer_ni->ksnp_conn_cb;
 343
 344                         *id = peer_ni->ksnp_id;
 345                         if (conn_cb->ksnr_addr.ss_family == AF_INET) {
 346                                 struct sockaddr_in *sa =
 347                                         (void *)&conn_cb->ksnr_addr;
 348
 349                                 rc = choose_ipv4_src(myip,
 350                                                      conn_cb->ksnr_myiface,
 351                                                      ntohl(sa->sin_addr.s_addr),
 352                                                      ni->ni_net_ns);
 353                                 *peer_ip = ntohl(sa->sin_addr.s_addr);
 354                                 *port = ntohs(sa->sin_port);
 355                         } else {
 356                                 *myip = 0xFFFFFFFF;
 357                                 *peer_ip = 0xFFFFFFFF;
 358                                 *port = 0;
 359                                 rc = -ENOTSUPP;
 360                         }
 361                         *conn_count = conn_cb->ksnr_conn_count;
 362                         *share_count = 1;
 363                         goto out;
 364                 }
 365         }
 366 out:
 367         read_unlock(&ksocknal_data.ksnd_global_lock);
 368         return rc;
 369 }
 370
 371 static unsigned int
 372 ksocknal_get_conn_count_by_type(struct ksock_conn_cb *conn_cb,
 373                                 int type)
 374 {
 375         unsigned int count = 0;
 376
 377         switch (type) {
 378         case SOCKLND_CONN_CONTROL:
 379                 count = conn_cb->ksnr_ctrl_conn_count;
 380                 break;
 381         case SOCKLND_CONN_BULK_IN:
 382                 count = conn_cb->ksnr_blki_conn_count;
 383                 break;
 384         case SOCKLND_CONN_BULK_OUT:
 385                 count = conn_cb->ksnr_blko_conn_count;
 386                 break;
 387         case SOCKLND_CONN_ANY:
 388                 count = conn_cb->ksnr_conn_count;
 389                 break;
 390         default:
 391                 LBUG();
 392                 break;
 393         }
 394
 395         return count;
 396 }
 397
 398 static unsigned int
 399 ksocknal_get_conns_per_peer(struct ksock_peer_ni *peer_ni)
 400 {
 401         struct lnet_ni *ni = peer_ni->ksnp_ni;
 402         struct lnet_ioctl_config_socklnd_tunables *tunables;
 403
 404         LASSERT(ni);
 405
 406         tunables = &ni->ni_lnd_tunables.lnd_tun_u.lnd_sock;
 407
 408         return tunables->lnd_conns_per_peer;
 409 }
 410
 411 static void
 412 ksocknal_incr_conn_count(struct ksock_conn_cb *conn_cb,
 413                          int type)
 414 {
 415         conn_cb->ksnr_conn_count++;
 416
 417         /* check if all connections of the given type got created */
 418         switch (type) {
 419         case SOCKLND_CONN_CONTROL:
 420                 conn_cb->ksnr_ctrl_conn_count++;
 421                 /* there's a single control connection per peer */
 422                 conn_cb->ksnr_connected |= BIT(type);
 423                 break;
 424         case SOCKLND_CONN_BULK_IN:
 425                 conn_cb->ksnr_blki_conn_count++;
 426                 if (conn_cb->ksnr_blki_conn_count >= conn_cb->ksnr_max_conns)
 427                         conn_cb->ksnr_connected |= BIT(type);
 428                 break;
 429         case SOCKLND_CONN_BULK_OUT:
 430                 conn_cb->ksnr_blko_conn_count++;
 431                 if (conn_cb->ksnr_blko_conn_count >= conn_cb->ksnr_max_conns)
 432                         conn_cb->ksnr_connected |= BIT(type);
 433                 break;
 434         case SOCKLND_CONN_ANY:
 435                 if (conn_cb->ksnr_conn_count >= conn_cb->ksnr_max_conns)
 436                         conn_cb->ksnr_connected |= BIT(type);
 437                 break;
 438         default:
 439                 LBUG();
 440                 break;
 441         }
 442
 443         CDEBUG(D_NET, "Add conn type %d, ksnr_connected %x ksnr_max_conns %d\n",
 444                type, conn_cb->ksnr_connected, conn_cb->ksnr_max_conns);
 445 }
 446
 447 static void
 448 ksocknal_associate_cb_conn_locked(struct ksock_conn_cb *conn_cb,
 449                                   struct ksock_conn *conn)
 450 {
 451         struct ksock_peer_ni *peer_ni = conn_cb->ksnr_peer;
 452         int type = conn->ksnc_type;
 453         struct ksock_interface *iface;
 454         int conn_iface;
 455
 456         conn_iface = ksocknal_ip2index((struct sockaddr *)&conn->ksnc_myaddr,
 457                                        peer_ni->ksnp_ni);
 458         conn->ksnc_conn_cb = conn_cb;
 459         ksocknal_conn_cb_addref(conn_cb);
 460
 461         if (conn_cb->ksnr_myiface != conn_iface) {
 462                 if (conn_cb->ksnr_myiface < 0) {
 463                         /* route wasn't bound locally yet (the initial route) */
 464                         CDEBUG(D_NET, "Binding %s %pIS to interface %d\n",
 465                                libcfs_id2str(peer_ni->ksnp_id),
 466                                &conn_cb->ksnr_addr,
 467                                conn_iface);
 468                 } else {
 469                         CDEBUG(D_NET,
 470                                "Rebinding %s %pIS from interface %d to %d\n",
 471                                libcfs_id2str(peer_ni->ksnp_id),
 472                                &conn_cb->ksnr_addr,
 473                                conn_cb->ksnr_myiface,
 474                                conn_iface);
 475
 476                         iface = ksocknal_index2iface(peer_ni->ksnp_ni,
 477                                                      conn_cb->ksnr_myiface);
 478                         if (iface)
 479                                 iface->ksni_nroutes--;
 480                 }
 481                 conn_cb->ksnr_myiface = conn_iface;
 482                 iface = ksocknal_index2iface(peer_ni->ksnp_ni,
 483                                              conn_cb->ksnr_myiface);
 484                 if (iface)
 485                         iface->ksni_nroutes++;
 486         }
 487
 488         ksocknal_incr_conn_count(conn_cb, type);
 489
 490         /* Successful connection => further attempts can
 491          * proceed immediately
 492          */
 493         conn_cb->ksnr_retry_interval = 0;
 494 }
 495
 496 static void
 497 ksocknal_add_conn_cb_locked(struct ksock_peer_ni *peer_ni,
 498                             struct ksock_conn_cb *conn_cb)
 499 {
 500         struct ksock_conn *conn;
 501         struct ksock_net *net = peer_ni->ksnp_ni->ni_data;
 502
 503         LASSERT(!peer_ni->ksnp_closing);
 504         LASSERT(!conn_cb->ksnr_peer);
 505         LASSERT(!conn_cb->ksnr_scheduled);
 506         LASSERT(!conn_cb->ksnr_connecting);
 507         LASSERT(conn_cb->ksnr_connected == 0);
 508
 509         conn_cb->ksnr_peer = peer_ni;
 510         ksocknal_peer_addref(peer_ni);
 511
 512         /* set the conn_cb's interface to the current net's interface */
 513         conn_cb->ksnr_myiface = net->ksnn_interface.ksni_index;
 514         net->ksnn_interface.ksni_nroutes++;
 515
 516         /* peer_ni's route list takes over my ref on 'route' */
 517         peer_ni->ksnp_conn_cb = conn_cb;
 518
 519         list_for_each_entry(conn, &peer_ni->ksnp_conns, ksnc_list) {
 520                 if (!rpc_cmp_addr((struct sockaddr *)&conn->ksnc_peeraddr,
 521                                   (struct sockaddr *)&conn_cb->ksnr_addr))
 522                         continue;
 523
 524                 ksocknal_associate_cb_conn_locked(conn_cb, conn);
 525                 /* keep going (typed conns) */
 526         }
 527 }
 528
 529 static void
 530 ksocknal_del_conn_cb_locked(struct ksock_conn_cb *conn_cb)
 531 {
 532         struct ksock_peer_ni *peer_ni = conn_cb->ksnr_peer;
 533         struct ksock_interface *iface;
 534         struct ksock_conn *conn;
 535         struct ksock_conn *cnxt;
 536
 537         LASSERT(!conn_cb->ksnr_deleted);
 538
 539         /* Close associated conns */
 540         list_for_each_entry_safe(conn, cnxt, &peer_ni->ksnp_conns, ksnc_list) {
 541                 if (conn->ksnc_conn_cb != conn_cb)
 542                         continue;
 543
 544                 ksocknal_close_conn_locked(conn, 0);
 545         }
 546
 547         if (conn_cb->ksnr_myiface >= 0) {
 548                 iface = ksocknal_index2iface(peer_ni->ksnp_ni,
 549                                              conn_cb->ksnr_myiface);
 550                 if (iface)
 551                         iface->ksni_nroutes--;
 552         }
 553
 554         conn_cb->ksnr_deleted = 1;
 555         ksocknal_conn_cb_decref(conn_cb);               /* drop peer_ni's ref */
 556         peer_ni->ksnp_conn_cb = NULL;
 557
 558         if (list_empty(&peer_ni->ksnp_conns)) {
 559                 /* I've just removed the last route to a peer_ni with no active
 560                  * connections
 561                  */
 562                 ksocknal_unlink_peer_locked(peer_ni);
 563         }
 564 }
 565
 566 int
 567 ksocknal_add_peer(struct lnet_ni *ni, struct lnet_process_id id,
 568                   struct sockaddr *addr)
 569 {
 570         struct ksock_peer_ni *peer_ni;
 571         struct ksock_peer_ni *peer2;
 572         struct ksock_conn_cb *conn_cb;
 573
 574         if (id.nid == LNET_NID_ANY ||
 575             id.pid == LNET_PID_ANY)
 576                 return (-EINVAL);
 577
 578         /* Have a brand new peer_ni ready... */
 579         peer_ni = ksocknal_create_peer(ni, id);
 580         if (IS_ERR(peer_ni))
 581                 return PTR_ERR(peer_ni);
 582
 583         conn_cb = ksocknal_create_conn_cb(addr);
 584         if (!conn_cb) {
 585                 ksocknal_peer_decref(peer_ni);
 586                 return -ENOMEM;
 587         }
 588
 589         write_lock_bh(&ksocknal_data.ksnd_global_lock);
 590
 591         /* always called with a ref on ni, so shutdown can't have started */
 592         LASSERT(atomic_read(&((struct ksock_net *)ni->ni_data)->ksnn_npeers)
 593                 >= 0);
 594
 595         peer2 = ksocknal_find_peer_locked(ni, id);
 596         if (peer2 != NULL) {
 597                 ksocknal_peer_decref(peer_ni);
 598                 peer_ni = peer2;
 599         } else {
 600                 /* peer_ni table takes my ref on peer_ni */
 601                 hash_add(ksocknal_data.ksnd_peers, &peer_ni->ksnp_list, id.nid);
 602         }
 603
 604         ksocknal_add_conn_cb_locked(peer_ni, conn_cb);
 605
 606         /* Remember conns_per_peer setting at the time
 607          * of connection initiation. It will define the
 608          * max number of conns per type for this conn_cb
 609          * while it's in use.
 610          */
 611         conn_cb->ksnr_max_conns = ksocknal_get_conns_per_peer(peer_ni);
 612
 613         write_unlock_bh(&ksocknal_data.ksnd_global_lock);
 614
 615         return 0;
 616 }
 617
 618 static void
 619 ksocknal_del_peer_locked(struct ksock_peer_ni *peer_ni, __u32 ip)
 620 {
 621         struct ksock_conn *conn;
 622         struct ksock_conn *cnxt;
 623         struct ksock_conn_cb *conn_cb;
 624
 625         LASSERT(!peer_ni->ksnp_closing);
 626
 627         /* Extra ref prevents peer_ni disappearing until I'm done with it */
 628         ksocknal_peer_addref(peer_ni);
 629         conn_cb = peer_ni->ksnp_conn_cb;
 630         if (conn_cb)
 631                 ksocknal_del_conn_cb_locked(conn_cb);
 632
 633         list_for_each_entry_safe(conn, cnxt, &peer_ni->ksnp_conns,
 634                                  ksnc_list)
 635                 ksocknal_close_conn_locked(conn, 0);
 636
 637         ksocknal_peer_decref(peer_ni);
 638         /* NB peer_ni unlinks itself when last conn/conn_cb is removed */
 639 }
 640
 641 static int
 642 ksocknal_del_peer(struct lnet_ni *ni, struct lnet_process_id id, __u32 ip)
 643 {
 644         LIST_HEAD(zombies);
 645         struct hlist_node *pnxt;
 646         struct ksock_peer_ni *peer_ni;
 647         int lo;
 648         int hi;
 649         int i;
 650         int rc = -ENOENT;
 651
 652         write_lock_bh(&ksocknal_data.ksnd_global_lock);
 653
 654         if (id.nid != LNET_NID_ANY) {
 655                 lo = hash_min(id.nid, HASH_BITS(ksocknal_data.ksnd_peers));
 656                 hi = lo;
 657         } else {
 658                 lo = 0;
 659                 hi = HASH_SIZE(ksocknal_data.ksnd_peers) - 1;
 660         }
 661
 662         for (i = lo; i <= hi; i++) {
 663                 hlist_for_each_entry_safe(peer_ni, pnxt,
 664                                           &ksocknal_data.ksnd_peers[i],
 665                                           ksnp_list) {
 666                         if (peer_ni->ksnp_ni != ni)
 667                                 continue;
 668
 669                         if (!((id.nid == LNET_NID_ANY ||
 670                                peer_ni->ksnp_id.nid == id.nid) &&
 671                               (id.pid == LNET_PID_ANY ||
 672                                peer_ni->ksnp_id.pid == id.pid)))
 673                                 continue;
 674
 675                         ksocknal_peer_addref(peer_ni);  /* a ref for me... */
 676
 677                         ksocknal_del_peer_locked(peer_ni, ip);
 678
 679                         if (peer_ni->ksnp_closing &&
 680                             !list_empty(&peer_ni->ksnp_tx_queue)) {
 681                                 LASSERT(list_empty(&peer_ni->ksnp_conns));
 682                                 LASSERT(peer_ni->ksnp_conn_cb == NULL);
 683
 684                                 list_splice_init(&peer_ni->ksnp_tx_queue,
 685                                                  &zombies);
 686                         }
 687
 688                         ksocknal_peer_decref(peer_ni);  /* ...till here */
 689
 690                         rc = 0;                         /* matched! */
 691                 }
 692         }
 693
 694         write_unlock_bh(&ksocknal_data.ksnd_global_lock);
 695
 696         ksocknal_txlist_done(ni, &zombies, -ENETDOWN);
 697
 698         return rc;
 699 }
 700
 701 static struct ksock_conn *
 702 ksocknal_get_conn_by_idx(struct lnet_ni *ni, int index)
 703 {
 704         struct ksock_peer_ni *peer_ni;
 705         struct ksock_conn *conn;
 706         int i;
 707
 708         read_lock(&ksocknal_data.ksnd_global_lock);
 709
 710         hash_for_each(ksocknal_data.ksnd_peers, i, peer_ni, ksnp_list) {
 711                 LASSERT(!peer_ni->ksnp_closing);
 712
 713                 if (peer_ni->ksnp_ni != ni)
 714                         continue;
 715
 716                 list_for_each_entry(conn, &peer_ni->ksnp_conns,
 717                                     ksnc_list) {
 718                         if (index-- > 0)
 719                                 continue;
 720
 721                         ksocknal_conn_addref(conn);
 722                         read_unlock(&ksocknal_data.ksnd_global_lock);
 723                         return conn;
 724                 }
 725         }
 726
 727         read_unlock(&ksocknal_data.ksnd_global_lock);
 728         return NULL;
 729 }
 730
 731 static struct ksock_sched *
 732 ksocknal_choose_scheduler_locked(unsigned int cpt)
 733 {
 734         struct ksock_sched *sched = ksocknal_data.ksnd_schedulers[cpt];
 735         int i;
 736
 737         if (sched->kss_nthreads == 0) {
 738                 cfs_percpt_for_each(sched, i, ksocknal_data.ksnd_schedulers) {
 739                         if (sched->kss_nthreads > 0) {
 740                                 CDEBUG(D_NET, "scheduler[%d] has no threads. selected scheduler[%d]\n",
 741                                        cpt, sched->kss_cpt);
 742                                 return sched;
 743                         }
 744                 }
 745                 return NULL;
 746         }
 747
 748         return sched;
 749 }
 750
 751 int
 752 ksocknal_accept(struct lnet_ni *ni, struct socket *sock)
 753 {
 754         struct ksock_connreq *cr;
 755         int rc;
 756         struct sockaddr_storage peer;
 757
 758         rc = lnet_sock_getaddr(sock, true, &peer);
 759         if (rc != 0) {
 760                 CERROR("Can't determine new connection's address\n");
 761                 return rc;
 762         }
 763
 764         LIBCFS_ALLOC(cr, sizeof(*cr));
 765         if (cr == NULL) {
 766                 LCONSOLE_ERROR_MSG(0x12f,
 767                                    "Dropping connection request from %pIS: memory exhausted\n",
 768                                    &peer);
 769                 return -ENOMEM;
 770         }
 771
 772         lnet_ni_addref(ni);
 773         cr->ksncr_ni   = ni;
 774         cr->ksncr_sock = sock;
 775
 776         spin_lock_bh(&ksocknal_data.ksnd_connd_lock);
 777
 778         list_add_tail(&cr->ksncr_list, &ksocknal_data.ksnd_connd_connreqs);
 779         wake_up(&ksocknal_data.ksnd_connd_waitq);
 780
 781         spin_unlock_bh(&ksocknal_data.ksnd_connd_lock);
 782         return 0;
 783 }
 784
 785 static int
 786 ksocknal_connecting(struct ksock_conn_cb *conn_cb, struct sockaddr *sa)
 787 {
 788         if (conn_cb &&
 789             rpc_cmp_addr((struct sockaddr *)&conn_cb->ksnr_addr, sa))
 790                 return conn_cb->ksnr_connecting;
 791         return 0;
 792 }
 793
 794 int
 795 ksocknal_create_conn(struct lnet_ni *ni, struct ksock_conn_cb *conn_cb,
 796                      struct socket *sock, int type)
 797 {
 798         rwlock_t *global_lock = &ksocknal_data.ksnd_global_lock;
 799         LIST_HEAD(zombies);
 800         struct lnet_process_id peerid;
 801         u64 incarnation;
 802         struct ksock_conn *conn;
 803         struct ksock_conn *conn2;
 804         struct ksock_peer_ni *peer_ni = NULL;
 805         struct ksock_peer_ni *peer2;
 806         struct ksock_sched *sched;
 807         struct ksock_hello_msg *hello;
 808         int cpt;
 809         struct ksock_tx *tx;
 810         struct ksock_tx *txtmp;
 811         int rc;
 812         int rc2;
 813         int active;
 814         int num_dup = 0;
 815         char *warn = NULL;
 816
 817         active = (conn_cb != NULL);
 818
 819         LASSERT(active == (type != SOCKLND_CONN_NONE));
 820
 821         LIBCFS_ALLOC(conn, sizeof(*conn));
 822         if (conn == NULL) {
 823                 rc = -ENOMEM;
 824                 goto failed_0;
 825         }
 826
 827         conn->ksnc_peer = NULL;
 828         conn->ksnc_conn_cb = NULL;
 829         conn->ksnc_sock = sock;
 830         /* 2 ref, 1 for conn, another extra ref prevents socket
 831          * being closed before establishment of connection */
 832         refcount_set(&conn->ksnc_sock_refcount, 2);
 833         conn->ksnc_type = type;
 834         ksocknal_lib_save_callback(sock, conn);
 835         refcount_set(&conn->ksnc_conn_refcount, 1); /* 1 ref for me */
 836
 837         conn->ksnc_rx_ready = 0;
 838         conn->ksnc_rx_scheduled = 0;
 839
 840         INIT_LIST_HEAD(&conn->ksnc_tx_queue);
 841         conn->ksnc_tx_ready = 0;
 842         conn->ksnc_tx_scheduled = 0;
 843         conn->ksnc_tx_carrier = NULL;
 844         atomic_set (&conn->ksnc_tx_nob, 0);
 845
 846         LIBCFS_ALLOC(hello, offsetof(struct ksock_hello_msg,
 847                                      kshm_ips[LNET_INTERFACES_NUM]));
 848         if (hello == NULL) {
 849                 rc = -ENOMEM;
 850                 goto failed_1;
 851         }
 852
 853         /* stash conn's local and remote addrs */
 854         rc = ksocknal_lib_get_conn_addrs(conn);
 855         if (rc != 0)
 856                 goto failed_1;
 857
 858         /* Find out/confirm peer_ni's NID and connection type and get the
 859          * vector of interfaces she's willing to let me connect to.
 860          * Passive connections use the listener timeout since the peer_ni sends
 861          * eagerly
 862          */
 863
 864         if (active) {
 865                 peer_ni = conn_cb->ksnr_peer;
 866                 LASSERT(ni == peer_ni->ksnp_ni);
 867
 868                 /* Active connection sends HELLO eagerly */
 869                 hello->kshm_nips = 0;
 870                 peerid = peer_ni->ksnp_id;
 871
 872                 write_lock_bh(global_lock);
 873                 conn->ksnc_proto = peer_ni->ksnp_proto;
 874                 write_unlock_bh(global_lock);
 875
 876                 if (conn->ksnc_proto == NULL) {
 877                         conn->ksnc_proto = &ksocknal_protocol_v3x;
 878 #if SOCKNAL_VERSION_DEBUG
 879                         if (*ksocknal_tunables.ksnd_protocol == 2)
 880                                 conn->ksnc_proto = &ksocknal_protocol_v2x;
 881                         else if (*ksocknal_tunables.ksnd_protocol == 1)
 882                                 conn->ksnc_proto = &ksocknal_protocol_v1x;
 883 #endif
 884                 }
 885
 886                 rc = ksocknal_send_hello(ni, conn, peerid.nid, hello);
 887                 if (rc != 0)
 888                         goto failed_1;
 889         } else {
 890                 peerid.nid = LNET_NID_ANY;
 891                 peerid.pid = LNET_PID_ANY;
 892
 893                 /* Passive, get protocol from peer_ni */
 894                 conn->ksnc_proto = NULL;
 895         }
 896
 897         rc = ksocknal_recv_hello(ni, conn, hello, &peerid, &incarnation);
 898         if (rc < 0)
 899                 goto failed_1;
 900
 901         LASSERT(rc == 0 || active);
 902         LASSERT(conn->ksnc_proto != NULL);
 903         LASSERT(peerid.nid != LNET_NID_ANY);
 904
 905         cpt = lnet_cpt_of_nid(peerid.nid, ni);
 906
 907         if (active) {
 908                 ksocknal_peer_addref(peer_ni);
 909                 write_lock_bh(global_lock);
 910         } else {
 911                 peer_ni = ksocknal_create_peer(ni, peerid);
 912                 if (IS_ERR(peer_ni)) {
 913                         rc = PTR_ERR(peer_ni);
 914                         goto failed_1;
 915                 }
 916
 917                 write_lock_bh(global_lock);
 918
 919                 /* called with a ref on ni, so shutdown can't have started */
 920                 LASSERT(atomic_read(&((struct ksock_net *)ni->ni_data)->ksnn_npeers) >= 0);
 921
 922                 peer2 = ksocknal_find_peer_locked(ni, peerid);
 923                 if (peer2 == NULL) {
 924                         /* NB this puts an "empty" peer_ni in the peer_ni
 925                          * table (which takes my ref) */
 926                         hash_add(ksocknal_data.ksnd_peers,
 927                                  &peer_ni->ksnp_list, peerid.nid);
 928                 } else {
 929                         ksocknal_peer_decref(peer_ni);
 930                         peer_ni = peer2;
 931                 }
 932
 933                 /* +1 ref for me */
 934                 ksocknal_peer_addref(peer_ni);
 935                 peer_ni->ksnp_accepting++;
 936
 937                 /* Am I already connecting to this guy?  Resolve in
 938                  * favour of higher NID...
 939                  */
 940                 if (peerid.nid < ni->ni_nid &&
 941                     ksocknal_connecting(peer_ni->ksnp_conn_cb,
 942                                         ((struct sockaddr *) &conn->ksnc_peeraddr))) {
 943                         rc = EALREADY;
 944                         warn = "connection race resolution";
 945                         goto failed_2;
 946                 }
 947         }
 948
 949         if (peer_ni->ksnp_closing ||
 950             (active && conn_cb->ksnr_deleted)) {
 951                 /* peer_ni/conn_cb got closed under me */
 952                 rc = -ESTALE;
 953                 warn = "peer_ni/conn_cb removed";
 954                 goto failed_2;
 955         }
 956
 957         if (peer_ni->ksnp_proto == NULL) {
 958                 /* Never connected before.
 959                  * NB recv_hello may have returned EPROTO to signal my peer_ni
 960                  * wants a different protocol than the one I asked for.
 961                  */
 962                 LASSERT(list_empty(&peer_ni->ksnp_conns));
 963
 964                 peer_ni->ksnp_proto = conn->ksnc_proto;
 965                 peer_ni->ksnp_incarnation = incarnation;
 966         }
 967
 968         if (peer_ni->ksnp_proto != conn->ksnc_proto ||
 969             peer_ni->ksnp_incarnation != incarnation) {
 970                 /* peer_ni rebooted or I've got the wrong protocol version */
 971                 ksocknal_close_peer_conns_locked(peer_ni, NULL, 0);
 972
 973                 peer_ni->ksnp_proto = NULL;
 974                 rc = ESTALE;
 975                 warn = peer_ni->ksnp_incarnation != incarnation ?
 976                         "peer_ni rebooted" :
 977                         "wrong proto version";
 978                 goto failed_2;
 979         }
 980
 981         switch (rc) {
 982         default:
 983                 LBUG();
 984         case 0:
 985                 break;
 986         case EALREADY:
 987                 warn = "lost conn race";
 988                 goto failed_2;
 989         case EPROTO:
 990                 warn = "retry with different protocol version";
 991                 goto failed_2;
 992         }
 993
 994         /* Refuse to duplicate an existing connection, unless this is a
 995          * loopback connection */
 996         if (!rpc_cmp_addr((struct sockaddr *)&conn->ksnc_peeraddr,
 997                           (struct sockaddr *)&conn->ksnc_myaddr)) {
 998                 list_for_each_entry(conn2, &peer_ni->ksnp_conns, ksnc_list) {
 999                         if (!rpc_cmp_addr(
1000                                     (struct sockaddr *)&conn2->ksnc_peeraddr,
1001                                     (struct sockaddr *)&conn->ksnc_peeraddr) ||
1002                             !rpc_cmp_addr(
1003                                     (struct sockaddr *)&conn2->ksnc_myaddr,
1004                                     (struct sockaddr *)&conn->ksnc_myaddr) ||
1005                             conn2->ksnc_type != conn->ksnc_type)
1006                                 continue;
1007
1008                         num_dup++;
1009                         /* If max conns per type is not registered in conn_cb
1010                          * as ksnr_max_conns, use ni's conns_per_peer
1011                          */
1012                         if ((peer_ni->ksnp_conn_cb &&
1013                             num_dup < peer_ni->ksnp_conn_cb->ksnr_max_conns) ||
1014                             (!peer_ni->ksnp_conn_cb &&
1015                             num_dup < ksocknal_get_conns_per_peer(peer_ni)))
1016                                 continue;
1017
1018                         /* Reply on a passive connection attempt so the peer_ni
1019                          * realises we're connected.
1020                          */
1021                         LASSERT(rc == 0);
1022                         if (!active)
1023                                 rc = EALREADY;
1024
1025                         warn = "duplicate";
1026                         goto failed_2;
1027                 }
1028         }
1029         /* If the connection created by this route didn't bind to the IP
1030          * address the route connected to, the connection/route matching
1031          * code below probably isn't going to work.
1032          */
1033         if (active &&
1034             !rpc_cmp_addr((struct sockaddr *)&conn_cb->ksnr_addr,
1035                           (struct sockaddr *)&conn->ksnc_peeraddr)) {
1036                 CERROR("Route %s %pIS connected to %pIS\n",
1037                        libcfs_id2str(peer_ni->ksnp_id),
1038                        &conn_cb->ksnr_addr,
1039                        &conn->ksnc_peeraddr);
1040         }
1041
1042         /* Search for a conn_cb corresponding to the new connection and
1043          * create an association.  This allows incoming connections created
1044          * by conn_cbs in my peer_ni to match my own conn_cb entries so I don't
1045          * continually create duplicate conn_cbs.
1046          */
1047         conn_cb = peer_ni->ksnp_conn_cb;
1048
1049         if (conn_cb && rpc_cmp_addr((struct sockaddr *)&conn->ksnc_peeraddr,
1050                                     (struct sockaddr *)&conn_cb->ksnr_addr))
1051                 ksocknal_associate_cb_conn_locked(conn_cb, conn);
1052
1053         conn->ksnc_peer = peer_ni;                 /* conn takes my ref on peer_ni */
1054         peer_ni->ksnp_last_alive = ktime_get_seconds();
1055         peer_ni->ksnp_send_keepalive = 0;
1056         peer_ni->ksnp_error = 0;
1057
1058         sched = ksocknal_choose_scheduler_locked(cpt);
1059         if (!sched) {
1060                 CERROR("no schedulers available. node is unhealthy\n");
1061                 goto failed_2;
1062         }
1063         /*
1064          * The cpt might have changed if we ended up selecting a non cpt
1065          * native scheduler. So use the scheduler's cpt instead.
1066          */
1067         cpt = sched->kss_cpt;
1068         sched->kss_nconns++;
1069         conn->ksnc_scheduler = sched;
1070
1071         conn->ksnc_tx_last_post = ktime_get_seconds();
1072         /* Set the deadline for the outgoing HELLO to drain */
1073         conn->ksnc_tx_bufnob = sock->sk->sk_wmem_queued;
1074         conn->ksnc_tx_deadline = ktime_get_seconds() +
1075                                  ksocknal_timeout();
1076         smp_mb();   /* order with adding to peer_ni's conn list */
1077
1078         list_add(&conn->ksnc_list, &peer_ni->ksnp_conns);
1079         ksocknal_conn_addref(conn);
1080
1081         ksocknal_new_packet(conn, 0);
1082
1083         conn->ksnc_zc_capable = ksocknal_lib_zc_capable(conn);
1084
1085         /* Take packets blocking for this connection. */
1086         list_for_each_entry_safe(tx, txtmp, &peer_ni->ksnp_tx_queue, tx_list) {
1087                 if (conn->ksnc_proto->pro_match_tx(conn, tx, tx->tx_nonblk) ==
1088                     SOCKNAL_MATCH_NO)
1089                         continue;
1090
1091                 list_del(&tx->tx_list);
1092                 ksocknal_queue_tx_locked(tx, conn);
1093         }
1094
1095         write_unlock_bh(global_lock);
1096
1097         /* We've now got a new connection.  Any errors from here on are just
1098          * like "normal" comms errors and we close the connection normally.
1099          * NB (a) we still have to send the reply HELLO for passive
1100          *        connections,
1101          *    (b) normal I/O on the conn is blocked until I setup and call the
1102          *        socket callbacks.
1103          */
1104
1105         CDEBUG(D_NET, "New conn %s p %d.x %pIS -> %pISp"
1106                " incarnation:%lld sched[%d]\n",
1107                libcfs_id2str(peerid), conn->ksnc_proto->pro_version,
1108                &conn->ksnc_myaddr, &conn->ksnc_peeraddr,
1109                incarnation, cpt);
1110
1111         if (!active) {
1112                 hello->kshm_nips = 0;
1113                 rc = ksocknal_send_hello(ni, conn, peerid.nid, hello);
1114         }
1115
1116         LIBCFS_FREE(hello, offsetof(struct ksock_hello_msg,
1117                                     kshm_ips[LNET_INTERFACES_NUM]));
1118
1119         /* setup the socket AFTER I've received hello (it disables
1120          * SO_LINGER).  I might call back to the acceptor who may want
1121          * to send a protocol version response and then close the
1122          * socket; this ensures the socket only tears down after the
1123          * response has been sent.
1124          */
1125         if (rc == 0)
1126                 rc = ksocknal_lib_setup_sock(sock);
1127
1128         write_lock_bh(global_lock);
1129
1130         /* NB my callbacks block while I hold ksnd_global_lock */
1131         ksocknal_lib_set_callback(sock, conn);
1132
1133         if (!active)
1134                 peer_ni->ksnp_accepting--;
1135
1136         write_unlock_bh(global_lock);
1137
1138         if (rc != 0) {
1139                 write_lock_bh(global_lock);
1140                 if (!conn->ksnc_closing) {
1141                         /* could be closed by another thread */
1142                         ksocknal_close_conn_locked(conn, rc);
1143                 }
1144                 write_unlock_bh(global_lock);
1145         } else if (ksocknal_connsock_addref(conn) == 0) {
1146                 /* Allow I/O to proceed. */
1147                 ksocknal_read_callback(conn);
1148                 ksocknal_write_callback(conn);
1149                 ksocknal_connsock_decref(conn);
1150         }
1151
1152         ksocknal_connsock_decref(conn);
1153         ksocknal_conn_decref(conn);
1154         return rc;
1155
1156 failed_2:
1157
1158         if (!peer_ni->ksnp_closing &&
1159             list_empty(&peer_ni->ksnp_conns) &&
1160             peer_ni->ksnp_conn_cb == NULL) {
1161                 list_splice_init(&peer_ni->ksnp_tx_queue, &zombies);
1162                 ksocknal_unlink_peer_locked(peer_ni);
1163         }
1164
1165         write_unlock_bh(global_lock);
1166
1167         if (warn != NULL) {
1168                 if (rc < 0)
1169                         CERROR("Not creating conn %s type %d: %s\n",
1170                                libcfs_id2str(peerid), conn->ksnc_type, warn);
1171                 else
1172                         CDEBUG(D_NET, "Not creating conn %s type %d: %s\n",
1173                                libcfs_id2str(peerid), conn->ksnc_type, warn);
1174         }
1175
1176         if (!active) {
1177                 if (rc > 0) {
1178                         /* Request retry by replying with CONN_NONE
1179                          * ksnc_proto has been set already
1180                          */
1181                         conn->ksnc_type = SOCKLND_CONN_NONE;
1182                         hello->kshm_nips = 0;
1183                         ksocknal_send_hello(ni, conn, peerid.nid, hello);
1184                 }
1185
1186                 write_lock_bh(global_lock);
1187                 peer_ni->ksnp_accepting--;
1188                 write_unlock_bh(global_lock);
1189         }
1190
1191         /*
1192          * If we get here without an error code, just use -EALREADY.
1193          * Depending on how we got here, the error may be positive
1194          * or negative. Normalize the value for ksocknal_txlist_done().
1195          */
1196         rc2 = (rc == 0 ? -EALREADY : (rc > 0 ? -rc : rc));
1197         ksocknal_txlist_done(ni, &zombies, rc2);
1198         ksocknal_peer_decref(peer_ni);
1199
1200 failed_1:
1201         if (hello != NULL)
1202                 LIBCFS_FREE(hello, offsetof(struct ksock_hello_msg,
1203                                             kshm_ips[LNET_INTERFACES_NUM]));
1204
1205         LIBCFS_FREE(conn, sizeof(*conn));
1206
1207 failed_0:
1208         sock_release(sock);
1209
1210         return rc;
1211 }
1212
1213 void
1214 ksocknal_close_conn_locked(struct ksock_conn *conn, int error)
1215 {
1216         /* This just does the immmediate housekeeping, and queues the
1217          * connection for the reaper to terminate.
1218          * Caller holds ksnd_global_lock exclusively in irq context */
1219         struct ksock_peer_ni *peer_ni = conn->ksnc_peer;
1220         struct ksock_conn_cb *conn_cb;
1221         struct ksock_conn *conn2;
1222
1223         LASSERT(peer_ni->ksnp_error == 0);
1224         LASSERT(!conn->ksnc_closing);
1225         conn->ksnc_closing = 1;
1226
1227         /* ksnd_deathrow_conns takes over peer_ni's ref */
1228         list_del(&conn->ksnc_list);
1229
1230         conn_cb = conn->ksnc_conn_cb;
1231         if (conn_cb != NULL) {
1232                 /* dissociate conn from cb... */
1233                 LASSERT(!conn_cb->ksnr_deleted);
1234
1235                 /* connected bit is set only if all connections
1236                  * of the given type got created
1237                  */
1238                 if (ksocknal_get_conn_count_by_type(conn_cb, conn->ksnc_type) ==
1239                     conn_cb->ksnr_max_conns)
1240                         LASSERT((conn_cb->ksnr_connected &
1241                                 BIT(conn->ksnc_type)) != 0);
1242
1243                 list_for_each_entry(conn2, &peer_ni->ksnp_conns, ksnc_list) {
1244                         if (conn2->ksnc_conn_cb == conn_cb &&
1245                             conn2->ksnc_type == conn->ksnc_type)
1246                                 goto conn2_found;
1247                 }
1248                 conn_cb->ksnr_connected &= ~BIT(conn->ksnc_type);
1249 conn2_found:
1250                 conn->ksnc_conn_cb = NULL;
1251
1252                 /* drop conn's ref on conn_cb */
1253                 ksocknal_conn_cb_decref(conn_cb);
1254         }
1255
1256         if (list_empty(&peer_ni->ksnp_conns)) {
1257                 /* No more connections to this peer_ni */
1258
1259                 if (!list_empty(&peer_ni->ksnp_tx_queue)) {
1260                         struct ksock_tx *tx;
1261
1262                         LASSERT(conn->ksnc_proto == &ksocknal_protocol_v3x);
1263
1264                         /* throw them to the last connection...,
1265                          * these TXs will be send to /dev/null by scheduler */
1266                         list_for_each_entry(tx, &peer_ni->ksnp_tx_queue,
1267                                             tx_list)
1268                                 ksocknal_tx_prep(conn, tx);
1269
1270                         spin_lock_bh(&conn->ksnc_scheduler->kss_lock);
1271                         list_splice_init(&peer_ni->ksnp_tx_queue,
1272                                          &conn->ksnc_tx_queue);
1273                         spin_unlock_bh(&conn->ksnc_scheduler->kss_lock);
1274                 }
1275
1276                 /* renegotiate protocol version */
1277                 peer_ni->ksnp_proto = NULL;
1278                 /* stash last conn close reason */
1279                 peer_ni->ksnp_error = error;
1280
1281                 if (peer_ni->ksnp_conn_cb == NULL) {
1282                         /* I've just closed last conn belonging to a
1283                          * peer_ni with no connections to it
1284                          */
1285                         ksocknal_unlink_peer_locked(peer_ni);
1286                 }
1287         }
1288
1289         spin_lock_bh(&ksocknal_data.ksnd_reaper_lock);
1290
1291         list_add_tail(&conn->ksnc_list, &ksocknal_data.ksnd_deathrow_conns);
1292         wake_up(&ksocknal_data.ksnd_reaper_waitq);
1293
1294         spin_unlock_bh(&ksocknal_data.ksnd_reaper_lock);
1295 }
1296
1297 void
1298 ksocknal_peer_failed(struct ksock_peer_ni *peer_ni)
1299 {
1300         bool notify = false;
1301         time64_t last_alive = 0;
1302
1303         /* There has been a connection failure or comms error; but I'll only
1304          * tell LNET I think the peer_ni is dead if it's to another kernel and
1305          * there are no connections or connection attempts in existence. */
1306
1307         read_lock(&ksocknal_data.ksnd_global_lock);
1308
1309         if ((peer_ni->ksnp_id.pid & LNET_PID_USERFLAG) == 0 &&
1310              list_empty(&peer_ni->ksnp_conns) &&
1311              peer_ni->ksnp_accepting == 0 &&
1312              !ksocknal_find_connecting_conn_cb_locked(peer_ni)) {
1313                 notify = true;
1314                 last_alive = peer_ni->ksnp_last_alive;
1315         }
1316
1317         read_unlock(&ksocknal_data.ksnd_global_lock);
1318
1319         if (notify)
1320                 lnet_notify(peer_ni->ksnp_ni, peer_ni->ksnp_id.nid,
1321                             false, false, last_alive);
1322 }
1323
1324 void
1325 ksocknal_finalize_zcreq(struct ksock_conn *conn)
1326 {
1327         struct ksock_peer_ni *peer_ni = conn->ksnc_peer;
1328         struct ksock_tx *tx;
1329         struct ksock_tx *tmp;
1330         LIST_HEAD(zlist);
1331
1332         /* NB safe to finalize TXs because closing of socket will
1333          * abort all buffered data */
1334         LASSERT(conn->ksnc_sock == NULL);
1335
1336         spin_lock(&peer_ni->ksnp_lock);
1337
1338         list_for_each_entry_safe(tx, tmp, &peer_ni->ksnp_zc_req_list,
1339                                  tx_zc_list) {
1340                 if (tx->tx_conn != conn)
1341                         continue;
1342
1343                 LASSERT(tx->tx_msg.ksm_zc_cookies[0] != 0);
1344
1345                 tx->tx_msg.ksm_zc_cookies[0] = 0;
1346                 tx->tx_zc_aborted = 1;  /* mark it as not-acked */
1347                 list_move(&tx->tx_zc_list, &zlist);
1348         }
1349
1350         spin_unlock(&peer_ni->ksnp_lock);
1351
1352         while ((tx = list_first_entry_or_null(&zlist, struct ksock_tx,
1353                                               tx_zc_list)) != NULL) {
1354                 list_del(&tx->tx_zc_list);
1355                 ksocknal_tx_decref(tx);
1356         }
1357 }
1358
1359 void
1360 ksocknal_terminate_conn(struct ksock_conn *conn)
1361 {
1362         /* This gets called by the reaper (guaranteed thread context) to
1363          * disengage the socket from its callbacks and close it.
1364          * ksnc_refcount will eventually hit zero, and then the reaper will
1365          * destroy it.
1366          */
1367         struct ksock_peer_ni *peer_ni = conn->ksnc_peer;
1368         struct ksock_sched *sched = conn->ksnc_scheduler;
1369         bool failed = false;
1370
1371         LASSERT(conn->ksnc_closing);
1372
1373         /* wake up the scheduler to "send" all remaining packets to /dev/null */
1374         spin_lock_bh(&sched->kss_lock);
1375
1376         /* a closing conn is always ready to tx */
1377         conn->ksnc_tx_ready = 1;
1378
1379         if (!conn->ksnc_tx_scheduled &&
1380             !list_empty(&conn->ksnc_tx_queue)) {
1381                 list_add_tail(&conn->ksnc_tx_list,
1382                               &sched->kss_tx_conns);
1383                 conn->ksnc_tx_scheduled = 1;
1384                 /* extra ref for scheduler */
1385                 ksocknal_conn_addref(conn);
1386
1387                 wake_up(&sched->kss_waitq);
1388         }
1389
1390         spin_unlock_bh(&sched->kss_lock);
1391
1392         /* serialise with callbacks */
1393         write_lock_bh(&ksocknal_data.ksnd_global_lock);
1394
1395         ksocknal_lib_reset_callback(conn->ksnc_sock, conn);
1396
1397         /* OK, so this conn may not be completely disengaged from its
1398          * scheduler yet, but it _has_ committed to terminate...
1399          */
1400         conn->ksnc_scheduler->kss_nconns--;
1401
1402         if (peer_ni->ksnp_error != 0) {
1403                 /* peer_ni's last conn closed in error */
1404                 LASSERT(list_empty(&peer_ni->ksnp_conns));
1405                 failed = true;
1406                 peer_ni->ksnp_error = 0;     /* avoid multiple notifications */
1407         }
1408
1409         write_unlock_bh(&ksocknal_data.ksnd_global_lock);
1410
1411         if (failed)
1412                 ksocknal_peer_failed(peer_ni);
1413
1414         /* The socket is closed on the final put; either here, or in
1415          * ksocknal_{send,recv}msg().  Since we set up the linger2 option
1416          * when the connection was established, this will close the socket
1417          * immediately, aborting anything buffered in it. Any hung
1418          * zero-copy transmits will therefore complete in finite time.
1419          */
1420         ksocknal_connsock_decref(conn);
1421 }
1422
1423 void
1424 ksocknal_queue_zombie_conn(struct ksock_conn *conn)
1425 {
1426         /* Queue the conn for the reaper to destroy */
1427         LASSERT(refcount_read(&conn->ksnc_conn_refcount) == 0);
1428         spin_lock_bh(&ksocknal_data.ksnd_reaper_lock);
1429
1430         list_add_tail(&conn->ksnc_list, &ksocknal_data.ksnd_zombie_conns);
1431         wake_up(&ksocknal_data.ksnd_reaper_waitq);
1432
1433         spin_unlock_bh(&ksocknal_data.ksnd_reaper_lock);
1434 }
1435
1436 void
1437 ksocknal_destroy_conn(struct ksock_conn *conn)
1438 {
1439         time64_t last_rcv;
1440
1441         /* Final coup-de-grace of the reaper */
1442         CDEBUG(D_NET, "connection %p\n", conn);
1443
1444         LASSERT(refcount_read(&conn->ksnc_conn_refcount) == 0);
1445         LASSERT(refcount_read(&conn->ksnc_sock_refcount) == 0);
1446         LASSERT(conn->ksnc_sock == NULL);
1447         LASSERT(conn->ksnc_conn_cb == NULL);
1448         LASSERT(!conn->ksnc_tx_scheduled);
1449         LASSERT(!conn->ksnc_rx_scheduled);
1450         LASSERT(list_empty(&conn->ksnc_tx_queue));
1451
1452         /* complete current receive if any */
1453         switch (conn->ksnc_rx_state) {
1454         case SOCKNAL_RX_LNET_PAYLOAD:
1455                 last_rcv = conn->ksnc_rx_deadline -
1456                            ksocknal_timeout();
1457                 CERROR("Completing partial receive from %s[%d], ip %pISp, with error, wanted: %d, left: %d, last alive is %lld secs ago\n",
1458                        libcfs_id2str(conn->ksnc_peer->ksnp_id), conn->ksnc_type,
1459                        &conn->ksnc_peeraddr,
1460                        conn->ksnc_rx_nob_wanted, conn->ksnc_rx_nob_left,
1461                        ktime_get_seconds() - last_rcv);
1462                 if (conn->ksnc_lnet_msg)
1463                         conn->ksnc_lnet_msg->msg_health_status =
1464                                 LNET_MSG_STATUS_REMOTE_ERROR;
1465                 lnet_finalize(conn->ksnc_lnet_msg, -EIO);
1466                 break;
1467         case SOCKNAL_RX_LNET_HEADER:
1468                 if (conn->ksnc_rx_started)
1469                         CERROR("Incomplete receive of lnet header from %s, ip %pISp, with error, protocol: %d.x.\n",
1470                                libcfs_id2str(conn->ksnc_peer->ksnp_id),
1471                                &conn->ksnc_peeraddr,
1472                                conn->ksnc_proto->pro_version);
1473                 break;
1474         case SOCKNAL_RX_KSM_HEADER:
1475                 if (conn->ksnc_rx_started)
1476                         CERROR("Incomplete receive of ksock message from %s, ip %pISp, with error, protocol: %d.x.\n",
1477                                libcfs_id2str(conn->ksnc_peer->ksnp_id),
1478                                &conn->ksnc_peeraddr,
1479                                conn->ksnc_proto->pro_version);
1480                 break;
1481         case SOCKNAL_RX_SLOP:
1482                 if (conn->ksnc_rx_started)
1483                         CERROR("Incomplete receive of slops from %s, ip %pISp, with error\n",
1484                                libcfs_id2str(conn->ksnc_peer->ksnp_id),
1485                                &conn->ksnc_peeraddr);
1486                break;
1487         default:
1488                 LBUG ();
1489                 break;
1490         }
1491
1492         ksocknal_peer_decref(conn->ksnc_peer);
1493
1494         LIBCFS_FREE (conn, sizeof (*conn));
1495 }
1496
1497 int
1498 ksocknal_close_peer_conns_locked(struct ksock_peer_ni *peer_ni,
1499                                  struct sockaddr *addr, int why)
1500 {
1501         struct ksock_conn *conn;
1502         struct ksock_conn *cnxt;
1503         int count = 0;
1504
1505         list_for_each_entry_safe(conn, cnxt, &peer_ni->ksnp_conns, ksnc_list) {
1506                 if (!addr ||
1507                     rpc_cmp_addr(addr,
1508                                  (struct sockaddr *)&conn->ksnc_peeraddr)) {
1509                         count++;
1510                         ksocknal_close_conn_locked(conn, why);
1511                 }
1512         }
1513
1514         return count;
1515 }
1516
1517 int
1518 ksocknal_close_conn_and_siblings(struct ksock_conn *conn, int why)
1519 {
1520         struct ksock_peer_ni *peer_ni = conn->ksnc_peer;
1521         int count;
1522
1523         write_lock_bh(&ksocknal_data.ksnd_global_lock);
1524
1525         count = ksocknal_close_peer_conns_locked(
1526                 peer_ni, (struct sockaddr *)&conn->ksnc_peeraddr, why);
1527
1528         write_unlock_bh(&ksocknal_data.ksnd_global_lock);
1529
1530         return count;
1531 }
1532
1533 int
1534 ksocknal_close_matching_conns(struct lnet_process_id id, __u32 ipaddr)
1535 {
1536         struct ksock_peer_ni *peer_ni;
1537         struct hlist_node *pnxt;
1538         int lo;
1539         int hi;
1540         int i;
1541         int count = 0;
1542         struct sockaddr_in sa = {.sin_family = AF_INET};
1543
1544         write_lock_bh(&ksocknal_data.ksnd_global_lock);
1545
1546         if (id.nid != LNET_NID_ANY) {
1547                 lo = hash_min(id.nid, HASH_BITS(ksocknal_data.ksnd_peers));
1548                 hi = lo;
1549         } else {
1550                 lo = 0;
1551                 hi = HASH_SIZE(ksocknal_data.ksnd_peers) - 1;
1552         }
1553
1554         sa.sin_addr.s_addr = htonl(ipaddr);
1555         for (i = lo; i <= hi; i++) {
1556                 hlist_for_each_entry_safe(peer_ni, pnxt,
1557                                           &ksocknal_data.ksnd_peers[i],
1558                                           ksnp_list) {
1559
1560                         if (!((id.nid == LNET_NID_ANY ||
1561                                id.nid == peer_ni->ksnp_id.nid) &&
1562                               (id.pid == LNET_PID_ANY ||
1563                                id.pid == peer_ni->ksnp_id.pid)))
1564                                 continue;
1565
1566                         count += ksocknal_close_peer_conns_locked(
1567                                 peer_ni,
1568                                 ipaddr ? (struct sockaddr *)&sa : NULL, 0);
1569                 }
1570         }
1571
1572         write_unlock_bh(&ksocknal_data.ksnd_global_lock);
1573
1574         /* wildcards always succeed */
1575         if (id.nid == LNET_NID_ANY || id.pid == LNET_PID_ANY || ipaddr == 0)
1576                 return 0;
1577
1578         return (count == 0 ? -ENOENT : 0);
1579 }
1580
1581 void
1582 ksocknal_notify_gw_down(lnet_nid_t gw_nid)
1583 {
1584         /* The router is telling me she's been notified of a change in
1585          * gateway state....
1586          */
1587         struct lnet_process_id id = {
1588                 .nid    = gw_nid,
1589                 .pid    = LNET_PID_ANY,
1590         };
1591
1592         CDEBUG(D_NET, "gw %s down\n", libcfs_nid2str(gw_nid));
1593
1594         /* If the gateway crashed, close all open connections... */
1595         ksocknal_close_matching_conns(id, 0);
1596         return;
1597
1598         /* We can only establish new connections
1599          * if we have autroutes, and these connect on demand. */
1600 }
1601
1602 static void
1603 ksocknal_push_peer(struct ksock_peer_ni *peer_ni)
1604 {
1605         int index;
1606         int i;
1607         struct ksock_conn *conn;
1608
1609         for (index = 0; ; index++) {
1610                 read_lock(&ksocknal_data.ksnd_global_lock);
1611
1612                 i = 0;
1613                 conn = NULL;
1614
1615                 list_for_each_entry(conn, &peer_ni->ksnp_conns, ksnc_list) {
1616                         if (i++ == index) {
1617                                 ksocknal_conn_addref(conn);
1618                                 break;
1619                         }
1620                 }
1621
1622                 read_unlock(&ksocknal_data.ksnd_global_lock);
1623
1624                 if (i <= index)
1625                         break;
1626
1627                 ksocknal_lib_push_conn (conn);
1628                 ksocknal_conn_decref(conn);
1629         }
1630 }
1631
1632 static int
1633 ksocknal_push(struct lnet_ni *ni, struct lnet_process_id id)
1634 {
1635         int lo;
1636         int hi;
1637         int bkt;
1638         int rc = -ENOENT;
1639
1640         if (id.nid != LNET_NID_ANY) {
1641                 lo = hash_min(id.nid, HASH_BITS(ksocknal_data.ksnd_peers));
1642                 hi = lo;
1643         } else {
1644                 lo = 0;
1645                 hi = HASH_SIZE(ksocknal_data.ksnd_peers) - 1;
1646         }
1647
1648         for (bkt = lo; bkt <= hi; bkt++) {
1649                 int peer_off; /* searching offset in peer_ni hash table */
1650
1651                 for (peer_off = 0; ; peer_off++) {
1652                         struct ksock_peer_ni *peer_ni;
1653                         int           i = 0;
1654
1655                         read_lock(&ksocknal_data.ksnd_global_lock);
1656                         hlist_for_each_entry(peer_ni,
1657                                              &ksocknal_data.ksnd_peers[bkt],
1658                                              ksnp_list) {
1659                                 if (!((id.nid == LNET_NID_ANY ||
1660                                        id.nid == peer_ni->ksnp_id.nid) &&
1661                                       (id.pid == LNET_PID_ANY ||
1662                                        id.pid == peer_ni->ksnp_id.pid)))
1663                                         continue;
1664
1665                                 if (i++ == peer_off) {
1666                                         ksocknal_peer_addref(peer_ni);
1667                                         break;
1668                                 }
1669                         }
1670                         read_unlock(&ksocknal_data.ksnd_global_lock);
1671
1672                         if (i <= peer_off) /* no match */
1673                                 break;
1674
1675                         rc = 0;
1676                         ksocknal_push_peer(peer_ni);
1677                         ksocknal_peer_decref(peer_ni);
1678                 }
1679         }
1680         return rc;
1681 }
1682
1683 int
1684 ksocknal_ctl(struct lnet_ni *ni, unsigned int cmd, void *arg)
1685 {
1686         struct lnet_process_id id = {0};
1687         struct libcfs_ioctl_data *data = arg;
1688         int rc;
1689
1690         switch(cmd) {
1691         case IOC_LIBCFS_GET_INTERFACE: {
1692                 struct ksock_net *net = ni->ni_data;
1693                 struct ksock_interface *iface;
1694                 struct sockaddr_in *sa;
1695
1696                 read_lock(&ksocknal_data.ksnd_global_lock);
1697
1698                 if (data->ioc_count >= 1) {
1699                         rc = -ENOENT;
1700                 } else {
1701                         rc = 0;
1702                         iface = &net->ksnn_interface;
1703
1704                         sa = (void *)&iface->ksni_addr;
1705                         if (sa->sin_family == AF_INET)
1706                                 data->ioc_u32[0] = ntohl(sa->sin_addr.s_addr);
1707                         else
1708                                 data->ioc_u32[0] = 0xFFFFFFFF;
1709                         data->ioc_u32[1] = iface->ksni_netmask;
1710                         data->ioc_u32[2] = iface->ksni_npeers;
1711                         data->ioc_u32[3] = iface->ksni_nroutes;
1712                 }
1713
1714                 read_unlock(&ksocknal_data.ksnd_global_lock);
1715                 return rc;
1716         }
1717
1718         case IOC_LIBCFS_GET_PEER: {
1719                 __u32            myip = 0;
1720                 __u32            ip = 0;
1721                 int              port = 0;
1722                 int              conn_count = 0;
1723                 int              share_count = 0;
1724
1725                 rc = ksocknal_get_peer_info(ni, data->ioc_count,
1726                                             &id, &myip, &ip, &port,
1727                                             &conn_count,  &share_count);
1728                 if (rc != 0)
1729                         return rc;
1730
1731                 data->ioc_nid    = id.nid;
1732                 data->ioc_count  = share_count;
1733                 data->ioc_u32[0] = ip;
1734                 data->ioc_u32[1] = port;
1735                 data->ioc_u32[2] = myip;
1736                 data->ioc_u32[3] = conn_count;
1737                 data->ioc_u32[4] = id.pid;
1738                 return 0;
1739         }
1740
1741         case IOC_LIBCFS_ADD_PEER: {
1742                 struct sockaddr_in sa = {.sin_family = AF_INET};
1743
1744                 id.nid = data->ioc_nid;
1745                 id.pid = LNET_PID_LUSTRE;
1746                 sa.sin_addr.s_addr = htonl(data->ioc_u32[0]);
1747                 sa.sin_port = htons(data->ioc_u32[1]);
1748                 return ksocknal_add_peer(ni, id, (struct sockaddr *)&sa);
1749         }
1750         case IOC_LIBCFS_DEL_PEER:
1751                 id.nid = data->ioc_nid;
1752                 id.pid = LNET_PID_ANY;
1753                 return ksocknal_del_peer (ni, id,
1754                                           data->ioc_u32[0]); /* IP */
1755
1756         case IOC_LIBCFS_GET_CONN: {
1757                 int           txmem;
1758                 int           rxmem;
1759                 int           nagle;
1760                 struct ksock_conn *conn = ksocknal_get_conn_by_idx(ni, data->ioc_count);
1761                 struct sockaddr_in *psa = (void *)&conn->ksnc_peeraddr;
1762                 struct sockaddr_in *mysa = (void *)&conn->ksnc_myaddr;
1763
1764                 if (conn == NULL)
1765                         return -ENOENT;
1766
1767                 ksocknal_lib_get_conn_tunables(conn, &txmem, &rxmem, &nagle);
1768
1769                 data->ioc_count  = txmem;
1770                 data->ioc_nid    = conn->ksnc_peer->ksnp_id.nid;
1771                 data->ioc_flags  = nagle;
1772                 if (psa->sin_family == AF_INET)
1773                         data->ioc_u32[0] = ntohl(psa->sin_addr.s_addr);
1774                 else
1775                         data->ioc_u32[0] = 0xFFFFFFFF;
1776                 data->ioc_u32[1] = rpc_get_port((struct sockaddr *)
1777                                                 &conn->ksnc_peeraddr);
1778                 if (mysa->sin_family == AF_INET)
1779                         data->ioc_u32[2] = ntohl(mysa->sin_addr.s_addr);
1780                 else
1781                         data->ioc_u32[2] = 0xFFFFFFFF;
1782                 data->ioc_u32[3] = conn->ksnc_type;
1783                 data->ioc_u32[4] = conn->ksnc_scheduler->kss_cpt;
1784                 data->ioc_u32[5] = rxmem;
1785                 data->ioc_u32[6] = conn->ksnc_peer->ksnp_id.pid;
1786                 ksocknal_conn_decref(conn);
1787                 return 0;
1788         }
1789
1790         case IOC_LIBCFS_CLOSE_CONNECTION:
1791                 id.nid = data->ioc_nid;
1792                 id.pid = LNET_PID_ANY;
1793                 return ksocknal_close_matching_conns (id,
1794                                                       data->ioc_u32[0]);
1795
1796         case IOC_LIBCFS_REGISTER_MYNID:
1797                 /* Ignore if this is a noop */
1798                 if (data->ioc_nid == ni->ni_nid)
1799                         return 0;
1800
1801                 CERROR("obsolete IOC_LIBCFS_REGISTER_MYNID: %s(%s)\n",
1802                        libcfs_nid2str(data->ioc_nid),
1803                        libcfs_nid2str(ni->ni_nid));
1804                 return -EINVAL;
1805
1806         case IOC_LIBCFS_PUSH_CONNECTION:
1807                 id.nid = data->ioc_nid;
1808                 id.pid = LNET_PID_ANY;
1809                 return ksocknal_push(ni, id);
1810
1811         default:
1812                 return -EINVAL;
1813         }
1814         /* not reached */
1815 }
1816
1817 static void
1818 ksocknal_free_buffers (void)
1819 {
1820         LASSERT (atomic_read(&ksocknal_data.ksnd_nactive_txs) == 0);
1821
1822         if (ksocknal_data.ksnd_schedulers != NULL)
1823                 cfs_percpt_free(ksocknal_data.ksnd_schedulers);
1824
1825         spin_lock(&ksocknal_data.ksnd_tx_lock);
1826
1827         if (!list_empty(&ksocknal_data.ksnd_idle_noop_txs)) {
1828                 LIST_HEAD(zlist);
1829                 struct ksock_tx *tx;
1830
1831                 list_splice_init(&ksocknal_data.ksnd_idle_noop_txs, &zlist);
1832                 spin_unlock(&ksocknal_data.ksnd_tx_lock);
1833
1834                 while ((tx = list_first_entry_or_null(&zlist, struct ksock_tx,
1835                                                       tx_list)) != NULL) {
1836                         list_del(&tx->tx_list);
1837                         LIBCFS_FREE(tx, tx->tx_desc_size);
1838                 }
1839         } else {
1840                 spin_unlock(&ksocknal_data.ksnd_tx_lock);
1841         }
1842 }
1843
1844 static int ksocknal_get_link_status(struct net_device *dev)
1845 {
1846         int ret = -1;
1847
1848         LASSERT(dev);
1849
1850         if (!netif_running(dev))
1851                 ret = 0;
1852         /* Some devices may not be providing link settings */
1853         else if (dev->ethtool_ops->get_link)
1854                 ret = dev->ethtool_ops->get_link(dev);
1855
1856         return ret;
1857 }
1858
1859 static int
1860 ksocknal_handle_link_state_change(struct net_device *dev,
1861                                   unsigned char operstate)
1862 {
1863         struct lnet_ni *ni;
1864         struct ksock_net *net;
1865         struct ksock_net *cnxt;
1866         int ifindex;
1867         unsigned char link_down = !(operstate == IF_OPER_UP);
1868
1869         ifindex = dev->ifindex;
1870
1871         if (!ksocknal_data.ksnd_nnets)
1872                 goto out;
1873
1874         list_for_each_entry_safe(net, cnxt, &ksocknal_data.ksnd_nets,
1875                                  ksnn_list) {
1876                 if (net->ksnn_interface.ksni_index != ifindex)
1877                         continue;
1878                 ni = net->ksnn_ni;
1879                 if (link_down)
1880                         atomic_set(&ni->ni_fatal_error_on, link_down);
1881                 else
1882                         atomic_set(&ni->ni_fatal_error_on,
1883                                    (ksocknal_get_link_status(dev) == 0));
1884         }
1885 out:
1886         return 0;
1887 }
1888
1889
1890 /************************************
1891  * Net device notifier event handler
1892  ************************************/
1893 static int ksocknal_device_event(struct notifier_block *unused,
1894                                  unsigned long event, void *ptr)
1895 {
1896         struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1897         unsigned char operstate;
1898
1899         operstate = dev->operstate;
1900
1901         switch (event) {
1902         case NETDEV_UP:
1903         case NETDEV_DOWN:
1904         case NETDEV_CHANGE:
1905                 ksocknal_handle_link_state_change(dev, operstate);
1906                 break;
1907         }
1908
1909         return NOTIFY_OK;
1910 }
1911
1912 static struct notifier_block ksocknal_notifier_block = {
1913         .notifier_call = ksocknal_device_event,
1914 };
1915
1916 static void
1917 ksocknal_base_shutdown(void)
1918 {
1919         struct ksock_sched *sched;
1920         struct ksock_peer_ni *peer_ni;
1921         int i;
1922
1923         CDEBUG(D_MALLOC, "before NAL cleanup: kmem %lld\n",
1924                libcfs_kmem_read());
1925         LASSERT (ksocknal_data.ksnd_nnets == 0);
1926
1927         if (ksocknal_data.ksnd_init == SOCKNAL_INIT_ALL)
1928                 unregister_netdevice_notifier(&ksocknal_notifier_block);
1929
1930         switch (ksocknal_data.ksnd_init) {
1931         default:
1932                 LASSERT(0);
1933                 /* fallthrough */
1934
1935         case SOCKNAL_INIT_ALL:
1936         case SOCKNAL_INIT_DATA:
1937                 hash_for_each(ksocknal_data.ksnd_peers, i, peer_ni, ksnp_list)
1938                         LASSERT(0);
1939
1940                 LASSERT(list_empty(&ksocknal_data.ksnd_nets));
1941                 LASSERT(list_empty(&ksocknal_data.ksnd_enomem_conns));
1942                 LASSERT(list_empty(&ksocknal_data.ksnd_zombie_conns));
1943                 LASSERT(list_empty(&ksocknal_data.ksnd_connd_connreqs));
1944                 LASSERT(list_empty(&ksocknal_data.ksnd_connd_routes));
1945
1946                 if (ksocknal_data.ksnd_schedulers != NULL) {
1947                         cfs_percpt_for_each(sched, i,
1948                                             ksocknal_data.ksnd_schedulers) {
1949
1950                                 LASSERT(list_empty(&sched->kss_tx_conns));
1951                                 LASSERT(list_empty(&sched->kss_rx_conns));
1952                                 LASSERT(list_empty(&sched->kss_zombie_noop_txs));
1953                                 LASSERT(sched->kss_nconns == 0);
1954                         }
1955                 }
1956
1957                 /* flag threads to terminate; wake and wait for them to die */
1958                 ksocknal_data.ksnd_shuttingdown = 1;
1959                 wake_up_all(&ksocknal_data.ksnd_connd_waitq);
1960                 wake_up(&ksocknal_data.ksnd_reaper_waitq);
1961
1962                 if (ksocknal_data.ksnd_schedulers != NULL) {
1963                         cfs_percpt_for_each(sched, i,
1964                                             ksocknal_data.ksnd_schedulers)
1965                                         wake_up_all(&sched->kss_waitq);
1966                 }
1967
1968                 wait_var_event_warning(&ksocknal_data.ksnd_nthreads,
1969                                        atomic_read(&ksocknal_data.ksnd_nthreads) == 0,
1970                                        "waiting for %d threads to terminate\n",
1971                                        atomic_read(&ksocknal_data.ksnd_nthreads));
1972
1973                 ksocknal_free_buffers();
1974
1975                 ksocknal_data.ksnd_init = SOCKNAL_INIT_NOTHING;
1976                 break;
1977         }
1978
1979         CDEBUG(D_MALLOC, "after NAL cleanup: kmem %lld\n",
1980                libcfs_kmem_read());
1981
1982         module_put(THIS_MODULE);
1983 }
1984
1985 static int
1986 ksocknal_base_startup(void)
1987 {
1988         struct ksock_sched *sched;
1989         int rc;
1990         int i;
1991
1992         LASSERT(ksocknal_data.ksnd_init == SOCKNAL_INIT_NOTHING);
1993         LASSERT(ksocknal_data.ksnd_nnets == 0);
1994
1995         memset(&ksocknal_data, 0, sizeof(ksocknal_data)); /* zero pointers */
1996
1997         hash_init(ksocknal_data.ksnd_peers);
1998
1999         rwlock_init(&ksocknal_data.ksnd_global_lock);
2000         INIT_LIST_HEAD(&ksocknal_data.ksnd_nets);
2001
2002         spin_lock_init(&ksocknal_data.ksnd_reaper_lock);
2003         INIT_LIST_HEAD(&ksocknal_data.ksnd_enomem_conns);
2004         INIT_LIST_HEAD(&ksocknal_data.ksnd_zombie_conns);
2005         INIT_LIST_HEAD(&ksocknal_data.ksnd_deathrow_conns);
2006         init_waitqueue_head(&ksocknal_data.ksnd_reaper_waitq);
2007
2008         spin_lock_init(&ksocknal_data.ksnd_connd_lock);
2009         INIT_LIST_HEAD(&ksocknal_data.ksnd_connd_connreqs);
2010         INIT_LIST_HEAD(&ksocknal_data.ksnd_connd_routes);
2011         init_waitqueue_head(&ksocknal_data.ksnd_connd_waitq);
2012
2013         spin_lock_init(&ksocknal_data.ksnd_tx_lock);
2014         INIT_LIST_HEAD(&ksocknal_data.ksnd_idle_noop_txs);
2015
2016         /* NB memset above zeros whole of ksocknal_data */
2017
2018         /* flag lists/ptrs/locks initialised */
2019         ksocknal_data.ksnd_init = SOCKNAL_INIT_DATA;
2020         if (!try_module_get(THIS_MODULE))
2021                 goto failed;
2022
2023         /* Create a scheduler block per available CPT */
2024         ksocknal_data.ksnd_schedulers = cfs_percpt_alloc(lnet_cpt_table(),
2025                                                          sizeof(*sched));
2026         if (ksocknal_data.ksnd_schedulers == NULL)
2027                 goto failed;
2028
2029         cfs_percpt_for_each(sched, i, ksocknal_data.ksnd_schedulers) {
2030                 int nthrs;
2031
2032                 /*
2033                  * make sure not to allocate more threads than there are
2034                  * cores/CPUs in teh CPT
2035                  */
2036                 nthrs = cfs_cpt_weight(lnet_cpt_table(), i);
2037                 if (*ksocknal_tunables.ksnd_nscheds > 0) {
2038                         nthrs = min(nthrs, *ksocknal_tunables.ksnd_nscheds);
2039                 } else {
2040                         /*
2041                          * max to half of CPUs, assume another half should be
2042                          * reserved for upper layer modules
2043                          */
2044                         nthrs = min(max(SOCKNAL_NSCHEDS, nthrs >> 1), nthrs);
2045                 }
2046
2047                 sched->kss_nthreads_max = nthrs;
2048                 sched->kss_cpt = i;
2049
2050                 spin_lock_init(&sched->kss_lock);
2051                 INIT_LIST_HEAD(&sched->kss_rx_conns);
2052                 INIT_LIST_HEAD(&sched->kss_tx_conns);
2053                 INIT_LIST_HEAD(&sched->kss_zombie_noop_txs);
2054                 init_waitqueue_head(&sched->kss_waitq);
2055         }
2056
2057         ksocknal_data.ksnd_connd_starting         = 0;
2058         ksocknal_data.ksnd_connd_failed_stamp     = 0;
2059         ksocknal_data.ksnd_connd_starting_stamp   = ktime_get_real_seconds();
2060         /* must have at least 2 connds to remain responsive to accepts while
2061          * connecting */
2062         if (*ksocknal_tunables.ksnd_nconnds < SOCKNAL_CONND_RESV + 1)
2063                 *ksocknal_tunables.ksnd_nconnds = SOCKNAL_CONND_RESV + 1;
2064
2065         if (*ksocknal_tunables.ksnd_nconnds_max <
2066             *ksocknal_tunables.ksnd_nconnds) {
2067                 ksocknal_tunables.ksnd_nconnds_max =
2068                         ksocknal_tunables.ksnd_nconnds;
2069         }
2070
2071         for (i = 0; i < *ksocknal_tunables.ksnd_nconnds; i++) {
2072                 spin_lock_bh(&ksocknal_data.ksnd_connd_lock);
2073                 ksocknal_data.ksnd_connd_starting++;
2074                 spin_unlock_bh(&ksocknal_data.ksnd_connd_lock);
2075
2076                 rc = ksocknal_thread_start(ksocknal_connd,
2077                                            (void *)((uintptr_t)i),
2078                                            "socknal_cd%02d", i);
2079                 if (rc != 0) {
2080                         spin_lock_bh(&ksocknal_data.ksnd_connd_lock);
2081                         ksocknal_data.ksnd_connd_starting--;
2082                         spin_unlock_bh(&ksocknal_data.ksnd_connd_lock);
2083                         CERROR("Can't spawn socknal connd: %d\n", rc);
2084                         goto failed;
2085                 }
2086         }
2087
2088         rc = ksocknal_thread_start(ksocknal_reaper, NULL, "socknal_reaper");
2089         if (rc != 0) {
2090                 CERROR ("Can't spawn socknal reaper: %d\n", rc);
2091                 goto failed;
2092         }
2093
2094         register_netdevice_notifier(&ksocknal_notifier_block);
2095
2096         /* flag everything initialised */
2097         ksocknal_data.ksnd_init = SOCKNAL_INIT_ALL;
2098
2099         return 0;
2100
2101  failed:
2102         ksocknal_base_shutdown();
2103         return -ENETDOWN;
2104 }
2105
2106 static int
2107 ksocknal_debug_peerhash(struct lnet_ni *ni)
2108 {
2109         struct ksock_peer_ni *peer_ni;
2110         int i;
2111
2112         read_lock(&ksocknal_data.ksnd_global_lock);
2113
2114         hash_for_each(ksocknal_data.ksnd_peers, i, peer_ni, ksnp_list) {
2115                 struct ksock_conn_cb *conn_cb;
2116                 struct ksock_conn *conn;
2117
2118                 if (peer_ni->ksnp_ni != ni)
2119                         continue;
2120
2121                 CWARN("Active peer_ni on shutdown: %s, ref %d, "
2122                       "closing %d, accepting %d, err %d, zcookie %llu, "
2123                       "txq %d, zc_req %d\n", libcfs_id2str(peer_ni->ksnp_id),
2124                       refcount_read(&peer_ni->ksnp_refcount),
2125                       peer_ni->ksnp_closing,
2126                       peer_ni->ksnp_accepting, peer_ni->ksnp_error,
2127                       peer_ni->ksnp_zc_next_cookie,
2128                       !list_empty(&peer_ni->ksnp_tx_queue),
2129                       !list_empty(&peer_ni->ksnp_zc_req_list));
2130
2131                 conn_cb = peer_ni->ksnp_conn_cb;
2132                 if (conn_cb) {
2133                         CWARN("ConnCB: ref %d, schd %d, conn %d, cnted %d, del %d\n",
2134                               refcount_read(&conn_cb->ksnr_refcount),
2135                               conn_cb->ksnr_scheduled, conn_cb->ksnr_connecting,
2136                               conn_cb->ksnr_connected, conn_cb->ksnr_deleted);
2137                 }
2138
2139                 list_for_each_entry(conn, &peer_ni->ksnp_conns, ksnc_list) {
2140                         CWARN("Conn: ref %d, sref %d, t %d, c %d\n",
2141                               refcount_read(&conn->ksnc_conn_refcount),
2142                               refcount_read(&conn->ksnc_sock_refcount),
2143                               conn->ksnc_type, conn->ksnc_closing);
2144                 }
2145                 break;
2146         }
2147
2148         read_unlock(&ksocknal_data.ksnd_global_lock);
2149         return 0;
2150 }
2151
2152 void
2153 ksocknal_shutdown(struct lnet_ni *ni)
2154 {
2155         struct ksock_net *net = ni->ni_data;
2156         struct lnet_process_id anyid = {
2157                 .nid = LNET_NID_ANY,
2158                 .pid = LNET_PID_ANY,
2159         };
2160
2161         LASSERT(ksocknal_data.ksnd_init == SOCKNAL_INIT_ALL);
2162         LASSERT(ksocknal_data.ksnd_nnets > 0);
2163
2164         /* prevent new peers */
2165         atomic_add(SOCKNAL_SHUTDOWN_BIAS, &net->ksnn_npeers);
2166
2167         /* Delete all peers */
2168         ksocknal_del_peer(ni, anyid, 0);
2169
2170         /* Wait for all peer_ni state to clean up */
2171         wait_var_event_warning(&net->ksnn_npeers,
2172                                atomic_read(&net->ksnn_npeers) ==
2173                                SOCKNAL_SHUTDOWN_BIAS,
2174                                "waiting for %d peers to disconnect\n",
2175                                ksocknal_debug_peerhash(ni) +
2176                                atomic_read(&net->ksnn_npeers) -
2177                                SOCKNAL_SHUTDOWN_BIAS);
2178
2179         LASSERT(net->ksnn_interface.ksni_npeers == 0);
2180         LASSERT(net->ksnn_interface.ksni_nroutes == 0);
2181
2182         list_del(&net->ksnn_list);
2183         LIBCFS_FREE(net, sizeof(*net));
2184
2185         ksocknal_data.ksnd_nnets--;
2186         if (ksocknal_data.ksnd_nnets == 0)
2187                 ksocknal_base_shutdown();
2188 }
2189
2190 static int
2191 ksocknal_search_new_ipif(struct ksock_net *net)
2192 {
2193         int new_ipif = 0;
2194         char *ifnam = &net->ksnn_interface.ksni_name[0];
2195         char *colon = strchr(ifnam, ':');
2196         bool found = false;
2197         struct ksock_net *tmp;
2198
2199         if (colon != NULL)
2200                 *colon = 0;
2201
2202         list_for_each_entry(tmp, &ksocknal_data.ksnd_nets, ksnn_list) {
2203                 char *ifnam2 = &tmp->ksnn_interface.ksni_name[0];
2204                 char *colon2 = strchr(ifnam2, ':');
2205
2206                 if (colon2 != NULL)
2207                         *colon2 = 0;
2208
2209                 found = strcmp(ifnam, ifnam2) == 0;
2210                 if (colon2 != NULL)
2211                         *colon2 = ':';
2212         }
2213
2214         new_ipif += !found;
2215         if (colon != NULL)
2216                 *colon = ':';
2217
2218         return new_ipif;
2219 }
2220
2221 static int
2222 ksocknal_start_schedulers(struct ksock_sched *sched)
2223 {
2224         int     nthrs;
2225         int     rc = 0;
2226         int     i;
2227
2228         if (sched->kss_nthreads == 0) {
2229                 if (*ksocknal_tunables.ksnd_nscheds > 0) {
2230                         nthrs = sched->kss_nthreads_max;
2231                 } else {
2232                         nthrs = cfs_cpt_weight(lnet_cpt_table(),
2233                                                sched->kss_cpt);
2234                         nthrs = min(max(SOCKNAL_NSCHEDS, nthrs >> 1), nthrs);
2235                         nthrs = min(SOCKNAL_NSCHEDS_HIGH, nthrs);
2236                 }
2237                 nthrs = min(nthrs, sched->kss_nthreads_max);
2238         } else {
2239                 LASSERT(sched->kss_nthreads <= sched->kss_nthreads_max);
2240                 /* increase two threads if there is new interface */
2241                 nthrs = min(2, sched->kss_nthreads_max - sched->kss_nthreads);
2242         }
2243
2244         for (i = 0; i < nthrs; i++) {
2245                 long id;
2246
2247                 id = KSOCK_THREAD_ID(sched->kss_cpt, sched->kss_nthreads + i);
2248                 rc = ksocknal_thread_start(ksocknal_scheduler, (void *)id,
2249                                            "socknal_sd%02d_%02d",
2250                                            sched->kss_cpt,
2251                                            (int)KSOCK_THREAD_SID(id));
2252                 if (rc == 0)
2253                         continue;
2254
2255                 CERROR("Can't spawn thread %d for scheduler[%d]: %d\n",
2256                        sched->kss_cpt, (int) KSOCK_THREAD_SID(id), rc);
2257                 break;
2258         }
2259
2260         sched->kss_nthreads += i;
2261         return rc;
2262 }
2263
2264 static int
2265 ksocknal_net_start_threads(struct ksock_net *net, __u32 *cpts, int ncpts)
2266 {
2267         int newif = ksocknal_search_new_ipif(net);
2268         int rc;
2269         int i;
2270
2271         if (ncpts > 0 && ncpts > cfs_cpt_number(lnet_cpt_table()))
2272                 return -EINVAL;
2273
2274         for (i = 0; i < ncpts; i++) {
2275                 struct ksock_sched *sched;
2276                 int cpt = (cpts == NULL) ? i : cpts[i];
2277
2278                 LASSERT(cpt < cfs_cpt_number(lnet_cpt_table()));
2279                 sched = ksocknal_data.ksnd_schedulers[cpt];
2280
2281                 if (!newif && sched->kss_nthreads > 0)
2282                         continue;
2283
2284                 rc = ksocknal_start_schedulers(sched);
2285                 if (rc != 0)
2286                         return rc;
2287         }
2288         return 0;
2289 }
2290
2291 int
2292 ksocknal_startup(struct lnet_ni *ni)
2293 {
2294         struct ksock_net *net;
2295         struct ksock_interface *ksi = NULL;
2296         struct lnet_inetdev *ifaces = NULL;
2297         struct sockaddr_in *sa;
2298         int i = 0;
2299         int rc;
2300
2301         LASSERT (ni->ni_net->net_lnd == &the_ksocklnd);
2302         if (ksocknal_data.ksnd_init == SOCKNAL_INIT_NOTHING) {
2303                 rc = ksocknal_base_startup();
2304                 if (rc != 0)
2305                         return rc;
2306         }
2307         LIBCFS_ALLOC(net, sizeof(*net));
2308         if (net == NULL)
2309                 goto fail_0;
2310         net->ksnn_incarnation = ktime_get_real_ns();
2311         ni->ni_data = net;
2312
2313         ksocknal_tunables_setup(ni);
2314
2315         rc = lnet_inet_enumerate(&ifaces, ni->ni_net_ns);
2316         if (rc < 0)
2317                 goto fail_1;
2318
2319         ksi = &net->ksnn_interface;
2320
2321         /* Use the first discovered interface or look in the list */
2322         if (ni->ni_interface) {
2323                 for (i = 0; i < rc; i++)
2324                         if (strcmp(ifaces[i].li_name, ni->ni_interface) == 0)
2325                                 break;
2326
2327                 /* ni_interfaces doesn't contain the interface we want */
2328                 if (i == rc) {
2329                         CERROR("ksocklnd: failed to find interface %s\n",
2330                                ni->ni_interface);
2331                         goto fail_1;
2332                 }
2333         }
2334
2335         ni->ni_dev_cpt = ifaces[i].li_cpt;
2336         sa = (void *)&ksi->ksni_addr;
2337         memset(sa, 0, sizeof(*sa));
2338         sa->sin_family = AF_INET;
2339         sa->sin_addr.s_addr = htonl(ifaces[i].li_ipaddr);
2340         ksi->ksni_index = ksocknal_ip2index((struct sockaddr *)sa, ni);
2341         ksi->ksni_netmask = ifaces[i].li_netmask;
2342         strlcpy(ksi->ksni_name, ifaces[i].li_name, sizeof(ksi->ksni_name));
2343
2344         /* call it before add it to ksocknal_data.ksnd_nets */
2345         rc = ksocknal_net_start_threads(net, ni->ni_cpts, ni->ni_ncpts);
2346         if (rc != 0)
2347                 goto fail_1;
2348
2349         LASSERT(ksi);
2350         LASSERT(ksi->ksni_addr.ss_family == AF_INET);
2351         ni->ni_nid = LNET_MKNID(
2352                 LNET_NIDNET(ni->ni_nid),
2353                 ntohl(((struct sockaddr_in *)
2354                        &ksi->ksni_addr)->sin_addr.s_addr));
2355         list_add(&net->ksnn_list, &ksocknal_data.ksnd_nets);
2356         net->ksnn_ni = ni;
2357         ksocknal_data.ksnd_nnets++;
2358
2359         return 0;
2360
2361 fail_1:
2362         LIBCFS_FREE(net, sizeof(*net));
2363 fail_0:
2364         if (ksocknal_data.ksnd_nnets == 0)
2365                 ksocknal_base_shutdown();
2366
2367         return -ENETDOWN;
2368 }
2369
2370
2371 static void __exit ksocklnd_exit(void)
2372 {
2373         lnet_unregister_lnd(&the_ksocklnd);
2374 }
2375
2376 static const struct lnet_lnd the_ksocklnd = {
2377         .lnd_type               = SOCKLND,
2378         .lnd_startup            = ksocknal_startup,
2379         .lnd_shutdown           = ksocknal_shutdown,
2380         .lnd_ctl                = ksocknal_ctl,
2381         .lnd_send               = ksocknal_send,
2382         .lnd_recv               = ksocknal_recv,
2383         .lnd_notify_peer_down   = ksocknal_notify_gw_down,
2384         .lnd_accept             = ksocknal_accept,
2385 };
2386
2387 static int __init ksocklnd_init(void)
2388 {
2389         int rc;
2390
2391         /* check ksnr_connected/connecting field large enough */
2392         BUILD_BUG_ON(SOCKLND_CONN_NTYPES > 4);
2393         BUILD_BUG_ON(SOCKLND_CONN_ACK != SOCKLND_CONN_BULK_IN);
2394
2395         rc = ksocknal_tunables_init();
2396         if (rc != 0)
2397                 return rc;
2398
2399         lnet_register_lnd(&the_ksocklnd);
2400
2401         return 0;
2402 }
2403
2404 MODULE_AUTHOR("OpenSFS, Inc. <http://www.lustre.org/>");
2405 MODULE_DESCRIPTION("TCP Socket LNet Network Driver");
2406 MODULE_VERSION("2.8.0");
2407 MODULE_LICENSE("GPL");
2408
2409 module_init(ksocklnd_init);
2410 module_exit(ksocklnd_exit);