lustre/obdclass/linux/linux-sysctl.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  * GPL HEADER START
   5  *
   6  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 only,
  10  * as published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License version 2 for more details (a copy is included
  16  * in the LICENSE file that accompanied this code).
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * version 2 along with this program; If not, see
  20  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
  21  *
  22  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  23  * CA 95054 USA or visit www.sun.com if you need additional information or
  24  * have any questions.
  25  *
  26  * GPL HEADER END
  27  */
  28 /*
  29  * Copyright  2008 Sun Microsystems, Inc. All rights reserved
  30  * Use is subject to license terms.
  31  */
  32 /*
  33  * This file is part of Lustre, http://www.lustre.org/
  34  * Lustre is a trademark of Sun Microsystems, Inc.
  35  */
  36
  37 #include <linux/module.h>
  38 #include <linux/autoconf.h>
  39 #include <linux/sysctl.h>
  40 #include <linux/sched.h>
  41 #include <linux/mm.h>
  42 #include <linux/sysctl.h>
  43 #include <linux/version.h>
  44 #include <linux/proc_fs.h>
  45 #include <linux/slab.h>
  46 #include <linux/stat.h>
  47 #include <linux/ctype.h>
  48 #include <asm/bitops.h>
  49 #include <asm/uaccess.h>
  50 #include <linux/utsname.h>
  51
  52 #define DEBUG_SUBSYSTEM S_CLASS
  53
  54 #include <obd_support.h>
  55 #include <lprocfs_status.h>
  56
  57 cfs_sysctl_table_header_t *obd_table_header = NULL;
  58
  59 #define OBD_SYSCTL 300
  60
  61 enum {
  62         OBD_FAIL_LOC = 1,       /* control test failures instrumentation */
  63         OBD_FAIL_VAL,           /* userdata for fail loc */
  64         OBD_TIMEOUT,            /* RPC timeout before recovery/intr */
  65         OBD_DUMP_ON_TIMEOUT,    /* dump kernel debug log upon eviction */
  66         OBD_MEMUSED,            /* bytes currently OBD_ALLOCated */
  67         OBD_PAGESUSED,          /* pages currently OBD_PAGE_ALLOCated */
  68         OBD_MAXMEMUSED,         /* maximum bytes OBD_ALLOCated concurrently */
  69         OBD_MAXPAGESUSED,       /* maximum pages OBD_PAGE_ALLOCated concurrently */
  70         OBD_SYNCFILTER,         /* XXX temporary, as we play with sync osts.. */
  71         OBD_LDLM_TIMEOUT,       /* LDLM timeout for ASTs before client eviction */
  72         OBD_DUMP_ON_EVICTION,   /* dump kernel debug log upon eviction */
  73         OBD_DEBUG_PEER_ON_TIMEOUT, /* dump peer debug when RPC times out */
  74         OBD_ALLOC_FAIL_RATE,    /* memory allocation random failure rate */
  75         OBD_MAX_DIRTY_PAGES,    /* maximum dirty pages */
  76 };
  77
  78 int LL_PROC_PROTO(proc_fail_loc)
  79 {
  80         int rc;
  81         long old_fail_loc = obd_fail_loc;
  82
  83         rc = ll_proc_dointvec(table, write, filp, buffer, lenp, ppos);
  84         if (old_fail_loc != obd_fail_loc)
  85                 wake_up(&obd_race_waitq);
  86         return rc;
  87 }
  88
  89 int LL_PROC_PROTO(proc_set_timeout)
  90 {
  91         int rc;
  92
  93         rc = ll_proc_dointvec(table, write, filp, buffer, lenp, ppos);
  94         if (ldlm_timeout >= obd_timeout)
  95                 ldlm_timeout = max(obd_timeout / 3, 1U);
  96         return rc;
  97 }
  98
  99 int LL_PROC_PROTO(proc_memory_alloc)
 100 {
 101         char buf[22];
 102         int len;
 103         DECLARE_LL_PROC_PPOS_DECL;
 104
 105         if (!*lenp || (*ppos && !write)) {
 106                 *lenp = 0;
 107                 return 0;
 108         }
 109         if (write)
 110                 return -EINVAL;
 111
 112         len = snprintf(buf, sizeof(buf), LPU64"\n", obd_memory_sum());
 113         if (len > *lenp)
 114                 len = *lenp;
 115         buf[len] = '\0';
 116         if (copy_to_user(buffer, buf, len))
 117                 return -EFAULT;
 118         *lenp = len;
 119         *ppos += *lenp;
 120         return 0;
 121 }
 122
 123 int LL_PROC_PROTO(proc_pages_alloc)
 124 {
 125         char buf[22];
 126         int len;
 127         DECLARE_LL_PROC_PPOS_DECL;
 128
 129         if (!*lenp || (*ppos && !write)) {
 130                 *lenp = 0;
 131                 return 0;
 132         }
 133         if (write)
 134                 return -EINVAL;
 135
 136         len = snprintf(buf, sizeof(buf), LPU64"\n", obd_pages_sum());
 137         if (len > *lenp)
 138                 len = *lenp;
 139         buf[len] = '\0';
 140         if (copy_to_user(buffer, buf, len))
 141                 return -EFAULT;
 142         *lenp = len;
 143         *ppos += *lenp;
 144         return 0;
 145 }
 146
 147 int LL_PROC_PROTO(proc_mem_max)
 148 {
 149         char buf[22];
 150         int len;
 151         DECLARE_LL_PROC_PPOS_DECL;
 152
 153         if (!*lenp || (*ppos && !write)) {
 154                 *lenp = 0;
 155                 return 0;
 156         }
 157         if (write)
 158                 return -EINVAL;
 159
 160         len = snprintf(buf, sizeof(buf), LPU64"\n", obd_memory_max());
 161         if (len > *lenp)
 162                 len = *lenp;
 163         buf[len] = '\0';
 164         if (copy_to_user(buffer, buf, len))
 165                 return -EFAULT;
 166         *lenp = len;
 167         *ppos += *lenp;
 168         return 0;
 169 }
 170
 171 int LL_PROC_PROTO(proc_pages_max)
 172 {
 173         char buf[22];
 174         int len;
 175         DECLARE_LL_PROC_PPOS_DECL;
 176
 177         if (!*lenp || (*ppos && !write)) {
 178                 *lenp = 0;
 179                 return 0;
 180         }
 181         if (write)
 182                 return -EINVAL;
 183
 184         len = snprintf(buf, sizeof(buf), LPU64"\n", obd_pages_max());
 185         if (len > *lenp)
 186                 len = *lenp;
 187         buf[len] = '\0';
 188         if (copy_to_user(buffer, buf, len))
 189                 return -EFAULT;
 190         *lenp = len;
 191         *ppos += *lenp;
 192         return 0;
 193 }
 194
 195 int LL_PROC_PROTO(proc_max_dirty_pages_in_mb)
 196 {
 197         int rc = 0;
 198         DECLARE_LL_PROC_PPOS_DECL;
 199
 200         if (!table->data || !table->maxlen || !*lenp || (*ppos && !write)) {
 201                 *lenp = 0;
 202                 return 0;
 203         }
 204         if (write) {
 205                 rc = lprocfs_write_frac_helper(buffer, *lenp,
 206                                                (unsigned int*)table->data,
 207                                                1 << (20 - CFS_PAGE_SHIFT));
 208                 /* Don't allow them to let dirty pages exceed 90% of system memory,
 209                  * and set a hard minimum of 4MB. */
 210                 if (obd_max_dirty_pages > ((num_physpages / 10) * 9)) {
 211                         CERROR("Refusing to set max dirty pages to %u, which "
 212                                "is more than 90%% of available RAM; setting to %lu\n",
 213                                obd_max_dirty_pages, ((num_physpages / 10) * 9));
 214                         obd_max_dirty_pages = ((num_physpages / 10) * 9);
 215                 } else if (obd_max_dirty_pages < 4 << (20 - CFS_PAGE_SHIFT)) {
 216                         obd_max_dirty_pages = 4 << (20 - CFS_PAGE_SHIFT);
 217                 }
 218         } else {
 219                 char buf[21];
 220                 int len;
 221
 222                 len = lprocfs_read_frac_helper(buf, sizeof(buf),
 223                                                *(unsigned int*)table->data,
 224                                                1 << (20 - CFS_PAGE_SHIFT));
 225                 if (len > *lenp)
 226                         len = *lenp;
 227                 buf[len] = '\0';
 228                 if (copy_to_user(buffer, buf, len))
 229                         return -EFAULT;
 230                 *lenp = len;
 231         }
 232         *ppos += *lenp;
 233         return rc;
 234 }
 235
 236 #ifdef RANDOM_FAIL_ALLOC
 237 int LL_PROC_PROTO(proc_alloc_fail_rate)
 238 {
 239         int rc          = 0;
 240         DECLARE_LL_PROC_PPOS_DECL;
 241
 242         if (!table->data || !table->maxlen || !*lenp || (*ppos && !write)) {
 243                 *lenp = 0;
 244                 return 0;
 245         }
 246         if (write) {
 247                 rc = lprocfs_write_frac_helper(buffer, *lenp,
 248                                                (unsigned int*)table->data,
 249                                                OBD_ALLOC_FAIL_MULT);
 250         } else {
 251                 char buf[21];
 252                 int  len;
 253
 254                 len = lprocfs_read_frac_helper(buf, 21,
 255                                                *(unsigned int*)table->data,
 256                                                OBD_ALLOC_FAIL_MULT);
 257                 if (len > *lenp)
 258                         len = *lenp;
 259                 buf[len] = '\0';
 260                 if (copy_to_user(buffer, buf, len))
 261                         return -EFAULT;
 262                 *lenp = len;
 263         }
 264         *ppos += *lenp;
 265         return rc;
 266 }
 267 #endif
 268
 269 static cfs_sysctl_table_t obd_table[] = {
 270         {
 271                 .ctl_name = OBD_FAIL_LOC,
 272                 .procname = "fail_loc",
 273                 .data     = &obd_fail_loc,
 274                 .maxlen   = sizeof(int),
 275                 .mode     = 0644,
 276                 .proc_handler = &proc_fail_loc
 277         },
 278         {
 279                 .ctl_name = OBD_FAIL_VAL,
 280                 .procname = "fail_val",
 281                 .data     = &obd_fail_val,
 282                 .maxlen   = sizeof(int),
 283                 .mode     = 0644,
 284                 .proc_handler = &proc_dointvec
 285         },
 286         {
 287                 .ctl_name = OBD_TIMEOUT,
 288                 .procname = "timeout",
 289                 .data     = &obd_timeout,
 290                 .maxlen   = sizeof(int),
 291                 .mode     = 0644,
 292                 .proc_handler = &proc_set_timeout
 293         },
 294         {
 295                 .ctl_name = OBD_DEBUG_PEER_ON_TIMEOUT,
 296                 .procname = "debug_peer_on_timeout",
 297                 .data     = &obd_debug_peer_on_timeout,
 298                 .maxlen   = sizeof(int),
 299                 .mode     = 0644,
 300                 .proc_handler = &proc_dointvec
 301         },
 302         {
 303                 .ctl_name = OBD_DUMP_ON_TIMEOUT,
 304                 .procname = "dump_on_timeout",
 305                 .data     = &obd_dump_on_timeout,
 306                 .maxlen   = sizeof(int),
 307                 .mode     = 0644,
 308                 .proc_handler = &proc_dointvec
 309         },
 310         {
 311                 .ctl_name = OBD_DUMP_ON_EVICTION,
 312                 .procname = "dump_on_eviction",
 313                 .data     = &obd_dump_on_eviction,
 314                 .maxlen   = sizeof(int),
 315                 .mode     = 0644,
 316                 .proc_handler = &proc_dointvec
 317         },
 318         {
 319                 .ctl_name = OBD_MEMUSED,
 320                 .procname = "memused",
 321                 .data     = NULL,
 322                 .maxlen   = 0,
 323                 .mode     = 0444,
 324                 .proc_handler = &proc_memory_alloc
 325         },
 326         {
 327                 .ctl_name = OBD_PAGESUSED,
 328                 .procname = "pagesused",
 329                 .data     = NULL,
 330                 .maxlen   = 0,
 331                 .mode     = 0444,
 332                 .proc_handler = &proc_pages_alloc
 333         },
 334         {
 335                 .ctl_name = OBD_MAXMEMUSED,
 336                 .procname = "memused_max",
 337                 .data     = NULL,
 338                 .maxlen   = 0,
 339                 .mode     = 0444,
 340                 .proc_handler = &proc_mem_max
 341         },
 342         {
 343                 .ctl_name = OBD_MAXPAGESUSED,
 344                 .procname = "pagesused_max",
 345                 .data     = NULL,
 346                 .maxlen   = 0,
 347                 .mode     = 0444,
 348                 .proc_handler = &proc_pages_max
 349         },
 350         {
 351                 .ctl_name = OBD_LDLM_TIMEOUT,
 352                 .procname = "ldlm_timeout",
 353                 .data     = &ldlm_timeout,
 354                 .maxlen   = sizeof(int),
 355                 .mode     = 0644,
 356                 .proc_handler = &proc_set_timeout
 357         },
 358 #ifdef RANDOM_FAIL_ALLOC
 359         {
 360                 .ctl_name = OBD_ALLOC_FAIL_RATE,
 361                 .procname = "alloc_fail_rate",
 362                 .data     = &obd_alloc_fail_rate,
 363                 .maxlen   = sizeof(int),
 364                 .mode     = 0644,
 365                 .proc_handler = &proc_alloc_fail_rate
 366         },
 367 #endif
 368         {
 369                 .ctl_name = OBD_MAX_DIRTY_PAGES,
 370                 .procname = "max_dirty_mb",
 371                 .data     = &obd_max_dirty_pages,
 372                 .maxlen   = sizeof(int),
 373                 .mode     = 0644,
 374                 .proc_handler = &proc_max_dirty_pages_in_mb
 375         },
 376         { 0 }
 377 };
 378
 379 static cfs_sysctl_table_t parent_table[] = {
 380         {
 381                 .ctl_name = OBD_SYSCTL,
 382                 .procname = "lustre",
 383                 .data     = NULL,
 384                 .maxlen   = 0,
 385                 .mode     = 0555,
 386                 .child    = obd_table
 387         },
 388         {0}
 389 };
 390
 391 void obd_sysctl_init (void)
 392 {
 393 #ifdef CONFIG_SYSCTL
 394         if ( !obd_table_header )
 395                 obd_table_header = cfs_register_sysctl_table(parent_table, 0);
 396 #endif
 397 }
 398
 399 void obd_sysctl_clean (void)
 400 {
 401 #ifdef CONFIG_SYSCTL
 402         if ( obd_table_header )
 403                 cfs_unregister_sysctl_table(obd_table_header);
 404         obd_table_header = NULL;
 405 #endif
 406 }