lnet/klnds/openiblnd/openiblnd_modparams.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  * Copyright (C) 2004 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 "openiblnd.h"
  25
  26 static char *ipif_basename = "ib";
  27 CFS_MODULE_PARM(ipif_basename, "s", charp, 0444,
  28                 "IPoIB interface base name");
  29
  30 static int n_connd = 4;
  31 CFS_MODULE_PARM(n_connd, "i", int, 0444,
  32                 "# of connection daemons");
  33
  34 static int min_reconnect_interval = 1;
  35 CFS_MODULE_PARM(min_reconnect_interval, "i", int, 0644,
  36                 "minimum connection retry interval (seconds)");
  37
  38 static int max_reconnect_interval = 60;
  39 CFS_MODULE_PARM(max_reconnect_interval, "i", int, 0644,
  40                 "maximum connection retry interval (seconds)");
  41
  42 static int concurrent_peers = 1152;
  43 CFS_MODULE_PARM(concurrent_peers, "i", int, 0444,
  44                 "maximum number of peers that may connect");
  45
  46 static int cksum = 0;
  47 CFS_MODULE_PARM(cksum, "i", int, 0644,
  48                 "set non-zero to enable message (not RDMA) checksums");
  49
  50 static int timeout = 50;
  51 CFS_MODULE_PARM(timeout, "i", int, 0644,
  52                 "timeout (seconds)");
  53
  54 static int ntx = 384;
  55 CFS_MODULE_PARM(ntx, "i", int, 0444,
  56                 "# of message descriptors");
  57
  58 static int credits = 256;
  59 CFS_MODULE_PARM(credits, "i", int, 0444,
  60                 "# concurrent sends");
  61
  62 static int peer_credits = 16;
  63 CFS_MODULE_PARM(peer_credits, "i", int, 0444,
  64                 "# concurrent sends to 1 peer");
  65
  66 static int keepalive = 100;
  67 CFS_MODULE_PARM(keepalive, "i", int, 0644,
  68                 "Idle time in seconds before sending a keepalive");
  69
  70 kib_tunables_t kibnal_tunables = {
  71         .kib_ipif_basename          = &ipif_basename,
  72         .kib_n_connd                = &n_connd,
  73         .kib_min_reconnect_interval = &min_reconnect_interval,
  74         .kib_max_reconnect_interval = &max_reconnect_interval,
  75         .kib_concurrent_peers       = &concurrent_peers,
  76         .kib_cksum                  = &cksum,
  77         .kib_timeout                = &timeout,
  78         .kib_ntx                    = &ntx,
  79         .kib_credits                = &credits,
  80         .kib_peercredits            = &peer_credits,
  81         .kib_keepalive              = &keepalive,
  82 };
  83
  84 #if defined(CONFIG_SYSCTL) && !CFS_SYSFS_MODULE_PARM
  85
  86 static cfs_sysctl_table_t kibnal_ctl_table[] = {
  87         {
  88                 .ctl_name = 1,
  89                 .procname = "ipif_basename",
  90                 .data     = &ipif_basename,
  91                 .maxlen   = 1024,
  92                 .mode     = 0444,
  93                 .proc_handler = &proc_dostring
  94         },
  95         {
  96                 .ctl_name = 2,
  97                 .procname = "n_connd",
  98                 .data     = &n_connd,
  99                 .maxlen   = sizeof(int),
 100                 .mode     = 0444,
 101                 .proc_handler = &proc_dointvec
 102         },
 103         {
 104                 .ctl_name = 3,
 105                 .procname = "min_reconnect_interval",
 106                 .data     = &min_reconnect_interval,
 107                 .maxlen   = sizeof(int),
 108                 .mode     = 0644,
 109                 .proc_handler = &proc_dointvec
 110         },
 111         {
 112                 .ctl_name = 4,
 113                 .procname = "max_reconnect_interval",
 114                 .data     = &max_reconnect_interval,
 115                 .maxlen   = sizeof(int),
 116                 .mode     = 0644,
 117                 .proc_handler = &proc_dointvec
 118         },
 119         {
 120                 .ctl_name = 5,
 121                 .procname = "concurrent_peers",
 122                 .data     = &concurrent_peers,
 123                 .maxlen   = sizeof(int),
 124                 .mode     = 0444,
 125                 .proc_handler = &proc_dointvec
 126         },
 127         {
 128                 .ctl_name = 6,
 129                 .procname = "cksum",
 130                 .data     = &cksum,
 131                 .maxlen   = sizeof(int),
 132                 .mode     = 0644,
 133                 .proc_handler = &proc_dointvec
 134         },
 135         {
 136                 .ctl_name = 7,
 137                 .procname = "timeout",
 138                 .data     = &timeout,
 139                 .maxlen   = sizeof(int),
 140                 .mode     = 0644,
 141                 .proc_handler = &proc_dointvec
 142         },
 143         {
 144                 .ctl_name = 8,
 145                 .procname = "ntx",
 146                 .data     = &ntx,
 147                 .maxlen   = sizeof(int),
 148                 .mode     = 0444,
 149                 .proc_handler = &proc_dointvec
 150         },
 151         {
 152                 .ctl_name = 9,
 153                 .procname = "credits",
 154                 .data     = &credits,
 155                 .maxlen   = sizeof(int),
 156                 .mode     = 0444,
 157                 .proc_handler = &proc_dointvec
 158         },
 159         {
 160                 .ctl_name = 10,
 161                 .procname = "peer_credits",
 162                 .data     = &peer_credits,
 163                 .maxlen   = sizeof(int),
 164                 .mode     = 0444,
 165                 .proc_handler = &proc_dointvec
 166         },
 167         {
 168                 .ctl_name = 11,
 169                 .procname = "keepalive",
 170                 .data     = &keepalive,
 171                 .maxlen   = sizeof(int),
 172                 .mode     = 0644,
 173                 .proc_handler = &proc_dointvec
 174         },
 175         {0}
 176 };
 177
 178 static cfs_sysctl_table_t kibnal_top_ctl_table[] = {
 179         {
 180                 .ctl_name = 203,
 181                 .procname = "openibnal",
 182                 .data     = NULL,
 183                 .maxlen   = 0,
 184                 .mode     = 0555,
 185                 .child    = kibnal_ctl_table
 186         },
 187         {0}
 188 };
 189
 190 int
 191 kibnal_tunables_init ()
 192 {
 193         kibnal_tunables.kib_sysctl =
 194                 cfs_register_sysctl_table(kibnal_top_ctl_table, 0);
 195
 196         if (kibnal_tunables.kib_sysctl == NULL)
 197                 CWARN("Can't setup /proc tunables\n");
 198
 199         return 0;
 200 }
 201
 202 void
 203 kibnal_tunables_fini ()
 204 {
 205         if (kibnal_tunables.kib_sysctl != NULL)
 206                 cfs_unregister_sysctl_table(kibnal_tunables.kib_sysctl);
 207 }
 208
 209 #else
 210
 211 int
 212 kibnal_tunables_init ()
 213 {
 214         return 0;
 215 }
 216
 217 void
 218 kibnal_tunables_fini ()
 219 {
 220 }
 221
 222 #endif