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