lnet/klnds/o2iblnd/o2iblnd_modparams.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  * Copyright (C) 2006 Cluster File Systems, Inc.
   5  *   Author: Eric Barton <eric@bartonsoftware.com>
   6  *
   7  *   This file is part of Lustre, http://www.lustre.org.
   8  *
   9  *   Lustre is free software; you can redistribute it and/or
  10  *   modify it under the terms of version 2 of the GNU General Public
  11  *   License as published by the Free Software Foundation.
  12  *
  13  *   Lustre is distributed in the hope that it will be useful,
  14  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *   GNU General Public License for more details.
  17  *
  18  *   You should have received a copy of the GNU General Public License
  19  *   along with Lustre; if not, write to the Free Software
  20  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21  *
  22  */
  23
  24 #include "o2iblnd.h"
  25
  26 static int service = 987;
  27 CFS_MODULE_PARM(service, "i", int, 0444,
  28                 "service number (within RDMA_PS_TCP)");
  29
  30 static int cksum = 0;
  31 CFS_MODULE_PARM(cksum, "i", int, 0644,
  32                 "set non-zero to enable message (not RDMA) checksums");
  33
  34 static int timeout = 50;
  35 CFS_MODULE_PARM(timeout, "i", int, 0644,
  36                 "timeout (seconds)");
  37
  38 static int ntx = 256;
  39 CFS_MODULE_PARM(ntx, "i", int, 0444,
  40                 "# of message descriptors");
  41
  42 static int credits = 64;
  43 CFS_MODULE_PARM(credits, "i", int, 0444,
  44                 "# concurrent sends");
  45
  46 static int peer_credits = 8;
  47 CFS_MODULE_PARM(peer_credits, "i", int, 0444,
  48                 "# concurrent sends to 1 peer");
  49
  50 static char *ipif_name = "ib0";
  51 CFS_MODULE_PARM(ipif_name, "s", charp, 0444,
  52                 "IPoIB interface name");
  53
  54 static int retry_count = 5;
  55 CFS_MODULE_PARM(retry_count, "i", int, 0644,
  56                 "Retransmissions when no ACK received");
  57
  58 static int rnr_retry_count = 6;
  59 CFS_MODULE_PARM(rnr_retry_count, "i", int, 0644,
  60                 "RNR retransmissions");
  61
  62 static int keepalive = 100;
  63 CFS_MODULE_PARM(keepalive, "i", int, 0644,
  64                 "Idle time in seconds before sending a keepalive");
  65
  66 static int ib_mtu = 0;
  67 CFS_MODULE_PARM(ib_mtu, "i", int, 0444,
  68                 "IB MTU 256/512/1024/2048/4096");
  69
  70 #if IBLND_MAP_ON_DEMAND
  71 static int concurrent_sends = IBLND_RX_MSGS;
  72 #else
  73 static int concurrent_sends = IBLND_MSG_QUEUE_SIZE;
  74 #endif
  75 CFS_MODULE_PARM(concurrent_sends, "i", int, 0444,
  76                 "send work-queue sizing");
  77
  78 #if IBLND_MAP_ON_DEMAND
  79 static int fmr_pool_size = 512;
  80 CFS_MODULE_PARM(fmr_pool_size, "i", int, 0444,
  81                 "size of the fmr pool (>= ntx)");
  82
  83 static int fmr_flush_trigger = 384;
  84 CFS_MODULE_PARM(fmr_flush_trigger, "i", int, 0444,
  85                 "# dirty FMRs that triggers pool flush");
  86
  87 static int fmr_cache = 1;
  88 CFS_MODULE_PARM(fmr_cache, "i", int, 0444,
  89                 "non-zero to enable FMR caching");
  90 #endif
  91
  92 kib_tunables_t kiblnd_tunables = {
  93         .kib_service                = &service,
  94         .kib_cksum                  = &cksum,
  95         .kib_timeout                = &timeout,
  96         .kib_keepalive              = &keepalive,
  97         .kib_ntx                    = &ntx,
  98         .kib_credits                = &credits,
  99         .kib_peercredits            = &peer_credits,
 100         .kib_default_ipif           = &ipif_name,
 101         .kib_retry_count            = &retry_count,
 102         .kib_rnr_retry_count        = &rnr_retry_count,
 103         .kib_concurrent_sends       = &concurrent_sends,
 104         .kib_ib_mtu                 = &ib_mtu,
 105 #if IBLND_MAP_ON_DEMAND
 106         .kib_fmr_pool_size          = &fmr_pool_size,
 107         .kib_fmr_flush_trigger      = &fmr_flush_trigger,
 108         .kib_fmr_cache              = &fmr_cache,
 109 #endif
 110 };
 111
 112 #if defined(CONFIG_SYSCTL) && !CFS_SYSFS_MODULE_PARM
 113
 114 static char ipif_basename_space[32];
 115
 116 static cfs_sysctl_table_t kiblnd_ctl_table[] = {
 117         {
 118                 .ctl_name = 1,
 119                 .procname = "service",
 120                 .data     = &service,
 121                 .maxlen   = sizeof(int),
 122                 .mode     = 0444,
 123                 .proc_handler = &proc_dointvec
 124         },
 125         {
 126                 .ctl_name = 2,
 127                 .procname = "cksum",
 128                 .data     = &cksum,
 129                 .maxlen   = sizeof(int),
 130                 .mode     = 0644,
 131                 .proc_handler = &proc_dointvec
 132         },
 133         {
 134                 .ctl_name = 3,
 135                 .procname = "timeout",
 136                 .data     = &timeout,
 137                 .maxlen   = sizeof(int),
 138                 .mode     = 0644,
 139                 .proc_handler = &proc_dointvec
 140         },
 141         {
 142                 .ctl_name = 4,
 143                 .procname = "ntx",
 144                 .data     = &ntx,
 145                 .maxlen   = sizeof(int),
 146                 .mode     = 0444,
 147                 .proc_handler = &proc_dointvec
 148         },
 149         {
 150                 .ctl_name = 5,
 151                 .procname = "credits",
 152                 .data     = &credits,
 153                 .maxlen   = sizeof(int),
 154                 .mode     = 0444,
 155                 .proc_handler = &proc_dointvec
 156         },
 157         {
 158                 .ctl_name = 6,
 159                 .procname = "peer_credits",
 160                 .data     = &peer_credits,
 161                 .maxlen   = sizeof(int),
 162                 .mode     = 0444,
 163                 .proc_handler = &proc_dointvec
 164         },
 165         {
 166                 .ctl_name = 7,
 167                 .procname = "ipif_name",
 168                 .data     = ipif_basename_space,
 169                 .maxlen   = sizeof(ipif_basename_space),
 170                 .mode     = 0444,
 171                 .proc_handler = &proc_dostring
 172         },
 173         {
 174                 .ctl_name = 8,
 175                 .procname = "retry_count",
 176                 .data     = &retry_count,
 177                 .maxlen   = sizeof(int),
 178                 .mode     = 0644,
 179                 .proc_handler = &proc_dointvec
 180         },
 181         {
 182                 .ctl_name = 9,
 183                 .procname = "rnr_retry_count",
 184                 .data     = &rnr_retry_count,
 185                 .maxlen   = sizeof(int),
 186                 .mode     = 0644,
 187                 .proc_handler = &proc_dointvec
 188         },
 189         {
 190                 .ctl_name = 10,
 191                 .procname = "keepalive",
 192                 .data     = &keepalive,
 193                 .maxlen   = sizeof(int),
 194                 .mode     = 0644,
 195                 .proc_handler = &proc_dointvec
 196         },
 197         {
 198                 .ctl_name = 11,
 199                 .procname = "concurrent_sends",
 200                 .data     = &concurrent_sends,
 201                 .maxlen   = sizeof(int),
 202                 .mode     = 0644,
 203                 .proc_handler = &proc_dointvec
 204         },
 205         {
 206                 .ctl_name = 12,
 207                 .procname = "ib_mtu",
 208                 .data     = &ib_mtu,
 209                 .maxlen   = sizeof(int),
 210                 .mode     = 0444,
 211                 .proc_handler = &proc_dointvec
 212         },
 213 #if IBLND_MAP_ON_DEMAND
 214         {
 215                 .ctl_name = 13,
 216                 .procname = "fmr_pool_size",
 217                 .data     = &fmr_pool_size,
 218                 .maxlen   = sizeof(int),
 219                 .mode     = 0444,
 220                 .proc_handler = &proc_dointvec
 221         },
 222         {
 223                 .ctl_name = 14,
 224                 .procname = "fmr_flush_trigger",
 225                 .data     = &fmr_flush_trigger,
 226                 .maxlen   = sizeof(int),
 227                 .mode     = 0444,
 228                 .proc_handler = &proc_dointvec
 229         },
 230         {
 231                 .ctl_name = 15,
 232                 .procname = "fmr_cache",
 233                 .data     = &fmr_cache,
 234                 .maxlen   = sizeof(int),
 235                 .mode     = 0444,
 236                 .proc_handler = &proc_dointvec
 237         },
 238 #endif
 239         {0}
 240 };
 241
 242 static cfs_sysctl_table_t kiblnd_top_ctl_table[] = {
 243         {
 244                 .ctl_name = 203,
 245                 .procname = "o2iblnd",
 246                 .data     = NULL,
 247                 .maxlen   = 0,
 248                 .mode     = 0555,
 249                 .child    = kiblnd_ctl_table
 250         },
 251         {0}
 252 };
 253
 254 void
 255 kiblnd_initstrtunable(char *space, char *str, int size)
 256 {
 257         strncpy(space, str, size);
 258         space[size-1] = 0;
 259 }
 260
 261 void
 262 kiblnd_sysctl_init (void)
 263 {
 264         kiblnd_initstrtunable(ipif_basename_space, ipif_name,
 265                               sizeof(ipif_basename_space));
 266
 267         kiblnd_tunables.kib_sysctl =
 268                 cfs_register_sysctl_table(kiblnd_top_ctl_table, 0);
 269
 270         if (kiblnd_tunables.kib_sysctl == NULL)
 271                 CWARN("Can't setup /proc tunables\n");
 272 }
 273
 274 void
 275 kiblnd_sysctl_fini (void)
 276 {
 277         if (kiblnd_tunables.kib_sysctl != NULL)
 278                 cfs_unregister_sysctl_table(kiblnd_tunables.kib_sysctl);
 279 }
 280
 281 #else
 282
 283 void
 284 kiblnd_sysctl_init (void)
 285 {
 286 }
 287
 288 void
 289 kiblnd_sysctl_fini (void)
 290 {
 291 }
 292
 293 #endif
 294
 295 int
 296 kiblnd_tunables_init (void)
 297 {
 298         kiblnd_sysctl_init();
 299
 300         if (*kiblnd_tunables.kib_concurrent_sends > IBLND_RX_MSGS)
 301                 *kiblnd_tunables.kib_concurrent_sends = IBLND_RX_MSGS;
 302         if (*kiblnd_tunables.kib_concurrent_sends < IBLND_MSG_QUEUE_SIZE)
 303                 *kiblnd_tunables.kib_concurrent_sends = IBLND_MSG_QUEUE_SIZE;
 304
 305         return 0;
 306 }
 307
 308 void
 309 kiblnd_tunables_fini (void)
 310 {
 311         kiblnd_sysctl_fini();
 312 }
 313
 314
 315