Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
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_TWO ((void *)&sysctl_vals[2])
44#define SYSCTL_THREE ((void *)&sysctl_vals[3])
45#define SYSCTL_FOUR ((void *)&sysctl_vals[4])
46#define SYSCTL_ONE_HUNDRED ((void *)&sysctl_vals[5])
47#define SYSCTL_TWO_HUNDRED ((void *)&sysctl_vals[6])
48#define SYSCTL_ONE_THOUSAND ((void *)&sysctl_vals[7])
49#define SYSCTL_THREE_THOUSAND ((void *)&sysctl_vals[8])
50#define SYSCTL_INT_MAX ((void *)&sysctl_vals[9])
51
52/* this is needed for the proc_dointvec_minmax for [fs_]overflow UID and GID */
53#define SYSCTL_MAXOLDUID ((void *)&sysctl_vals[10])
54#define SYSCTL_NEG_ONE ((void *)&sysctl_vals[11])
55
56extern const int sysctl_vals[];
57
58#define SYSCTL_LONG_ZERO ((void *)&sysctl_long_vals[0])
59#define SYSCTL_LONG_ONE ((void *)&sysctl_long_vals[1])
60#define SYSCTL_LONG_MAX ((void *)&sysctl_long_vals[2])
61
62/**
63 *
64 * "dir" originates from read_iter (dir = 0) or write_iter (dir = 1)
65 * in the file_operations struct at proc/proc_sysctl.c. Its value means
66 * one of two things for sysctl:
67 * 1. SYSCTL_USER_TO_KERN(dir) Writing to an internal kernel variable from user
68 * space (dir > 0)
69 * 2. SYSCTL_KERN_TO_USER(dir) Writing to a user space buffer from a kernel
70 * variable (dir == 0).
71 */
72#define SYSCTL_USER_TO_KERN(dir) (!!(dir))
73#define SYSCTL_KERN_TO_USER(dir) (!dir)
74
75extern const unsigned long sysctl_long_vals[];
76
77typedef int proc_handler(const struct ctl_table *ctl, int write, void *buffer,
78 size_t *lenp, loff_t *ppos);
79
80int proc_dostring(const struct ctl_table *, int, void *, size_t *, loff_t *);
81int proc_dobool(const struct ctl_table *table, int write, void *buffer,
82 size_t *lenp, loff_t *ppos);
83
84int proc_dointvec(const struct ctl_table *, int, void *, size_t *, loff_t *);
85int proc_dointvec_minmax(const struct ctl_table *table, int dir, void *buffer,
86 size_t *lenp, loff_t *ppos);
87int proc_dointvec_conv(const struct ctl_table *table, int dir, void *buffer,
88 size_t *lenp, loff_t *ppos,
89 int (*conv)(bool *negp, unsigned long *u_ptr, int *k_ptr,
90 int dir, const struct ctl_table *table));
91int proc_int_k2u_conv_kop(ulong *u_ptr, const int *k_ptr, bool *negp,
92 ulong (*k_ptr_op)(const ulong));
93int proc_int_u2k_conv_uop(const ulong *u_ptr, int *k_ptr, const bool *negp,
94 ulong (*u_ptr_op)(const ulong));
95int proc_int_conv(bool *negp, ulong *u_ptr, int *k_ptr, int dir,
96 const struct ctl_table *tbl, bool k_ptr_range_check,
97 int (*user_to_kern)(const bool *negp, const ulong *u_ptr, int *k_ptr),
98 int (*kern_to_user)(bool *negp, ulong *u_ptr, const int *k_ptr));
99
100int proc_douintvec(const struct ctl_table *, int, void *, size_t *, loff_t *);
101int proc_douintvec_minmax(const struct ctl_table *table, int write, void *buffer,
102 size_t *lenp, loff_t *ppos);
103int proc_douintvec_conv(const struct ctl_table *table, int write, void *buffer,
104 size_t *lenp, loff_t *ppos,
105 int (*conv)(unsigned long *lvalp, unsigned int *valp,
106 int write, const struct ctl_table *table));
107int proc_uint_k2u_conv(ulong *u_ptr, const uint *k_ptr);
108int proc_uint_u2k_conv_uop(const ulong *u_ptr, uint *k_ptr,
109 ulong (*u_ptr_op)(const ulong));
110int proc_uint_conv(ulong *u_ptr, uint *k_ptr, int dir,
111 const struct ctl_table *tbl, bool k_ptr_range_check,
112 int (*user_to_kern)(const ulong *u_ptr, uint *k_ptr),
113 int (*kern_to_user)(ulong *u_ptr, const uint *k_ptr));
114
115int proc_dou8vec_minmax(const struct ctl_table *table, int write, void *buffer,
116 size_t *lenp, loff_t *ppos);
117int proc_doulongvec_minmax(const struct ctl_table *, int, void *, size_t *, loff_t *);
118int proc_doulongvec_minmax_conv(const struct ctl_table *table, int dir,
119 void *buffer, size_t *lenp, loff_t *ppos,
120 unsigned long convmul, unsigned long convdiv);
121int proc_do_large_bitmap(const struct ctl_table *, int, void *, size_t *, loff_t *);
122int proc_do_static_key(const struct ctl_table *table, int write, void *buffer,
123 size_t *lenp, loff_t *ppos);
124
125/*
126 * Register a set of sysctl names by calling register_sysctl
127 * with an initialised array of struct ctl_table's.
128 *
129 * sysctl names can be mirrored automatically under /proc/sys. The
130 * procname supplied controls /proc naming.
131 *
132 * The table's mode will be honoured for proc-fs access.
133 *
134 * Leaf nodes in the sysctl tree will be represented by a single file
135 * under /proc; non-leaf nodes will be represented by directories. A
136 * null procname disables /proc mirroring at this node.
137 *
138 * The data and maxlen fields of the ctl_table
139 * struct enable minimal validation of the values being written to be
140 * performed, and the mode field allows minimal authentication.
141 *
142 * There must be a proc_handler routine for any terminal nodes
143 * mirrored under /proc/sys (non-terminals are handled by a built-in
144 * directory handler). Several default handlers are available to
145 * cover common cases.
146 */
147
148/* Support for userspace poll() to watch for changes */
149struct ctl_table_poll {
150 atomic_t event;
151 wait_queue_head_t wait;
152};
153
154static inline void *proc_sys_poll_event(struct ctl_table_poll *poll)
155{
156 return (void *)(unsigned long)atomic_read(&poll->event);
157}
158
159#define __CTL_TABLE_POLL_INITIALIZER(name) { \
160 .event = ATOMIC_INIT(0), \
161 .wait = __WAIT_QUEUE_HEAD_INITIALIZER(name.wait) }
162
163#define DEFINE_CTL_TABLE_POLL(name) \
164 struct ctl_table_poll name = __CTL_TABLE_POLL_INITIALIZER(name)
165
166/* A sysctl table is an array of struct ctl_table: */
167struct ctl_table {
168 const char *procname; /* Text ID for /proc/sys */
169 void *data;
170 int maxlen;
171 umode_t mode;
172 proc_handler *proc_handler; /* Callback for text formatting */
173 struct ctl_table_poll *poll;
174 void *extra1;
175 void *extra2;
176} __randomize_layout;
177
178struct ctl_node {
179 struct rb_node node;
180 struct ctl_table_header *header;
181};
182
183/**
184 * struct ctl_table_header - maintains dynamic lists of struct ctl_table trees
185 * @ctl_table: pointer to the first element in ctl_table array
186 * @ctl_table_size: number of elements pointed by @ctl_table
187 * @used: The entry will never be touched when equal to 0.
188 * @count: Upped every time something is added to @inodes and downed every time
189 * something is removed from inodes
190 * @nreg: When nreg drops to 0 the ctl_table_header will be unregistered.
191 * @rcu: Delays the freeing of the inode. Introduced with "unfuck proc_sysctl ->d_compare()"
192 *
193 * @type: Enumeration to differentiate between ctl target types
194 * @type.SYSCTL_TABLE_TYPE_DEFAULT: ctl target with no special considerations
195 * @type.SYSCTL_TABLE_TYPE_PERMANENTLY_EMPTY: Identifies a permanently empty dir
196 * target to serve as a mount point
197 */
198struct ctl_table_header {
199 union {
200 struct {
201 const struct ctl_table *ctl_table;
202 int ctl_table_size;
203 int used;
204 int count;
205 int nreg;
206 };
207 struct rcu_head rcu;
208 };
209 struct completion *unregistering;
210 const struct ctl_table *ctl_table_arg;
211 struct ctl_table_root *root;
212 struct ctl_table_set *set;
213 struct ctl_dir *parent;
214 struct ctl_node *node;
215 struct hlist_head inodes; /* head for proc_inode->sysctl_inodes */
216 enum {
217 SYSCTL_TABLE_TYPE_DEFAULT,
218 SYSCTL_TABLE_TYPE_PERMANENTLY_EMPTY,
219 } type;
220};
221
222struct ctl_dir {
223 /* Header must be at the start of ctl_dir */
224 struct ctl_table_header header;
225 struct rb_root root;
226};
227
228struct ctl_table_set {
229 int (*is_seen)(struct ctl_table_set *);
230 struct ctl_dir dir;
231};
232
233struct ctl_table_root {
234 struct ctl_table_set default_set;
235 struct ctl_table_set *(*lookup)(struct ctl_table_root *root);
236 void (*set_ownership)(struct ctl_table_header *head,
237 kuid_t *uid, kgid_t *gid);
238 int (*permissions)(struct ctl_table_header *head, const struct ctl_table *table);
239};
240
241#define register_sysctl(path, table) \
242 register_sysctl_sz(path, table, ARRAY_SIZE(table))
243
244#ifdef CONFIG_SYSCTL
245
246void proc_sys_poll_notify(struct ctl_table_poll *poll);
247
248extern void setup_sysctl_set(struct ctl_table_set *p,
249 struct ctl_table_root *root,
250 int (*is_seen)(struct ctl_table_set *));
251extern void retire_sysctl_set(struct ctl_table_set *set);
252
253struct ctl_table_header *__register_sysctl_table(
254 struct ctl_table_set *set,
255 const char *path, const struct ctl_table *table, size_t table_size);
256struct ctl_table_header *register_sysctl_sz(const char *path, const struct ctl_table *table,
257 size_t table_size);
258void unregister_sysctl_table(struct ctl_table_header * table);
259
260extern int sysctl_init_bases(void);
261extern void __register_sysctl_init(const char *path, const struct ctl_table *table,
262 const char *table_name, size_t table_size);
263#define register_sysctl_init(path, table) \
264 __register_sysctl_init(path, table, #table, ARRAY_SIZE(table))
265extern struct ctl_table_header *register_sysctl_mount_point(const char *path);
266
267void do_sysctl_args(void);
268bool sysctl_is_alias(char *param);
269
270extern int unaligned_enabled;
271extern int no_unaligned_warning;
272
273#else /* CONFIG_SYSCTL */
274
275static inline void register_sysctl_init(const char *path, const struct ctl_table *table)
276{
277}
278
279static inline struct ctl_table_header *register_sysctl_mount_point(const char *path)
280{
281 return NULL;
282}
283
284static inline struct ctl_table_header *register_sysctl_sz(const char *path,
285 const struct ctl_table *table,
286 size_t table_size)
287{
288 return NULL;
289}
290
291static inline void unregister_sysctl_table(struct ctl_table_header * table)
292{
293}
294
295static inline void setup_sysctl_set(struct ctl_table_set *p,
296 struct ctl_table_root *root,
297 int (*is_seen)(struct ctl_table_set *))
298{
299}
300
301static inline void do_sysctl_args(void)
302{
303}
304
305static inline bool sysctl_is_alias(char *param)
306{
307 return false;
308}
309#endif /* CONFIG_SYSCTL */
310
311#endif /* _LINUX_SYSCTL_H */