fs/xfs/xfs_sysctl.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2001-2005 Silicon Graphics, Inc.
   4  * All Rights Reserved.
   5  */
   6 #include "xfs.h"
   7 #include "xfs_error.h"
   8
   9 static struct ctl_table_header *xfs_table_header;
  10
  11 #ifdef CONFIG_PROC_FS
  12 STATIC int
  13 xfs_stats_clear_proc_handler(
  14         struct ctl_table        *ctl,
  15         int                     write,
  16         void                    *buffer,
  17         size_t                  *lenp,
  18         loff_t                  *ppos)
  19 {
  20         int             ret, *valp = ctl->data;
  21
  22         ret = proc_dointvec_minmax(ctl, write, buffer, lenp, ppos);
  23
  24         if (!ret && write && *valp) {
  25                 xfs_stats_clearall(xfsstats.xs_stats);
  26                 xfs_stats_clear = 0;
  27         }
  28
  29         return ret;
  30 }
  31
  32 STATIC int
  33 xfs_panic_mask_proc_handler(
  34         struct ctl_table        *ctl,
  35         int                     write,
  36         void                    *buffer,
  37         size_t                  *lenp,
  38         loff_t                  *ppos)
  39 {
  40         int             ret, *valp = ctl->data;
  41
  42         ret = proc_dointvec_minmax(ctl, write, buffer, lenp, ppos);
  43         if (!ret && write) {
  44                 xfs_panic_mask = *valp;
  45 #ifdef DEBUG
  46                 xfs_panic_mask |= (XFS_PTAG_SHUTDOWN_CORRUPT | XFS_PTAG_LOGRES);
  47 #endif
  48         }
  49         return ret;
  50 }
  51 #endif /* CONFIG_PROC_FS */
  52
  53 STATIC int
  54 xfs_deprecated_dointvec_minmax(
  55         struct ctl_table        *ctl,
  56         int                     write,
  57         void                    *buffer,
  58         size_t                  *lenp,
  59         loff_t                  *ppos)
  60 {
  61         if (write) {
  62                 printk_ratelimited(KERN_WARNING
  63                                 "XFS: %s sysctl option is deprecated.\n",
  64                                 ctl->procname);
  65         }
  66         return proc_dointvec_minmax(ctl, write, buffer, lenp, ppos);
  67 }
  68
  69 static struct ctl_table xfs_table[] = {
  70         {
  71                 .procname       = "irix_sgid_inherit",
  72                 .data           = &xfs_params.sgid_inherit.val,
  73                 .maxlen         = sizeof(int),
  74                 .mode           = 0644,
  75                 .proc_handler   = xfs_deprecated_dointvec_minmax,
  76                 .extra1         = &xfs_params.sgid_inherit.min,
  77                 .extra2         = &xfs_params.sgid_inherit.max
  78         },
  79         {
  80                 .procname       = "irix_symlink_mode",
  81                 .data           = &xfs_params.symlink_mode.val,
  82                 .maxlen         = sizeof(int),
  83                 .mode           = 0644,
  84                 .proc_handler   = xfs_deprecated_dointvec_minmax,
  85                 .extra1         = &xfs_params.symlink_mode.min,
  86                 .extra2         = &xfs_params.symlink_mode.max
  87         },
  88         {
  89                 .procname       = "panic_mask",
  90                 .data           = &xfs_params.panic_mask.val,
  91                 .maxlen         = sizeof(int),
  92                 .mode           = 0644,
  93                 .proc_handler   = xfs_panic_mask_proc_handler,
  94                 .extra1         = &xfs_params.panic_mask.min,
  95                 .extra2         = &xfs_params.panic_mask.max
  96         },
  97
  98         {
  99                 .procname       = "error_level",
 100                 .data           = &xfs_params.error_level.val,
 101                 .maxlen         = sizeof(int),
 102                 .mode           = 0644,
 103                 .proc_handler   = proc_dointvec_minmax,
 104                 .extra1         = &xfs_params.error_level.min,
 105                 .extra2         = &xfs_params.error_level.max
 106         },
 107         {
 108                 .procname       = "xfssyncd_centisecs",
 109                 .data           = &xfs_params.syncd_timer.val,
 110                 .maxlen         = sizeof(int),
 111                 .mode           = 0644,
 112                 .proc_handler   = proc_dointvec_minmax,
 113                 .extra1         = &xfs_params.syncd_timer.min,
 114                 .extra2         = &xfs_params.syncd_timer.max
 115         },
 116         {
 117                 .procname       = "inherit_sync",
 118                 .data           = &xfs_params.inherit_sync.val,
 119                 .maxlen         = sizeof(int),
 120                 .mode           = 0644,
 121                 .proc_handler   = proc_dointvec_minmax,
 122                 .extra1         = &xfs_params.inherit_sync.min,
 123                 .extra2         = &xfs_params.inherit_sync.max
 124         },
 125         {
 126                 .procname       = "inherit_nodump",
 127                 .data           = &xfs_params.inherit_nodump.val,
 128                 .maxlen         = sizeof(int),
 129                 .mode           = 0644,
 130                 .proc_handler   = proc_dointvec_minmax,
 131                 .extra1         = &xfs_params.inherit_nodump.min,
 132                 .extra2         = &xfs_params.inherit_nodump.max
 133         },
 134         {
 135                 .procname       = "inherit_noatime",
 136                 .data           = &xfs_params.inherit_noatim.val,
 137                 .maxlen         = sizeof(int),
 138                 .mode           = 0644,
 139                 .proc_handler   = proc_dointvec_minmax,
 140                 .extra1         = &xfs_params.inherit_noatim.min,
 141                 .extra2         = &xfs_params.inherit_noatim.max
 142         },
 143         {
 144                 .procname       = "inherit_nosymlinks",
 145                 .data           = &xfs_params.inherit_nosym.val,
 146                 .maxlen         = sizeof(int),
 147                 .mode           = 0644,
 148                 .proc_handler   = proc_dointvec_minmax,
 149                 .extra1         = &xfs_params.inherit_nosym.min,
 150                 .extra2         = &xfs_params.inherit_nosym.max
 151         },
 152         {
 153                 .procname       = "rotorstep",
 154                 .data           = &xfs_params.rotorstep.val,
 155                 .maxlen         = sizeof(int),
 156                 .mode           = 0644,
 157                 .proc_handler   = proc_dointvec_minmax,
 158                 .extra1         = &xfs_params.rotorstep.min,
 159                 .extra2         = &xfs_params.rotorstep.max
 160         },
 161         {
 162                 .procname       = "inherit_nodefrag",
 163                 .data           = &xfs_params.inherit_nodfrg.val,
 164                 .maxlen         = sizeof(int),
 165                 .mode           = 0644,
 166                 .proc_handler   = proc_dointvec_minmax,
 167                 .extra1         = &xfs_params.inherit_nodfrg.min,
 168                 .extra2         = &xfs_params.inherit_nodfrg.max
 169         },
 170         {
 171                 .procname       = "filestream_centisecs",
 172                 .data           = &xfs_params.fstrm_timer.val,
 173                 .maxlen         = sizeof(int),
 174                 .mode           = 0644,
 175                 .proc_handler   = proc_dointvec_minmax,
 176                 .extra1         = &xfs_params.fstrm_timer.min,
 177                 .extra2         = &xfs_params.fstrm_timer.max,
 178         },
 179         {
 180                 .procname       = "speculative_prealloc_lifetime",
 181                 .data           = &xfs_params.blockgc_timer.val,
 182                 .maxlen         = sizeof(int),
 183                 .mode           = 0644,
 184                 .proc_handler   = proc_dointvec_minmax,
 185                 .extra1         = &xfs_params.blockgc_timer.min,
 186                 .extra2         = &xfs_params.blockgc_timer.max,
 187         },
 188         {
 189                 .procname       = "speculative_cow_prealloc_lifetime",
 190                 .data           = &xfs_params.blockgc_timer.val,
 191                 .maxlen         = sizeof(int),
 192                 .mode           = 0644,
 193                 .proc_handler   = xfs_deprecated_dointvec_minmax,
 194                 .extra1         = &xfs_params.blockgc_timer.min,
 195                 .extra2         = &xfs_params.blockgc_timer.max,
 196         },
 197         /* please keep this the last entry */
 198 #ifdef CONFIG_PROC_FS
 199         {
 200                 .procname       = "stats_clear",
 201                 .data           = &xfs_params.stats_clear.val,
 202                 .maxlen         = sizeof(int),
 203                 .mode           = 0644,
 204                 .proc_handler   = xfs_stats_clear_proc_handler,
 205                 .extra1         = &xfs_params.stats_clear.min,
 206                 .extra2         = &xfs_params.stats_clear.max
 207         },
 208 #endif /* CONFIG_PROC_FS */
 209
 210         {}
 211 };
 212
 213 static struct ctl_table xfs_dir_table[] = {
 214         {
 215                 .procname       = "xfs",
 216                 .mode           = 0555,
 217                 .child          = xfs_table
 218         },
 219         {}
 220 };
 221
 222 static struct ctl_table xfs_root_table[] = {
 223         {
 224                 .procname       = "fs",
 225                 .mode           = 0555,
 226                 .child          = xfs_dir_table
 227         },
 228         {}
 229 };
 230
 231 int
 232 xfs_sysctl_register(void)
 233 {
 234         xfs_table_header = register_sysctl_table(xfs_root_table);
 235         if (!xfs_table_header)
 236                 return -ENOMEM;
 237         return 0;
 238 }
 239
 240 void
 241 xfs_sysctl_unregister(void)
 242 {
 243         unregister_sysctl_table(xfs_table_header);
 244 }