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