LXR linux/include/linux/sysctl.h

   1/* SPDX-License-Identifier: GPL-2.0 */
   2/*
   3 * sysctl.h: General linux system control interface
   4 *
   5 * Begun 24 March 1995, Stephen Tweedie
   6 *
   7 ****************************************************************
   8 ****************************************************************
   9 **
  10 **  WARNING:
  11 **  The values in this file are exported to user space via 
  12 **  the sysctl() binary interface.  Do *NOT* change the
  13 **  numbering of any existing values here, and do not change
  14 **  any numbers within any one set of values.  If you have to
  15 **  redefine an existing interface, use a new number for it.
  16 **  The kernel will then return -ENOTDIR to any application using
  17 **  the old binary interface.
  18 **
  19 ****************************************************************
  20 ****************************************************************
  21 */
  22#ifndef _LINUX_SYSCTL_H
  23#define _LINUX_SYSCTL_H
  24
  25#include <linux/list.h>
  26#include <linux/rcupdate.h>
  27#include <linux/wait.h>
  28#include <linux/rbtree.h>
  29#include <linux/uidgid.h>
  30#include <uapi/linux/sysctl.h>
  31
  32/* For the /proc/sys support */
  33struct completion;
  34struct ctl_table;
  35struct nsproxy;
  36struct ctl_table_root;
  37struct ctl_table_header;
  38struct ctl_dir;
  39
  40/* Keep the same order as in fs/proc/proc_sysctl.c */
  41#define SYSCTL_ZERO     ((void *)&sysctl_vals[0])
  42#define SYSCTL_ONE      ((void *)&sysctl_vals[1])
  43#define SYSCTL_INT_MAX  ((void *)&sysctl_vals[2])
  44
  45extern const int sysctl_vals[];
  46
  47typedef int proc_handler (struct ctl_table *ctl, int write,
  48                          void __user *buffer, size_t *lenp, loff_t *ppos);
  49
  50extern int proc_dostring(struct ctl_table *, int,
  51                         void __user *, size_t *, loff_t *);
  52extern int proc_dointvec(struct ctl_table *, int,
  53                         void __user *, size_t *, loff_t *);
  54extern int proc_douintvec(struct ctl_table *, int,
  55                         void __user *, size_t *, loff_t *);
  56extern int proc_dointvec_minmax(struct ctl_table *, int,
  57                                void __user *, size_t *, loff_t *);
  58extern int proc_douintvec_minmax(struct ctl_table *table, int write,
  59                                 void __user *buffer, size_t *lenp,
  60                                 loff_t *ppos);
  61extern int proc_dointvec_jiffies(struct ctl_table *, int,
  62                                 void __user *, size_t *, loff_t *);
  63extern int proc_dointvec_userhz_jiffies(struct ctl_table *, int,
  64                                        void __user *, size_t *, loff_t *);
  65extern int proc_dointvec_ms_jiffies(struct ctl_table *, int,
  66                                    void __user *, size_t *, loff_t *);
  67extern int proc_doulongvec_minmax(struct ctl_table *, int,
  68                                  void __user *, size_t *, loff_t *);
  69extern int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int,
  70                                      void __user *, size_t *, loff_t *);
  71extern int proc_do_large_bitmap(struct ctl_table *, int,
  72                                void __user *, size_t *, loff_t *);
  73extern int proc_do_static_key(struct ctl_table *table, int write,
  74                              void __user *buffer, size_t *lenp,
  75                              loff_t *ppos);
  76
  77/*
  78 * Register a set of sysctl names by calling register_sysctl_table
  79 * with an initialised array of struct ctl_table's.  An entry with 
  80 * NULL procname terminates the table.  table->de will be
  81 * set up by the registration and need not be initialised in advance.
  82 *
  83 * sysctl names can be mirrored automatically under /proc/sys.  The
  84 * procname supplied controls /proc naming.
  85 *
  86 * The table's mode will be honoured both for sys_sysctl(2) and
  87 * proc-fs access.
  88 *
  89 * Leaf nodes in the sysctl tree will be represented by a single file
  90 * under /proc; non-leaf nodes will be represented by directories.  A
  91 * null procname disables /proc mirroring at this node.
  92 *
  93 * sysctl(2) can automatically manage read and write requests through
  94 * the sysctl table.  The data and maxlen fields of the ctl_table
  95 * struct enable minimal validation of the values being written to be
  96 * performed, and the mode field allows minimal authentication.
  97 * 
  98 * There must be a proc_handler routine for any terminal nodes
  99 * mirrored under /proc/sys (non-terminals are handled by a built-in
 100 * directory handler).  Several default handlers are available to
 101 * cover common cases.
 102 */
 103
 104/* Support for userspace poll() to watch for changes */
 105struct ctl_table_poll {
 106        atomic_t event;
 107        wait_queue_head_t wait;
 108};
 109
 110static inline void *proc_sys_poll_event(struct ctl_table_poll *poll)
 111{
 112        return (void *)(unsigned long)atomic_read(&poll->event);
 113}
 114
 115#define __CTL_TABLE_POLL_INITIALIZER(name) {                            \
 116        .event = ATOMIC_INIT(0),                                        \
 117        .wait = __WAIT_QUEUE_HEAD_INITIALIZER(name.wait) }
 118
 119#define DEFINE_CTL_TABLE_POLL(name)                                     \
 120        struct ctl_table_poll name = __CTL_TABLE_POLL_INITIALIZER(name)
 121
 122/* A sysctl table is an array of struct ctl_table: */
 123struct ctl_table 
 124{
 125        const char *procname;           /* Text ID for /proc/sys, or zero */
 126        void *data;
 127        int maxlen;
 128        umode_t mode;
 129        struct ctl_table *child;        /* Deprecated */
 130        proc_handler *proc_handler;     /* Callback for text formatting */
 131        struct ctl_table_poll *poll;
 132        void *extra1;
 133        void *extra2;
 134} __randomize_layout;
 135
 136struct ctl_node {
 137        struct rb_node node;
 138        struct ctl_table_header *header;
 139};
 140
 141/* struct ctl_table_header is used to maintain dynamic lists of
 142   struct ctl_table trees. */
 143struct ctl_table_header
 144{
 145        union {
 146                struct {
 147                        struct ctl_table *ctl_table;
 148                        int used;
 149                        int count;
 150                        int nreg;
 151                };
 152                struct rcu_head rcu;
 153        };
 154        struct completion *unregistering;
 155        struct ctl_table *ctl_table_arg;
 156        struct ctl_table_root *root;
 157        struct ctl_table_set *set;
 158        struct ctl_dir *parent;
 159        struct ctl_node *node;
 160        struct hlist_head inodes; /* head for proc_inode->sysctl_inodes */
 161};
 162
 163struct ctl_dir {
 164        /* Header must be at the start of ctl_dir */
 165        struct ctl_table_header header;
 166        struct rb_root root;
 167};
 168
 169struct ctl_table_set {
 170        int (*is_seen)(struct ctl_table_set *);
 171        struct ctl_dir dir;
 172};
 173
 174struct ctl_table_root {
 175        struct ctl_table_set default_set;
 176        struct ctl_table_set *(*lookup)(struct ctl_table_root *root);
 177        void (*set_ownership)(struct ctl_table_header *head,
 178                              struct ctl_table *table,
 179                              kuid_t *uid, kgid_t *gid);
 180        int (*permissions)(struct ctl_table_header *head, struct ctl_table *table);
 181};
 182
 183/* struct ctl_path describes where in the hierarchy a table is added */
 184struct ctl_path {
 185        const char *procname;
 186};
 187
 188#ifdef CONFIG_SYSCTL
 189
 190void proc_sys_poll_notify(struct ctl_table_poll *poll);
 191
 192extern void setup_sysctl_set(struct ctl_table_set *p,
 193        struct ctl_table_root *root,
 194        int (*is_seen)(struct ctl_table_set *));
 195extern void retire_sysctl_set(struct ctl_table_set *set);
 196
 197struct ctl_table_header *__register_sysctl_table(
 198        struct ctl_table_set *set,
 199        const char *path, struct ctl_table *table);
 200struct ctl_table_header *__register_sysctl_paths(
 201        struct ctl_table_set *set,
 202        const struct ctl_path *path, struct ctl_table *table);
 203struct ctl_table_header *register_sysctl(const char *path, struct ctl_table *table);
 204struct ctl_table_header *register_sysctl_table(struct ctl_table * table);
 205struct ctl_table_header *register_sysctl_paths(const struct ctl_path *path,
 206                                                struct ctl_table *table);
 207
 208void unregister_sysctl_table(struct ctl_table_header * table);
 209
 210extern int sysctl_init(void);
 211
 212extern struct ctl_table sysctl_mount_point[];
 213
 214#else /* CONFIG_SYSCTL */
 215static inline struct ctl_table_header *register_sysctl_table(struct ctl_table * table)
 216{
 217        return NULL;
 218}
 219
 220static inline struct ctl_table_header *register_sysctl_paths(
 221                        const struct ctl_path *path, struct ctl_table *table)
 222{
 223        return NULL;
 224}
 225
 226static inline struct ctl_table_header *register_sysctl(const char *path, struct ctl_table *table)
 227{
 228        return NULL;
 229}
 230
 231static inline void unregister_sysctl_table(struct ctl_table_header * table)
 232{
 233}
 234
 235static inline void setup_sysctl_set(struct ctl_table_set *p,
 236        struct ctl_table_root *root,
 237        int (*is_seen)(struct ctl_table_set *))
 238{
 239}
 240
 241#endif /* CONFIG_SYSCTL */
 242
 243int sysctl_max_threads(struct ctl_table *table, int write,
 244                       void __user *buffer, size_t *lenp, loff_t *ppos);
 245
 246#endif /* _LINUX_SYSCTL_H */
 247