lnet/klnds/gnilnd/gnilnd_modparams.c

   1 /*
   2  * Copyright (C) 2004 Cluster File Systems, Inc.
   3  *
   4  * Copyright (C) 2009-2012 Cray, Inc.
   5  *
   6  *   Derived from work by: Eric Barton <eric@bartonsoftware.com>
   7  *   Author: Nic Henke <nic@cray.com>
   8  *
   9  *   This file is part of Lustre, http://www.lustre.org.
  10  *
  11  *   Lustre is free software; you can redistribute it and/or
  12  *   modify it under the terms of version 2 of the GNU General Public
  13  *   License as published by the Free Software Foundation.
  14  *
  15  *   Lustre is distributed in the hope that it will be useful,
  16  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  *   GNU General Public License for more details.
  19  *
  20  *   You should have received a copy of the GNU General Public License
  21  *   along with Lustre; if not, write to the Free Software
  22  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23  *
  24  */
  25
  26 #include "gnilnd.h"
  27
  28 static int credits = 256;
  29 CFS_MODULE_PARM(credits, "i", int, 0444,
  30                 "# concurrent sends");
  31
  32 static int eager_credits = 256 * 1024;
  33 CFS_MODULE_PARM(eager_credits, "i", int, 0644,
  34                 "# eager buffers");
  35
  36 static int peer_credits = 16;
  37 CFS_MODULE_PARM(peer_credits, "i", int, 0444,
  38                 "# LNet peer credits");
  39
  40 /* NB - we'll not actually limit sends to this, we just size the mailbox buffer
  41  * such that at most we'll have concurrent_sends * max_immediate messages
  42  * in the mailbox */
  43 static int concurrent_sends = 0;
  44 CFS_MODULE_PARM(concurrent_sends, "i", int, 0444,
  45                 "# concurrent HW sends to 1 peer");
  46
  47 /* default for 2k nodes @ 16 peer credits */
  48 static int fma_cq_size = 32768;
  49 CFS_MODULE_PARM(fma_cq_size, "i", int, 0444,
  50                 "size of the completion queue");
  51
  52 static int timeout = GNILND_BASE_TIMEOUT;
  53 /* can't change @ runtime because LNet gets NI data at startup from
  54  * this value */
  55 CFS_MODULE_PARM(timeout, "i", int, 0444,
  56                 "communications timeout (seconds)");
  57
  58 /* time to wait between datagram timeout and sending of next dgram */
  59 static int min_reconnect_interval = GNILND_MIN_RECONNECT_TO;
  60 CFS_MODULE_PARM(min_reconnect_interval, "i", int, 0644,
  61                 "minimum connection retry interval (seconds)");
  62
  63 /* if this goes longer than timeout, we'll timeout the TX before
  64  * the dgram */
  65 static int max_reconnect_interval = GNILND_MAX_RECONNECT_TO;
  66 CFS_MODULE_PARM(max_reconnect_interval, "i", int, 0644,
  67                 "maximum connection retry interval (seconds)");
  68
  69 static int max_immediate = 2048;
  70 CFS_MODULE_PARM(max_immediate, "i", int, 0444,
  71                 "immediate/RDMA breakpoint");
  72
  73 static int checksum = GNILND_CHECKSUM_DEFAULT;
  74 CFS_MODULE_PARM(checksum, "i", int, 0644,
  75                 "0: None, 1: headers, 2: short msg, 3: all traffic");
  76
  77 static int checksum_dump = 0;
  78 CFS_MODULE_PARM(checksum_dump, "i", int, 0644,
  79                 "0: None, 1: dump log on failure, 2: payload data to D_INFO log");
  80
  81 static int bte_dlvr_mode = GNILND_RDMA_DLVR_OPTION;
  82 CFS_MODULE_PARM(bte_dlvr_mode, "i", int, 0644,
  83                 "enable hashing for BTE (RDMA) transfers");
  84
  85 static int bte_relaxed_ordering = 1;
  86 CFS_MODULE_PARM(bte_relaxed_ordering, "i", int, 0644,
  87                 "enable relaxed ordering (PASSPW) for BTE (RDMA) transfers");
  88
  89 #ifdef CONFIG_MK1OM
  90 static int ptag = GNI_PTAG_LND_KNC;
  91 #else
  92 static int ptag = GNI_PTAG_LND;
  93 #endif
  94 CFS_MODULE_PARM(ptag, "i", int, 0444,
  95                 "ptag for Gemini CDM");
  96
  97 static int pkey = GNI_JOB_CREATE_COOKIE(GNI_PKEY_LND, 0);
  98 CFS_MODULE_PARM(pkey, "i", int, 0444, "pkey for CDM");
  99
 100 static int max_retransmits = 1024;
 101 CFS_MODULE_PARM(max_retransmits, "i", int, 0444,
 102                 "max retransmits for FMA");
 103
 104 static int nwildcard = 4;
 105 CFS_MODULE_PARM(nwildcard, "i", int, 0444,
 106                 "# wildcard datagrams to post per net (interface)");
 107
 108 static int nice = -20;
 109 CFS_MODULE_PARM(nice, "i", int, 0444,
 110                 "nice value for kgnilnd threads, default -20");
 111
 112 static int rdmaq_intervals = 4;
 113 CFS_MODULE_PARM(rdmaq_intervals, "i", int, 0644,
 114                 "# intervals per second for rdmaq throttling, default 4, 0 to disable");
 115
 116 static int loops = 100;
 117 CFS_MODULE_PARM(loops, "i", int, 0644,
 118                 "# of loops before scheduler is friendly, default 100");
 119
 120 static int hash_size = 503;
 121 CFS_MODULE_PARM(hash_size, "i", int, 0444,
 122                 "prime number for peer/conn hash sizing, default 503");
 123
 124 static int peer_health = 0;
 125 CFS_MODULE_PARM(peer_health, "i", int, 0444,
 126                 "Disable peer timeout for LNet peer health, default off, > 0 to enable");
 127
 128 static int peer_timeout = -1;
 129 CFS_MODULE_PARM(peer_timeout, "i", int, 0444,
 130                 "Peer timeout used for peer_health, default based on gnilnd timeout, > -1 to manually set");
 131
 132 static int vmap_cksum = 0;
 133 CFS_MODULE_PARM(vmap_cksum, "i", int, 0644,
 134                 "use vmap for all kiov checksumming, default off");
 135
 136 static int mbox_per_block = GNILND_FMABLK;
 137 CFS_MODULE_PARM(mbox_per_block, "i", int, 0644,
 138                 "mailboxes per block");
 139
 140 static int nphys_mbox = 0;
 141 CFS_MODULE_PARM(nphys_mbox, "i", int, 0444,
 142                 "# mbox to preallocate from physical memory, default 0");
 143
 144 static int mbox_credits = GNILND_MBOX_CREDITS;
 145 CFS_MODULE_PARM(mbox_credits, "i", int, 0644,
 146                 "number of credits per mailbox");
 147
 148 static int sched_threads = GNILND_SCHED_THREADS;
 149 CFS_MODULE_PARM(sched_threads, "i", int, 0444,
 150                 "number of threads for moving data");
 151
 152 static int net_hash_size = 11;
 153 CFS_MODULE_PARM(net_hash_size, "i", int, 0444,
 154                 "prime number for net hash sizing, default 11");
 155
 156 static int hardware_timeout = GNILND_HARDWARE_TIMEOUT;
 157 CFS_MODULE_PARM(hardware_timeout, "i", int, 0444,
 158                 "maximum time for traffic to get from one node to another");
 159
 160 static int mdd_timeout = GNILND_MDD_TIMEOUT;
 161 CFS_MODULE_PARM(mdd_timeout, "i", int, 0644,
 162                 "maximum time (in minutes) for mdd to be held");
 163
 164 static int sched_timeout = GNILND_SCHED_TIMEOUT;
 165 CFS_MODULE_PARM(sched_timeout, "i", int, 0644,
 166                 "scheduler aliveness in seconds max time");
 167
 168 static int sched_nice = GNILND_SCHED_NICE;
 169 CFS_MODULE_PARM(sched_nice, "i", int, 0444,
 170                 "scheduler's nice setting, default compute 0 service -20");
 171
 172 static int reverse_rdma = GNILND_REVERSE_RDMA;
 173 CFS_MODULE_PARM(reverse_rdma, "i", int, 0644,
 174                 "Normal 0: Reverse GET: 1 Reverse Put: 2 Reverse Both: 3");
 175
 176 static int dgram_timeout = GNILND_DGRAM_TIMEOUT;
 177 CFS_MODULE_PARM(dgram_timeout, "i", int, 0644,
 178                 "dgram thread aliveness seconds max time");
 179
 180 static int efault_lbug = 0;
 181 CFS_MODULE_PARM(efault_lbug, "i", int, 0644,
 182                 "If a compute receives an EFAULT in"
 183                 " a message should it LBUG. 0 off 1 on");
 184
 185 static int fast_reconn = GNILND_FAST_RECONNECT;
 186 CFS_MODULE_PARM(fast_reconn, "i", int, 0644,
 187                 "fast reconnect on connection timeout");
 188
 189 static int max_conn_purg = GNILND_PURGATORY_MAX;
 190 CFS_MODULE_PARM(max_conn_purg, "i", int, 0644,
 191                 "Max number of connections per peer in purgatory");
 192
 193 static int thread_affinity = 0;
 194 CFS_MODULE_PARM(thread_affinity, "i", int, 0444,
 195                 "scheduler thread affinity default 0 (disabled)");
 196
 197 static int thread_safe = GNILND_TS_ENABLE;
 198 CFS_MODULE_PARM(thread_safe, "i", int, 0444,
 199                 "Use kgni thread safe API if available");
 200
 201 static int reg_fail_timeout = GNILND_REGFAILTO_DISABLE;
 202 CFS_MODULE_PARM(reg_fail_timeout, "i", int, 0644,
 203                 "fmablk registration timeout LBUG");
 204
 205 kgn_tunables_t kgnilnd_tunables = {
 206         .kgn_min_reconnect_interval = &min_reconnect_interval,
 207         .kgn_max_reconnect_interval = &max_reconnect_interval,
 208         .kgn_credits                = &credits,
 209         .kgn_peer_credits           = &peer_credits,
 210         .kgn_concurrent_sends       = &concurrent_sends,
 211         .kgn_fma_cq_size            = &fma_cq_size,
 212         .kgn_timeout                = &timeout,
 213         .kgn_max_immediate          = &max_immediate,
 214         .kgn_checksum               = &checksum,
 215         .kgn_checksum_dump          = &checksum_dump,
 216         .kgn_bte_dlvr_mode          = &bte_dlvr_mode,
 217         .kgn_bte_relaxed_ordering   = &bte_relaxed_ordering,
 218         .kgn_ptag                   = &ptag,
 219         .kgn_pkey                   = &pkey,
 220         .kgn_max_retransmits        = &max_retransmits,
 221         .kgn_nwildcard              = &nwildcard,
 222         .kgn_nice                   = &nice,
 223         .kgn_rdmaq_intervals        = &rdmaq_intervals,
 224         .kgn_loops                  = &loops,
 225         .kgn_peer_hash_size         = &hash_size,
 226         .kgn_peer_health            = &peer_health,
 227         .kgn_peer_timeout           = &peer_timeout,
 228         .kgn_vmap_cksum             = &vmap_cksum,
 229         .kgn_mbox_per_block         = &mbox_per_block,
 230         .kgn_nphys_mbox             = &nphys_mbox,
 231         .kgn_mbox_credits           = &mbox_credits,
 232         .kgn_sched_threads          = &sched_threads,
 233         .kgn_net_hash_size          = &net_hash_size,
 234         .kgn_hardware_timeout       = &hardware_timeout,
 235         .kgn_mdd_timeout            = &mdd_timeout,
 236         .kgn_sched_timeout          = &sched_timeout,
 237         .kgn_sched_nice             = &sched_nice,
 238         .kgn_reverse_rdma           = &reverse_rdma,
 239         .kgn_dgram_timeout          = &dgram_timeout,
 240         .kgn_eager_credits          = &eager_credits,
 241         .kgn_fast_reconn            = &fast_reconn,
 242         .kgn_efault_lbug            = &efault_lbug,
 243         .kgn_thread_affinity        = &thread_affinity,
 244         .kgn_thread_safe            = &thread_safe,
 245         .kgn_reg_fail_timeout       = &reg_fail_timeout,
 246         .kgn_max_purgatory          = &max_conn_purg
 247 };
 248
 249 #if CONFIG_SYSCTL && !CFS_SYSFS_MODULE_PARM
 250 static struct ctl_table kgnilnd_ctl_table[] = {
 251         {
 252                 INIT_CTL_NAME
 253                 .procname = "min_reconnect_interval",
 254                 .data     = &min_reconnect_interval,
 255                 .maxlen   = sizeof(int),
 256                 .mode     = 0644,
 257                 .proc_handler = &proc_dointvec
 258         },
 259         {
 260                 INIT_CTL_NAME
 261                 .procname = "max_reconnect_interval",
 262                 .data     = &max_reconnect_interval,
 263                 .maxlen   = sizeof(int),
 264                 .mode     = 0644,
 265                 .proc_handler = &proc_dointvec
 266         },
 267         {
 268                 INIT_CTL_NAME
 269                 .procname = "credits",
 270                 .data     = &credits,
 271                 .maxlen   = sizeof(int),
 272                 .mode     = 0444,
 273                 .proc_handler = &proc_dointvec
 274         },
 275         {
 276                 INIT_CTL_NAME
 277                 .procname = "peer_credits",
 278                 .data     = &peer_credits,
 279                 .maxlen   = sizeof(int),
 280                 .mode     = 0444,
 281                 .proc_handler = &proc_dointvec
 282         },
 283         {
 284                 INIT_CTL_NAME
 285                 .procname = "fma_cq_size",
 286                 .data     = &fma_cq_size,
 287                 .maxlen   = sizeof(int),
 288                 .mode     = 0444,
 289                 .proc_handler = &proc_dointvec
 290         },
 291         {
 292                 INIT_CTL_NAME
 293                 .procname = "timeout",
 294                 .data     = &timeout,
 295                 .maxlen   = sizeof(int),
 296                 .mode     = 0444,
 297                 .proc_handler = &proc_dointvec
 298         },
 299         {
 300                 INIT_CTL_NAME
 301                 .procname = "max_immediate",
 302                 .data     = &max_immediate,
 303                 .maxlen   = sizeof(int),
 304                 .mode     = 0444,
 305                 .proc_handler = &proc_dointvec
 306         },
 307         {
 308                 INIT_CTL_NAME
 309                 .procname = "checksum",
 310                 .data     = &checksum,
 311                 .maxlen   = sizeof(int),
 312                 .mode     = 0644,
 313                 .proc_handler = &proc_dointvec
 314         },
 315         {
 316                 INIT_CTL_NAME
 317                 .procname = "bte_dlvr_mode",
 318                 .data     = &bte_dlvr_mode,
 319                 .maxlen   = sizeof(int),
 320                 .mode     = 0644,
 321                 .proc_handler = &proc_dointvec
 322         },
 323         {
 324                 INIT_CTL_NAME
 325                 .procname = "ptag",
 326                 .data     = &ptag,
 327                 .maxlen   = sizeof(int),
 328                 .mode     = 0444,
 329                 .proc_handler = &proc_dointvec
 330         },
 331         {
 332                 INIT_CTL_NAME
 333                 .procname = "pkey",
 334                 .data     = &pkey,
 335                 .maxlen   = sizeof(int),
 336                 .mode     = 0444,
 337                 .proc_handler = &proc_dointvec
 338         },
 339         {
 340                 INIT_CTL_NAME
 341                 .procname = "nwildcard",
 342                 .data     = &nwildcard,
 343                 .maxlen   = sizeof(int),
 344                 .mode     = 0444,
 345                 .proc_handler = &proc_dointvec
 346         },
 347         {
 348                 INIT_CTL_NAME
 349                 .procname = "bte_relaxed_ordering",
 350                 .data     = &bte_relaxed_ordering,
 351                 .maxlen   = sizeof(int),
 352                 .mode     = 0644,
 353                 .proc_handler = &proc_dointvec
 354         },
 355         {
 356                 INIT_CTL_NAME
 357                 .procname = "checksum_dump",
 358                 .data     = &checksum_dump,
 359                 .maxlen   = sizeof(int),
 360                 .mode     = 0644,
 361                 .proc_handler = &proc_dointvec
 362         },
 363         {
 364                 INIT_CTL_NAME
 365                 .procname = "nice",
 366                 .data     = &nice,
 367                 .maxlen   = sizeof(int),
 368                 .mode     = 0444,
 369                 .proc_handler = &proc_dointvec
 370         },
 371         {
 372                 INIT_CTL_NAME
 373                 .procname = "rdmaq_intervals",
 374                 .data     = &rdmaq_intervals,
 375                 .maxlen   = sizeof(int),
 376                 .mode     = 0644,
 377                 .proc_handler = &proc_dointvec
 378         },
 379         {
 380                 INIT_CTL_NAME
 381                 .procname = "loops",
 382                 .data     = &loops,
 383                 .maxlen   = sizeof(int),
 384                 .mode     = 0644,
 385                 .proc_handler = &proc_dointvec
 386         },
 387         {
 388                 INIT_CTL_NAME
 389                 .procname = "hash_size",
 390                 .data     = &hash_size,
 391                 .maxlen   = sizeof(int),
 392                 .mode     = 0444,
 393                 .proc_handler = &proc_dointvec
 394         },
 395         {
 396                 INIT_CTL_NAME
 397                 .procname = "peer_health",
 398                 .data     = &peer_health,
 399                 .maxlen   = sizeof(int),
 400                 .mode     = 0444,
 401                 .proc_handler = &proc_dointvec
 402         },
 403         {
 404                 INIT_CTL_NAME
 405                 .procname = "vmap_cksum",
 406                 .data     = &vmap_cksum,
 407                 .maxlen   = sizeof(int),
 408                 .mode     = 0644,
 409                 .proc_handler = &proc_dointvec
 410         },
 411         {
 412                 INIT_CTL_NAME
 413                 .procname = "mbox_per_block",
 414                 .data     = &mbox_per_block,
 415                 .maxlen   = sizeof(int),
 416                 .mode     = 0644,
 417                 .proc_handler = &proc_dointvec
 418         },
 419         {
 420                 INIT_CTL_NAME
 421                 .procname = "mbox_credits"
 422                 .data     = &mbox_credits,
 423                 .maxlen   = sizeof(int),
 424                 .mode     = 0644,
 425                 .proc_handler = &proc_dointvec
 426         },
 427         {
 428                 INIT_CTL_NAME
 429                 .procname = "sched_threads"
 430                 .data     = &sched_threads,
 431                 .maxlen   = sizeof(int),
 432                 .mode     = 0444,
 433                 .proc_handler = &proc_dointvec
 434         },
 435         {
 436                 INIT_CTL_NAME
 437                 .procname = "net_hash_size",
 438                 .data     = &net_hash_size,
 439                 .maxlen   = sizeof(int),
 440                 .mode     = 0444,
 441                 .proc_handler = &proc_dointvec
 442         },
 443         {
 444                 INIT_CTL_NAME
 445                 .procname = "hardware_timeout",
 446                 .data     = &hardware_timeout,
 447                 .maxlen   = sizeof(int),
 448                 .mode     = 0444,
 449                 .proc_handler = &proc_dointvec
 450         },
 451         {
 452                 INIT_CTL_NAME
 453                 .procname = "mdd_timeout",
 454                 .data     = &mdd_timeout,
 455                 .maxlen   = sizeof(int),
 456                 .mode     = 0644,
 457                 .proc_handler = &proc_dointvec
 458         },
 459         {
 460                 INIT_CTL_NAME
 461                 .procname = "max_retransmits"
 462                 .data     = &max_retransmits,
 463                 .maxlen   = sizeof(int),
 464                 .mode     = 0444,
 465                 .proc_handler = &proc_dointvec
 466         },
 467         {
 468                 INIT_CTL_NAME
 469                 .procname = "concurrent_sends",
 470                 .data     = &concurrent_sends,
 471                 .maxlen   = sizeof(int),
 472                 .mode     = 0444,
 473                 .proc_handler = &proc_dointvec
 474         },
 475         {
 476                 INIT_CTL_NAME
 477                 .procname = "nphys_mbox",
 478                 .data     = &nphys_mbox,
 479                 .maxlen   = sizeof(int),
 480                 .mode     = 0444,
 481                 .proc_handler = &proc_dointvec
 482         },
 483         {
 484                 INIT_CTL_NAME
 485                 .procname = "sched_timeout",
 486                 .data     = &sched_timeout,
 487                 .maxlen   = sizeof(int),
 488                 .mode     = 0644,
 489                 .proc_handler = &proc_dointvec
 490         },
 491         {
 492                 INIT_CTL_NAME
 493                 .procname = "sched_nice",
 494                 .data     = &sched_nice,
 495                 .maxlen   = sizeof(int),
 496                 .mode     = 0444,
 497                 .proc_handler = &proc_dointvec
 498         },
 499         {
 500                 INIT_CTL_NAME
 501                 .procname = "reverse_rdma",
 502                 .data     = &reverse_rdma,
 503                 .maxlen   = sizeof(int),
 504                 .mode     = 0644,
 505                 .proc_handler = &proc_dointvec
 506         },
 507                 INIT_CTL_NAME
 508                 .procname = "dgram_timeout"
 509                 .data     = &dgram_timeout,
 510                 .maxlen   = sizeof(int),
 511                 .mode     = 0644,
 512                 .proc_handler = &proc_dointvec
 513         },
 514         {
 515                 INIT_CTL_NAME
 516                 .procname = "peer_timeout"
 517                 .data     = &peer_timeout,
 518                 .maxlen   = sizeof(int),
 519                 .mode     = 0444,
 520                 .proc_handler = &proc_dointvec
 521         },
 522         {
 523                 INIT_CTL_NAME
 524                 .procname = "eager_credits",
 525                 .data     = &eager_credits,
 526                 .maxlen   = sizeof(int),
 527                 .mode     = 0644,
 528                 .proc_handler = &proc_dointvec
 529         },
 530         {
 531                 INIT_CTL_NAME
 532                 .procname = "efault_lbug"
 533                 .data     = &efault_lbug,
 534                 .maxlen   = sizeof(int),
 535                 .mode     = 0644,
 536                 .proc_handler = &proc_dointvec
 537         },
 538         {
 539                 INIT_CTL_NAME
 540                 .procname = "thread_affinity"
 541                 .data     = &thread_affinity,
 542                 .maxlen   = sizeof(int),
 543                 .mode     = 0444,
 544                 .proc_handler = &proc_dointvec
 545         },
 546         {
 547                 INIT_CTL_NAME
 548                 .procname = "thread_safe"
 549                 .data     = &thread_safe,
 550                 .maxlen   = sizeof(int),
 551                 .mode     = 0444,
 552                 .proc_handler = &proc_dointvec
 553         },
 554         {
 555                 INIT_CTL_NAME
 556                 .procname = "reg_fail_timeout"
 557                 .data     = &reg_fail_timeout,
 558                 .maxlen   = sizeof(int),
 559                 .mode     = 0644,
 560                 .proc_handler = &proc_dointvec
 561         },
 562         {
 563                 INIT_CTL_NAME
 564                 .procname = "max_conn_purg"
 565                 .data     = &max_conn_purg,
 566                 .maxlen   = sizeof(int),
 567                 .mode     = 0644,
 568                 .proc_handler = &proc_dointvec
 569         },
 570         { 0 }
 571 };
 572
 573 static struct ctl_table kgnilnd_top_ctl_table[] = {
 574         {
 575                 INIT_CTL_NAME
 576                 .procname = "gnilnd",
 577                 .data     = NULL,
 578                 .maxlen   = 0,
 579                 .mode     = 0555,
 580                 .child    = kgnilnd_ctl_table
 581         },
 582         { 0 }
 583 };
 584 #endif
 585
 586 int
 587 kgnilnd_tunables_init()
 588 {
 589         int rc = 0;
 590
 591 #if CONFIG_SYSCTL && !CFS_SYSFS_MODULE_PARM
 592         kgnilnd_tunables.kgn_sysctl =
 593                 register_sysctl_table(kgnilnd_top_ctl_table, 0);
 594
 595         if (kgnilnd_tunables.kgn_sysctl == NULL)
 596                 CWARN("Can't setup /proc tunables\n");
 597 #endif
 598         switch (*kgnilnd_tunables.kgn_checksum) {
 599         default:
 600                 CERROR("Invalid checksum module parameter: %d\n",
 601                        *kgnilnd_tunables.kgn_checksum);
 602                 rc = -EINVAL;
 603                 GOTO(out, rc);
 604         case GNILND_CHECKSUM_OFF:
 605                 /* no checksumming */
 606                 break;
 607         case GNILND_CHECKSUM_SMSG_HEADER:
 608                 LCONSOLE_INFO("SMSG header only checksumming enabled\n");
 609                 break;
 610         case GNILND_CHECKSUM_SMSG:
 611                 LCONSOLE_INFO("SMSG checksumming enabled\n");
 612                 break;
 613         case GNILND_CHECKSUM_SMSG_BTE:
 614                 LCONSOLE_INFO("SMSG + BTE checksumming enabled\n");
 615                 break;
 616         }
 617
 618         if (*kgnilnd_tunables.kgn_max_immediate > GNILND_MAX_IMMEDIATE) {
 619                 LCONSOLE_ERROR("kgnilnd module parameter 'max_immediate' too large %d > %d\n",
 620                 *kgnilnd_tunables.kgn_max_immediate, GNILND_MAX_IMMEDIATE);
 621                 rc = -EINVAL;
 622                 GOTO(out, rc);
 623         }
 624
 625         if (*kgnilnd_tunables.kgn_mbox_per_block < 1) {
 626                 *kgnilnd_tunables.kgn_mbox_per_block = 1;
 627         }
 628
 629         if (*kgnilnd_tunables.kgn_concurrent_sends == 0) {
 630                 *kgnilnd_tunables.kgn_concurrent_sends = *kgnilnd_tunables.kgn_peer_credits;
 631         } else if (*kgnilnd_tunables.kgn_concurrent_sends > *kgnilnd_tunables.kgn_peer_credits) {
 632                 LCONSOLE_ERROR("kgnilnd parameter 'concurrent_sends' too large: %d > %d (peer_credits)\n",
 633                                *kgnilnd_tunables.kgn_concurrent_sends, *kgnilnd_tunables.kgn_peer_credits);
 634                 rc = -EINVAL;
 635         }
 636 out:
 637         return rc;
 638 }
 639
 640 void
 641 kgnilnd_tunables_fini()
 642 {
 643 #if CONFIG_SYSCTL && !CFS_SYSFS_MODULE_PARM
 644         if (kgnilnd_tunables.kgn_sysctl != NULL)
 645                 unregister_sysctl_table(kgnilnd_tunables.kgn_sysctl);
 646 #endif
 647 }