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