lnet/klnds/socklnd/socklnd_lib-linux.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  */
   4
   5 #include "socklnd.h"
   6
   7 # if CONFIG_SYSCTL && !CFS_SYSFS_MODULE_PARM
   8 static ctl_table ksocknal_ctl_table[21];
   9
  10 ctl_table ksocknal_top_ctl_table[] = {
  11         {200, "socknal", NULL, 0, 0555, ksocknal_ctl_table},
  12         { 0 }
  13 };
  14
  15 int
  16 ksocknal_lib_tunables_init ()
  17 {
  18         int    i = 0;
  19         int    j = 1;
  20
  21         ksocknal_ctl_table[i++] = (ctl_table)
  22                 {j++, "timeout", ksocknal_tunables.ksnd_timeout,
  23                  sizeof (int), 0644, NULL, &proc_dointvec};
  24         ksocknal_ctl_table[i++] = (ctl_table)
  25                 {j++, "credits", ksocknal_tunables.ksnd_credits,
  26                  sizeof (int), 0444, NULL, &proc_dointvec};
  27         ksocknal_ctl_table[i++] = (ctl_table)
  28                 {j++, "peer_credits", ksocknal_tunables.ksnd_peercredits,
  29                  sizeof (int), 0444, NULL, &proc_dointvec};
  30         ksocknal_ctl_table[i++] = (ctl_table)
  31                 {j++, "nconnds", ksocknal_tunables.ksnd_nconnds,
  32                  sizeof (int), 0444, NULL, &proc_dointvec};
  33         ksocknal_ctl_table[i++] = (ctl_table)
  34                 {j++, "min_reconnectms", ksocknal_tunables.ksnd_min_reconnectms,
  35                  sizeof (int), 0444, NULL, &proc_dointvec};
  36         ksocknal_ctl_table[i++] = (ctl_table)
  37                 {j++, "max_reconnectms", ksocknal_tunables.ksnd_max_reconnectms,
  38                  sizeof (int), 0444, NULL, &proc_dointvec};
  39         ksocknal_ctl_table[i++] = (ctl_table)
  40                 {j++, "eager_ack", ksocknal_tunables.ksnd_eager_ack,
  41                  sizeof (int), 0644, NULL, &proc_dointvec};
  42         ksocknal_ctl_table[i++] = (ctl_table)
  43                 {j++, "zero_copy", ksocknal_tunables.ksnd_zc_min_frag,
  44                  sizeof (int), 0644, NULL, &proc_dointvec};
  45         ksocknal_ctl_table[i++] = (ctl_table)
  46                 {j++, "typed", ksocknal_tunables.ksnd_typed_conns,
  47                  sizeof (int), 0444, NULL, &proc_dointvec};
  48         ksocknal_ctl_table[i++] = (ctl_table)
  49                 {j++, "min_bulk", ksocknal_tunables.ksnd_min_bulk,
  50                  sizeof (int), 0644, NULL, &proc_dointvec};
  51         ksocknal_ctl_table[i++] = (ctl_table)
  52                 {j++, "rx_buffer_size", ksocknal_tunables.ksnd_rx_buffer_size,
  53                  sizeof(int), 0644, NULL, &proc_dointvec};
  54         ksocknal_ctl_table[i++] = (ctl_table)
  55                 {j++, "tx_buffer_size", ksocknal_tunables.ksnd_tx_buffer_size,
  56                  sizeof(int), 0644, NULL, &proc_dointvec};
  57         ksocknal_ctl_table[i++] = (ctl_table)
  58                 {j++, "nagle", ksocknal_tunables.ksnd_nagle,
  59                  sizeof(int), 0644, NULL, &proc_dointvec};
  60 #if CPU_AFFINITY
  61         ksocknal_ctl_table[i++] = (ctl_table)
  62                 {j++, "irq_affinity", ksocknal_tunables.ksnd_irq_affinity,
  63                  sizeof(int), 0644, NULL, &proc_dointvec};
  64 #endif
  65         ksocknal_ctl_table[i++] = (ctl_table)
  66                 {j++, "keepalive_idle", ksocknal_tunables.ksnd_keepalive_idle,
  67                  sizeof(int), 0644, NULL, &proc_dointvec};
  68         ksocknal_ctl_table[i++] = (ctl_table)
  69                 {j++, "keepalive_count", ksocknal_tunables.ksnd_keepalive_count,
  70                  sizeof(int), 0644, NULL, &proc_dointvec};
  71         ksocknal_ctl_table[i++] = (ctl_table)
  72                 {j++, "keepalive_intvl", ksocknal_tunables.ksnd_keepalive_intvl,
  73                  sizeof(int), 0644, NULL, &proc_dointvec};
  74 #ifdef SOCKNAL_BACKOFF
  75         ksocknal_ctl_table[i++] = (ctl_table)
  76                 {j++, "backoff_init", ksocknal_tunables.ksnd_backoff_init,
  77                  sizeof(int), 0644, NULL, &proc_dointvec};
  78         ksocknal_ctl_table[i++] = (ctl_table)
  79                 {j++, "backoff_max", ksocknal_tunables.ksnd_backoff_max,
  80                  sizeof(int), 0644, NULL, &proc_dointvec};
  81 #endif
  82
  83         LASSERT (j == i+1);
  84         LASSERT (i < sizeof(ksocknal_ctl_table)/sizeof(ksocknal_ctl_table[0]));
  85
  86         ksocknal_tunables.ksnd_sysctl =
  87                 cfs_register_sysctl_table(ksocknal_top_ctl_table, 0);
  88
  89         if (ksocknal_tunables.ksnd_sysctl == NULL)
  90                 CWARN("Can't setup /proc tunables\n");
  91
  92         return 0;
  93 }
  94
  95 void
  96 ksocknal_lib_tunables_fini ()
  97 {
  98         if (ksocknal_tunables.ksnd_sysctl != NULL)
  99                 cfs_unregister_sysctl_table(ksocknal_tunables.ksnd_sysctl);
 100 }
 101 #else
 102 int
 103 ksocknal_lib_tunables_init ()
 104 {
 105         return 0;
 106 }
 107
 108 void
 109 ksocknal_lib_tunables_fini ()
 110 {
 111 }
 112 #endif /* # if CONFIG_SYSCTL && !CFS_SYSFS_MODULE_PARM */
 113
 114 void
 115 ksocknal_lib_bind_irq (unsigned int irq)
 116 {
 117 #if (defined(CONFIG_SMP) && CPU_AFFINITY)
 118         int              bind;
 119         int              cpu;
 120         char             cmdline[64];
 121         ksock_irqinfo_t *info;
 122         char            *argv[] = {"/bin/sh",
 123                                    "-c",
 124                                    cmdline,
 125                                    NULL};
 126         char            *envp[] = {"HOME=/",
 127                                    "PATH=/sbin:/bin:/usr/sbin:/usr/bin",
 128                                    NULL};
 129
 130         LASSERT (irq < NR_IRQS);
 131         if (irq == 0)              /* software NIC or affinity disabled */
 132                 return;
 133
 134         info = &ksocknal_data.ksnd_irqinfo[irq];
 135
 136         write_lock_bh (&ksocknal_data.ksnd_global_lock);
 137
 138         LASSERT (info->ksni_valid);
 139         bind = !info->ksni_bound;
 140         info->ksni_bound = 1;
 141
 142         write_unlock_bh (&ksocknal_data.ksnd_global_lock);
 143
 144         if (!bind)                              /* bound already */
 145                 return;
 146
 147         cpu = ksocknal_irqsched2cpu(info->ksni_sched);
 148         snprintf (cmdline, sizeof (cmdline),
 149                   "echo %d > /proc/irq/%u/smp_affinity", 1 << cpu, irq);
 150
 151         LCONSOLE_INFO("Binding irq %u to CPU %d with cmd: %s\n",
 152                       irq, cpu, cmdline);
 153
 154         /* FIXME: Find a better method of setting IRQ affinity...
 155          */
 156
 157         USERMODEHELPER(argv[0], argv, envp);
 158 #endif
 159 }
 160
 161 int
 162 ksocknal_lib_get_conn_addrs (ksock_conn_t *conn)
 163 {
 164         int rc = libcfs_sock_getaddr(conn->ksnc_sock, 1,
 165                                      &conn->ksnc_ipaddr,
 166                                      &conn->ksnc_port);
 167
 168         /* Didn't need the {get,put}connsock dance to deref ksnc_sock... */
 169         LASSERT (!conn->ksnc_closing);
 170
 171         if (rc != 0) {
 172                 CERROR ("Error %d getting sock peer IP\n", rc);
 173                 return rc;
 174         }
 175
 176         rc = libcfs_sock_getaddr(conn->ksnc_sock, 0,
 177                                  &conn->ksnc_myipaddr, NULL);
 178         if (rc != 0) {
 179                 CERROR ("Error %d getting sock local IP\n", rc);
 180                 return rc;
 181         }
 182
 183         return 0;
 184 }
 185
 186 unsigned int
 187 ksocknal_lib_sock_irq (struct socket *sock)
 188 {
 189         int                irq = 0;
 190 #if CPU_AFFINITY
 191         struct dst_entry  *dst;
 192
 193         if (!*ksocknal_tunables.ksnd_irq_affinity)
 194                 return 0;
 195
 196         dst = sk_dst_get (sock->sk);
 197         if (dst != NULL) {
 198                 if (dst->dev != NULL) {
 199                         irq = dst->dev->irq;
 200                         if (irq >= NR_IRQS) {
 201                                 CERROR ("Unexpected IRQ %x\n", irq);
 202                                 irq = 0;
 203                         }
 204                 }
 205                 dst_release (dst);
 206         }
 207
 208 #endif
 209         return irq;
 210 }
 211
 212 int
 213 ksocknal_lib_zc_capable(struct socket *sock)
 214 {
 215         int  caps = sock->sk->sk_route_caps;
 216
 217         /* ZC if the socket supports scatter/gather and doesn't need software
 218          * checksums */
 219         return ((caps & NETIF_F_SG) != 0 &&
 220                 (caps & (NETIF_F_IP_CSUM | NETIF_F_NO_CSUM | NETIF_F_HW_CSUM)) != 0);
 221 }
 222
 223 int
 224 ksocknal_lib_send_iov (ksock_conn_t *conn, ksock_tx_t *tx)
 225 {
 226         struct socket *sock = conn->ksnc_sock;
 227         int            nob;
 228         int            rc;
 229
 230         if (*ksocknal_tunables.ksnd_enable_csum        && /* checksum enabled */
 231             conn->ksnc_proto == &ksocknal_protocol_v2x && /* V2.x connection  */
 232             tx->tx_nob == tx->tx_resid                 && /* frist sending    */
 233             tx->tx_msg.ksm_csum == 0)                     /* not checksummed  */
 234                 ksocknal_lib_csum_tx(tx);
 235
 236         /* NB we can't trust socket ops to either consume our iovs
 237          * or leave them alone. */
 238
 239         {
 240 #if SOCKNAL_SINGLE_FRAG_TX
 241                 struct iovec    scratch;
 242                 struct iovec   *scratchiov = &scratch;
 243                 unsigned int    niov = 1;
 244 #else
 245                 struct iovec   *scratchiov = conn->ksnc_tx_scratch_iov;
 246                 unsigned int    niov = tx->tx_niov;
 247 #endif
 248                 struct msghdr msg = {
 249                         .msg_name       = NULL,
 250                         .msg_namelen    = 0,
 251                         .msg_iov        = scratchiov,
 252                         .msg_iovlen     = niov,
 253                         .msg_control    = NULL,
 254                         .msg_controllen = 0,
 255                         .msg_flags      = MSG_DONTWAIT
 256                 };
 257                 mm_segment_t oldmm = get_fs();
 258                 int  i;
 259
 260                 for (nob = i = 0; i < niov; i++) {
 261                         scratchiov[i] = tx->tx_iov[i];
 262                         nob += scratchiov[i].iov_len;
 263                 }
 264
 265                 if (!list_empty(&conn->ksnc_tx_queue) ||
 266                     nob < tx->tx_resid)
 267                         msg.msg_flags |= MSG_MORE;
 268
 269                 set_fs (KERNEL_DS);
 270                 rc = sock_sendmsg(sock, &msg, nob);
 271                 set_fs (oldmm);
 272         }
 273         return rc;
 274 }
 275
 276 int
 277 ksocknal_lib_send_kiov (ksock_conn_t *conn, ksock_tx_t *tx)
 278 {
 279         struct socket *sock = conn->ksnc_sock;
 280         lnet_kiov_t    *kiov = tx->tx_kiov;
 281         int            rc;
 282         int            nob;
 283
 284         /* NB we can't trust socket ops to either consume our iovs
 285          * or leave them alone. */
 286
 287         if (kiov->kiov_len >= *ksocknal_tunables.ksnd_zc_min_frag &&
 288             tx->tx_msg.ksm_zc_req_cookie != 0) {
 289                 /* Zero copy is enabled */
 290                 struct page   *page = kiov->kiov_page;
 291                 int            offset = kiov->kiov_offset;
 292                 int            fragsize = kiov->kiov_len;
 293                 int            msgflg = MSG_DONTWAIT;
 294
 295                 CDEBUG(D_NET, "page %p + offset %x for %d\n",
 296                                page, offset, kiov->kiov_len);
 297
 298                 if (!list_empty(&conn->ksnc_tx_queue) ||
 299                     fragsize < tx->tx_resid)
 300                         msgflg |= MSG_MORE;
 301
 302                 rc = tcp_sendpage(sock, page, offset, fragsize, msgflg);
 303         } else {
 304 #if SOCKNAL_SINGLE_FRAG_TX || !SOCKNAL_RISK_KMAP_DEADLOCK
 305                 struct iovec  scratch;
 306                 struct iovec *scratchiov = &scratch;
 307                 unsigned int  niov = 1;
 308 #else
 309 #ifdef CONFIG_HIGHMEM
 310 #warning "XXX risk of kmap deadlock on multiple frags..."
 311 #endif
 312                 struct iovec *scratchiov = conn->ksnc_tx_scratch_iov;
 313                 unsigned int  niov = tx->tx_nkiov;
 314 #endif
 315                 struct msghdr msg = {
 316                         .msg_name       = NULL,
 317                         .msg_namelen    = 0,
 318                         .msg_iov        = scratchiov,
 319                         .msg_iovlen     = niov,
 320                         .msg_control    = NULL,
 321                         .msg_controllen = 0,
 322                         .msg_flags      = MSG_DONTWAIT
 323                 };
 324                 mm_segment_t  oldmm = get_fs();
 325                 int           i;
 326
 327                 for (nob = i = 0; i < niov; i++) {
 328                         scratchiov[i].iov_base = kmap(kiov[i].kiov_page) +
 329                                                  kiov[i].kiov_offset;
 330                         nob += scratchiov[i].iov_len = kiov[i].kiov_len;
 331                 }
 332
 333                 if (!list_empty(&conn->ksnc_tx_queue) ||
 334                     nob < tx->tx_resid)
 335                         msg.msg_flags |= MSG_MORE;
 336
 337                 set_fs (KERNEL_DS);
 338                 rc = sock_sendmsg(sock, &msg, nob);
 339                 set_fs (oldmm);
 340
 341                 for (i = 0; i < niov; i++)
 342                         kunmap(kiov[i].kiov_page);
 343         }
 344         return rc;
 345 }
 346
 347 void
 348 ksocknal_lib_eager_ack (ksock_conn_t *conn)
 349 {
 350         int            opt = 1;
 351         mm_segment_t   oldmm = get_fs();
 352         struct socket *sock = conn->ksnc_sock;
 353
 354         /* Remind the socket to ACK eagerly.  If I don't, the socket might
 355          * think I'm about to send something it could piggy-back the ACK
 356          * on, introducing delay in completing zero-copy sends in my
 357          * peer. */
 358
 359         set_fs(KERNEL_DS);
 360         sock->ops->setsockopt (sock, SOL_TCP, TCP_QUICKACK,
 361                                (char *)&opt, sizeof (opt));
 362         set_fs(oldmm);
 363 }
 364
 365 int
 366 ksocknal_lib_recv_iov (ksock_conn_t *conn)
 367 {
 368 #if SOCKNAL_SINGLE_FRAG_RX
 369         struct iovec  scratch;
 370         struct iovec *scratchiov = &scratch;
 371         unsigned int  niov = 1;
 372 #else
 373         struct iovec *scratchiov = conn->ksnc_rx_scratch_iov;
 374         unsigned int  niov = conn->ksnc_rx_niov;
 375 #endif
 376         struct iovec *iov = conn->ksnc_rx_iov;
 377         struct msghdr msg = {
 378                 .msg_name       = NULL,
 379                 .msg_namelen    = 0,
 380                 .msg_iov        = scratchiov,
 381                 .msg_iovlen     = niov,
 382                 .msg_control    = NULL,
 383                 .msg_controllen = 0,
 384                 .msg_flags      = 0
 385         };
 386         mm_segment_t oldmm = get_fs();
 387         int          nob;
 388         int          i;
 389         int          rc;
 390         int          fragnob;
 391         int          sum;
 392         __u32        saved_csum;
 393
 394         /* NB we can't trust socket ops to either consume our iovs
 395          * or leave them alone. */
 396         LASSERT (niov > 0);
 397
 398         for (nob = i = 0; i < niov; i++) {
 399                 scratchiov[i] = iov[i];
 400                 nob += scratchiov[i].iov_len;
 401         }
 402         LASSERT (nob <= conn->ksnc_rx_nob_wanted);
 403
 404         set_fs (KERNEL_DS);
 405         rc = sock_recvmsg (conn->ksnc_sock, &msg, nob, MSG_DONTWAIT);
 406         /* NB this is just a boolean..........................^ */
 407         set_fs (oldmm);
 408
 409         saved_csum = 0;
 410         if (conn->ksnc_proto == &ksocknal_protocol_v2x) {
 411                 saved_csum = conn->ksnc_msg.ksm_csum;
 412                 conn->ksnc_msg.ksm_csum = 0;
 413         }
 414
 415         if (saved_csum != 0) {
 416                 /* accumulate checksum */
 417                 for (i = 0, sum = rc; sum > 0; i++, sum -= fragnob) {
 418                         LASSERT (i < niov);
 419
 420                         fragnob = iov[i].iov_len;
 421                         if (fragnob > sum)
 422                                 fragnob = sum;
 423
 424                         conn->ksnc_rx_csum = ksocknal_csum(conn->ksnc_rx_csum,
 425                                                            iov[i].iov_base, fragnob);
 426                 }
 427                 conn->ksnc_msg.ksm_csum = saved_csum;
 428         }
 429
 430         return rc;
 431 }
 432
 433 int
 434 ksocknal_lib_recv_kiov (ksock_conn_t *conn)
 435 {
 436 #if SOCKNAL_SINGLE_FRAG_RX || !SOCKNAL_RISK_KMAP_DEADLOCK
 437         struct iovec  scratch;
 438         struct iovec *scratchiov = &scratch;
 439         unsigned int  niov = 1;
 440 #else
 441 #ifdef CONFIG_HIGHMEM
 442 #warning "XXX risk of kmap deadlock on multiple frags..."
 443 #endif
 444         struct iovec *scratchiov = conn->ksnc_rx_scratch_iov;
 445         unsigned int  niov = conn->ksnc_rx_nkiov;
 446 #endif
 447         lnet_kiov_t   *kiov = conn->ksnc_rx_kiov;
 448         struct msghdr msg = {
 449                 .msg_name       = NULL,
 450                 .msg_namelen    = 0,
 451                 .msg_iov        = scratchiov,
 452                 .msg_iovlen     = niov,
 453                 .msg_control    = NULL,
 454                 .msg_controllen = 0,
 455                 .msg_flags      = 0
 456         };
 457         mm_segment_t oldmm = get_fs();
 458         int          nob;
 459         int          i;
 460         int          rc;
 461         void        *base;
 462         int          sum;
 463         int          fragnob;
 464
 465         /* NB we can't trust socket ops to either consume our iovs
 466          * or leave them alone. */
 467         for (nob = i = 0; i < niov; i++) {
 468                 scratchiov[i].iov_base = kmap(kiov[i].kiov_page) + kiov[i].kiov_offset;
 469                 nob += scratchiov[i].iov_len = kiov[i].kiov_len;
 470         }
 471         LASSERT (nob <= conn->ksnc_rx_nob_wanted);
 472
 473         set_fs (KERNEL_DS);
 474         rc = sock_recvmsg (conn->ksnc_sock, &msg, nob, MSG_DONTWAIT);
 475         /* NB this is just a boolean.......................^ */
 476         set_fs (oldmm);
 477
 478         if (conn->ksnc_msg.ksm_csum != 0) {
 479                 for (i = 0, sum = rc; sum > 0; i++, sum -= fragnob) {
 480                         LASSERT (i < niov);
 481
 482                         /* Dang! have to kmap again because I have nowhere to stash the
 483                          * mapped address.  But by doing it while the page is still
 484                          * mapped, the kernel just bumps the map count and returns me
 485                          * the address it stashed. */
 486                         base = kmap(kiov[i].kiov_page) + kiov[i].kiov_offset;
 487                         fragnob = kiov[i].kiov_len;
 488                         if (fragnob > sum)
 489                                 fragnob = sum;
 490
 491                         conn->ksnc_rx_csum = ksocknal_csum(conn->ksnc_rx_csum,
 492                                                            base, fragnob);
 493
 494                         kunmap(kiov[i].kiov_page);
 495                 }
 496         }
 497         for (i = 0; i < niov; i++)
 498                 kunmap(kiov[i].kiov_page);
 499
 500         return (rc);
 501 }
 502
 503 void ksocknal_lib_csum_tx(ksock_tx_t *tx)
 504 {
 505         int          i;
 506         __u32        csum;
 507         void        *base;
 508
 509         LASSERT(tx->tx_iov[0].iov_base == (void *)&tx->tx_msg);
 510         LASSERT(tx->tx_conn != NULL);
 511         LASSERT(tx->tx_conn->ksnc_proto == &ksocknal_protocol_v2x);
 512
 513         tx->tx_msg.ksm_csum = 0;
 514
 515         csum = ksocknal_csum(~0, (void *)tx->tx_iov[0].iov_base,
 516                              tx->tx_iov[0].iov_len);
 517
 518         if (tx->tx_kiov != NULL) {
 519                 for (i = 0; i < tx->tx_nkiov; i++) {
 520                         base = kmap(tx->tx_kiov[i].kiov_page) +
 521                                tx->tx_kiov[i].kiov_offset;
 522
 523                         csum = ksocknal_csum(csum, base, tx->tx_kiov[i].kiov_len);
 524
 525                         kunmap(tx->tx_kiov[i].kiov_page);
 526                 }
 527         } else {
 528                 for (i = 1; i < tx->tx_niov; i++)
 529                         csum = ksocknal_csum(csum, tx->tx_iov[i].iov_base,
 530                                              tx->tx_iov[i].iov_len);
 531         }
 532
 533         if (*ksocknal_tunables.ksnd_inject_csum_error) {
 534                 csum++;
 535                 *ksocknal_tunables.ksnd_inject_csum_error = 0;
 536         }
 537
 538         tx->tx_msg.ksm_csum = csum;
 539 }
 540
 541 int
 542 ksocknal_lib_get_conn_tunables (ksock_conn_t *conn, int *txmem, int *rxmem, int *nagle)
 543 {
 544         mm_segment_t   oldmm = get_fs ();
 545         struct socket *sock = conn->ksnc_sock;
 546         int            len;
 547         int            rc;
 548
 549         rc = ksocknal_connsock_addref(conn);
 550         if (rc != 0) {
 551                 LASSERT (conn->ksnc_closing);
 552                 *txmem = *rxmem = *nagle = 0;
 553                 return (-ESHUTDOWN);
 554         }
 555
 556         rc = libcfs_sock_getbuf(sock, txmem, rxmem);
 557         if (rc == 0) {
 558                 len = sizeof(*nagle);
 559                 set_fs(KERNEL_DS);
 560                 rc = sock->ops->getsockopt(sock, SOL_TCP, TCP_NODELAY,
 561                                            (char *)nagle, &len);
 562                 set_fs(oldmm);
 563         }
 564
 565         ksocknal_connsock_decref(conn);
 566
 567         if (rc == 0)
 568                 *nagle = !*nagle;
 569         else
 570                 *txmem = *rxmem = *nagle = 0;
 571
 572         return (rc);
 573 }
 574
 575 int
 576 ksocknal_lib_setup_sock (struct socket *sock)
 577 {
 578         mm_segment_t    oldmm = get_fs ();
 579         int             rc;
 580         int             option;
 581         int             keep_idle;
 582         int             keep_intvl;
 583         int             keep_count;
 584         int             do_keepalive;
 585         struct linger   linger;
 586
 587         sock->sk->sk_allocation = GFP_NOFS;
 588
 589         /* Ensure this socket aborts active sends immediately when we close
 590          * it. */
 591
 592         linger.l_onoff = 0;
 593         linger.l_linger = 0;
 594
 595         set_fs (KERNEL_DS);
 596         rc = sock_setsockopt (sock, SOL_SOCKET, SO_LINGER,
 597                               (char *)&linger, sizeof (linger));
 598         set_fs (oldmm);
 599         if (rc != 0) {
 600                 CERROR ("Can't set SO_LINGER: %d\n", rc);
 601                 return (rc);
 602         }
 603
 604         option = -1;
 605         set_fs (KERNEL_DS);
 606         rc = sock->ops->setsockopt (sock, SOL_TCP, TCP_LINGER2,
 607                                     (char *)&option, sizeof (option));
 608         set_fs (oldmm);
 609         if (rc != 0) {
 610                 CERROR ("Can't set SO_LINGER2: %d\n", rc);
 611                 return (rc);
 612         }
 613
 614         if (!*ksocknal_tunables.ksnd_nagle) {
 615                 option = 1;
 616
 617                 set_fs (KERNEL_DS);
 618                 rc = sock->ops->setsockopt (sock, SOL_TCP, TCP_NODELAY,
 619                                             (char *)&option, sizeof (option));
 620                 set_fs (oldmm);
 621                 if (rc != 0) {
 622                         CERROR ("Can't disable nagle: %d\n", rc);
 623                         return (rc);
 624                 }
 625         }
 626
 627         rc = libcfs_sock_setbuf(sock,
 628                                 *ksocknal_tunables.ksnd_tx_buffer_size,
 629                                 *ksocknal_tunables.ksnd_rx_buffer_size);
 630         if (rc != 0) {
 631                 CERROR ("Can't set buffer tx %d, rx %d buffers: %d\n",
 632                         *ksocknal_tunables.ksnd_tx_buffer_size,
 633                         *ksocknal_tunables.ksnd_rx_buffer_size, rc);
 634                 return (rc);
 635         }
 636
 637 /* TCP_BACKOFF_* sockopt tunables unsupported in stock kernels */
 638 #ifdef SOCKNAL_BACKOFF
 639         if (*ksocknal_tunables.ksnd_backoff_init > 0) {
 640                 option = *ksocknal_tunables.ksnd_backoff_init;
 641
 642                 set_fs (KERNEL_DS);
 643                 rc = sock->ops->setsockopt (sock, SOL_TCP, TCP_BACKOFF_INIT,
 644                                             (char *)&option, sizeof (option));
 645                 set_fs (oldmm);
 646                 if (rc != 0) {
 647                         CERROR ("Can't set initial tcp backoff %d: %d\n",
 648                                 option, rc);
 649                         return (rc);
 650                 }
 651         }
 652
 653         if (*ksocknal_tunables.ksnd_backoff_max > 0) {
 654                 option = *ksocknal_tunables.ksnd_backoff_max;
 655
 656                 set_fs (KERNEL_DS);
 657                 rc = sock->ops->setsockopt (sock, SOL_TCP, TCP_BACKOFF_MAX,
 658                                             (char *)&option, sizeof (option));
 659                 set_fs (oldmm);
 660                 if (rc != 0) {
 661                         CERROR ("Can't set maximum tcp backoff %d: %d\n",
 662                                 option, rc);
 663                         return (rc);
 664                 }
 665         }
 666 #endif
 667
 668         /* snapshot tunables */
 669         keep_idle  = *ksocknal_tunables.ksnd_keepalive_idle;
 670         keep_count = *ksocknal_tunables.ksnd_keepalive_count;
 671         keep_intvl = *ksocknal_tunables.ksnd_keepalive_intvl;
 672
 673         do_keepalive = (keep_idle > 0 && keep_count > 0 && keep_intvl > 0);
 674
 675         option = (do_keepalive ? 1 : 0);
 676         set_fs (KERNEL_DS);
 677         rc = sock_setsockopt (sock, SOL_SOCKET, SO_KEEPALIVE,
 678                               (char *)&option, sizeof (option));
 679         set_fs (oldmm);
 680         if (rc != 0) {
 681                 CERROR ("Can't set SO_KEEPALIVE: %d\n", rc);
 682                 return (rc);
 683         }
 684
 685         if (!do_keepalive)
 686                 return (0);
 687
 688         set_fs (KERNEL_DS);
 689         rc = sock->ops->setsockopt (sock, SOL_TCP, TCP_KEEPIDLE,
 690                                     (char *)&keep_idle, sizeof (keep_idle));
 691         set_fs (oldmm);
 692         if (rc != 0) {
 693                 CERROR ("Can't set TCP_KEEPIDLE: %d\n", rc);
 694                 return (rc);
 695         }
 696
 697         set_fs (KERNEL_DS);
 698         rc = sock->ops->setsockopt (sock, SOL_TCP, TCP_KEEPINTVL,
 699                                     (char *)&keep_intvl, sizeof (keep_intvl));
 700         set_fs (oldmm);
 701         if (rc != 0) {
 702                 CERROR ("Can't set TCP_KEEPINTVL: %d\n", rc);
 703                 return (rc);
 704         }
 705
 706         set_fs (KERNEL_DS);
 707         rc = sock->ops->setsockopt (sock, SOL_TCP, TCP_KEEPCNT,
 708                                     (char *)&keep_count, sizeof (keep_count));
 709         set_fs (oldmm);
 710         if (rc != 0) {
 711                 CERROR ("Can't set TCP_KEEPCNT: %d\n", rc);
 712                 return (rc);
 713         }
 714
 715         return (0);
 716 }
 717
 718 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
 719 struct tcp_opt *sock2tcp_opt(struct sock *sk)
 720 {
 721         return &(sk->tp_pinfo.af_tcp);
 722 }
 723 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,10))
 724 #define sock2tcp_opt(sk) tcp_sk(sk)
 725 #else
 726 struct tcp_opt *sock2tcp_opt(struct sock *sk)
 727 {
 728         struct tcp_sock *s = (struct tcp_sock *)sk;
 729         return &s->tcp;
 730 }
 731 #endif
 732
 733 void
 734 ksocknal_lib_push_conn (ksock_conn_t *conn)
 735 {
 736         struct sock    *sk;
 737 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,11))
 738         struct tcp_opt *tp;
 739 #else
 740         struct tcp_sock *tp;
 741 #endif
 742         int             nonagle;
 743         int             val = 1;
 744         int             rc;
 745         mm_segment_t    oldmm;
 746
 747         rc = ksocknal_connsock_addref(conn);
 748         if (rc != 0)                            /* being shut down */
 749                 return;
 750
 751         sk = conn->ksnc_sock->sk;
 752         tp = sock2tcp_opt(sk);
 753
 754         lock_sock (sk);
 755         nonagle = tp->nonagle;
 756         tp->nonagle = 1;
 757         release_sock (sk);
 758
 759         oldmm = get_fs ();
 760         set_fs (KERNEL_DS);
 761
 762         rc = sk->sk_prot->setsockopt (sk, SOL_TCP, TCP_NODELAY,
 763                                       (char *)&val, sizeof (val));
 764         LASSERT (rc == 0);
 765
 766         set_fs (oldmm);
 767
 768         lock_sock (sk);
 769         tp->nonagle = nonagle;
 770         release_sock (sk);
 771
 772         ksocknal_connsock_decref(conn);
 773 }
 774
 775 extern void ksocknal_read_callback (ksock_conn_t *conn);
 776 extern void ksocknal_write_callback (ksock_conn_t *conn);
 777 /*
 778  * socket call back in Linux
 779  */
 780 static void
 781 ksocknal_data_ready (struct sock *sk, int n)
 782 {
 783         ksock_conn_t  *conn;
 784         ENTRY;
 785
 786         /* interleave correctly with closing sockets... */
 787         LASSERT(!in_irq());
 788         read_lock (&ksocknal_data.ksnd_global_lock);
 789
 790         conn = sk->sk_user_data;
 791         if (conn == NULL) {             /* raced with ksocknal_terminate_conn */
 792                 LASSERT (sk->sk_data_ready != &ksocknal_data_ready);
 793                 sk->sk_data_ready (sk, n);
 794         } else
 795                 ksocknal_read_callback(conn);
 796
 797         read_unlock (&ksocknal_data.ksnd_global_lock);
 798
 799         EXIT;
 800 }
 801
 802 static void
 803 ksocknal_write_space (struct sock *sk)
 804 {
 805         ksock_conn_t  *conn;
 806         int            wspace;
 807         int            min_wpace;
 808
 809         /* interleave correctly with closing sockets... */
 810         LASSERT(!in_irq());
 811         read_lock (&ksocknal_data.ksnd_global_lock);
 812
 813         conn = sk->sk_user_data;
 814         wspace = SOCKNAL_WSPACE(sk);
 815         min_wpace = SOCKNAL_MIN_WSPACE(sk);
 816
 817         CDEBUG(D_NET, "sk %p wspace %d low water %d conn %p%s%s%s\n",
 818                sk, wspace, min_wpace, conn,
 819                (conn == NULL) ? "" : (conn->ksnc_tx_ready ?
 820                                       " ready" : " blocked"),
 821                (conn == NULL) ? "" : (conn->ksnc_tx_scheduled ?
 822                                       " scheduled" : " idle"),
 823                (conn == NULL) ? "" : (list_empty (&conn->ksnc_tx_queue) ?
 824                                       " empty" : " queued"));
 825
 826         if (conn == NULL) {             /* raced with ksocknal_terminate_conn */
 827                 LASSERT (sk->sk_write_space != &ksocknal_write_space);
 828                 sk->sk_write_space (sk);
 829
 830                 read_unlock (&ksocknal_data.ksnd_global_lock);
 831                 return;
 832         }
 833
 834         if (wspace >= min_wpace) {              /* got enough space */
 835                 ksocknal_write_callback(conn);
 836
 837                 /* Clear SOCK_NOSPACE _after_ ksocknal_write_callback so the
 838                  * ENOMEM check in ksocknal_transmit is race-free (think about
 839                  * it). */
 840
 841                 clear_bit (SOCK_NOSPACE, &sk->sk_socket->flags);
 842         }
 843
 844         read_unlock (&ksocknal_data.ksnd_global_lock);
 845 }
 846
 847 void
 848 ksocknal_lib_save_callback(struct socket *sock, ksock_conn_t *conn)
 849 {
 850         conn->ksnc_saved_data_ready = sock->sk->sk_data_ready;
 851         conn->ksnc_saved_write_space = sock->sk->sk_write_space;
 852 }
 853
 854 void
 855 ksocknal_lib_set_callback(struct socket *sock,  ksock_conn_t *conn)
 856 {
 857         sock->sk->sk_user_data = conn;
 858         sock->sk->sk_data_ready = ksocknal_data_ready;
 859         sock->sk->sk_write_space = ksocknal_write_space;
 860         return;
 861 }
 862
 863 void
 864 ksocknal_lib_reset_callback(struct socket *sock, ksock_conn_t *conn)
 865 {
 866         /* Remove conn's network callbacks.
 867          * NB I _have_ to restore the callback, rather than storing a noop,
 868          * since the socket could survive past this module being unloaded!! */
 869         sock->sk->sk_data_ready = conn->ksnc_saved_data_ready;
 870         sock->sk->sk_write_space = conn->ksnc_saved_write_space;
 871
 872         /* A callback could be in progress already; they hold a read lock
 873          * on ksnd_global_lock (to serialise with me) and NOOP if
 874          * sk_user_data is NULL. */
 875         sock->sk->sk_user_data = NULL;
 876
 877         return ;
 878 }
 879