Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 7dc05881b64792e0ea41293e9595cc962a716225

Authored by Eric W. Biederman
1 parent c9235f4872
Exists in smarc-l5.0.0_1.0.0-ga and in 5 other branches imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga

userns: Convert debugfs to use kuid/kgid where appropriate. 

Acked-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Acked-by: Serge Hallyn <serge.hallyn@canonical.com>
Signed-off-by: Eric W. Biederman <ebiederm@xmission.com>

Showing 2 changed files with 18 additions and 9 deletions Inline Diff

1 /* 1 /*
2 * inode.c - part of debugfs, a tiny little debug file system 2 * inode.c - part of debugfs, a tiny little debug file system
3 * 3 *
4 * Copyright (C) 2004 Greg Kroah-Hartman <greg@kroah.com> 4 * Copyright (C) 2004 Greg Kroah-Hartman <greg@kroah.com>
5 * Copyright (C) 2004 IBM Inc. 5 * Copyright (C) 2004 IBM Inc.
6 * 6 *
7 * This program is free software; you can redistribute it and/or 7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License version 8 * modify it under the terms of the GNU General Public License version
9 * 2 as published by the Free Software Foundation. 9 * 2 as published by the Free Software Foundation.
10 * 10 *
11 * debugfs is for people to use instead of /proc or /sys. 11 * debugfs is for people to use instead of /proc or /sys.
12 * See Documentation/DocBook/kernel-api for more details. 12 * See Documentation/DocBook/kernel-api for more details.
13 * 13 *
14 */ 14 */
15 15
16 #include <linux/module.h> 16 #include <linux/module.h>
17 #include <linux/fs.h> 17 #include <linux/fs.h>
18 #include <linux/mount.h> 18 #include <linux/mount.h>
19 #include <linux/pagemap.h> 19 #include <linux/pagemap.h>
20 #include <linux/init.h> 20 #include <linux/init.h>
21 #include <linux/kobject.h> 21 #include <linux/kobject.h>
22 #include <linux/namei.h> 22 #include <linux/namei.h>
23 #include <linux/debugfs.h> 23 #include <linux/debugfs.h>
24 #include <linux/fsnotify.h> 24 #include <linux/fsnotify.h>
25 #include <linux/string.h> 25 #include <linux/string.h>
26 #include <linux/seq_file.h> 26 #include <linux/seq_file.h>
27 #include <linux/parser.h> 27 #include <linux/parser.h>
28 #include <linux/magic.h> 28 #include <linux/magic.h>
29 #include <linux/slab.h> 29 #include <linux/slab.h>
30 30
31 #define DEBUGFS_DEFAULT_MODE 0755 31 #define DEBUGFS_DEFAULT_MODE 0755
32 32
33 static struct vfsmount *debugfs_mount; 33 static struct vfsmount *debugfs_mount;
34 static int debugfs_mount_count; 34 static int debugfs_mount_count;
35 static bool debugfs_registered; 35 static bool debugfs_registered;
36 36
37 static struct inode *debugfs_get_inode(struct super_block *sb, umode_t mode, dev_t dev, 37 static struct inode *debugfs_get_inode(struct super_block *sb, umode_t mode, dev_t dev,
38 void *data, const struct file_operations *fops) 38 void *data, const struct file_operations *fops)
39 39
40 { 40 {
41 struct inode *inode = new_inode(sb); 41 struct inode *inode = new_inode(sb);
42 42
43 if (inode) { 43 if (inode) {
44 inode->i_ino = get_next_ino(); 44 inode->i_ino = get_next_ino();
45 inode->i_mode = mode; 45 inode->i_mode = mode;
46 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME; 46 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
47 switch (mode & S_IFMT) { 47 switch (mode & S_IFMT) {
48 default: 48 default:
49 init_special_inode(inode, mode, dev); 49 init_special_inode(inode, mode, dev);
50 break; 50 break;
51 case S_IFREG: 51 case S_IFREG:
52 inode->i_fop = fops ? fops : &debugfs_file_operations; 52 inode->i_fop = fops ? fops : &debugfs_file_operations;
53 inode->i_private = data; 53 inode->i_private = data;
54 break; 54 break;
55 case S_IFLNK: 55 case S_IFLNK:
56 inode->i_op = &debugfs_link_operations; 56 inode->i_op = &debugfs_link_operations;
57 inode->i_private = data; 57 inode->i_private = data;
58 break; 58 break;
59 case S_IFDIR: 59 case S_IFDIR:
60 inode->i_op = &simple_dir_inode_operations; 60 inode->i_op = &simple_dir_inode_operations;
61 inode->i_fop = &simple_dir_operations; 61 inode->i_fop = &simple_dir_operations;
62 inode->i_private = NULL; 62 inode->i_private = NULL;
63 63
64 /* directory inodes start off with i_nlink == 2 64 /* directory inodes start off with i_nlink == 2
65 * (for "." entry) */ 65 * (for "." entry) */
66 inc_nlink(inode); 66 inc_nlink(inode);
67 break; 67 break;
68 } 68 }
69 } 69 }
70 return inode; 70 return inode;
71 } 71 }
72 72
73 /* SMP-safe */ 73 /* SMP-safe */
74 static int debugfs_mknod(struct inode *dir, struct dentry *dentry, 74 static int debugfs_mknod(struct inode *dir, struct dentry *dentry,
75 umode_t mode, dev_t dev, void *data, 75 umode_t mode, dev_t dev, void *data,
76 const struct file_operations *fops) 76 const struct file_operations *fops)
77 { 77 {
78 struct inode *inode; 78 struct inode *inode;
79 int error = -EPERM; 79 int error = -EPERM;
80 80
81 if (dentry->d_inode) 81 if (dentry->d_inode)
82 return -EEXIST; 82 return -EEXIST;
83 83
84 inode = debugfs_get_inode(dir->i_sb, mode, dev, data, fops); 84 inode = debugfs_get_inode(dir->i_sb, mode, dev, data, fops);
85 if (inode) { 85 if (inode) {
86 d_instantiate(dentry, inode); 86 d_instantiate(dentry, inode);
87 dget(dentry); 87 dget(dentry);
88 error = 0; 88 error = 0;
89 } 89 }
90 return error; 90 return error;
91 } 91 }
92 92
93 static int debugfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode) 93 static int debugfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
94 { 94 {
95 int res; 95 int res;
96 96
97 mode = (mode & (S_IRWXUGO | S_ISVTX)) | S_IFDIR; 97 mode = (mode & (S_IRWXUGO | S_ISVTX)) | S_IFDIR;
98 res = debugfs_mknod(dir, dentry, mode, 0, NULL, NULL); 98 res = debugfs_mknod(dir, dentry, mode, 0, NULL, NULL);
99 if (!res) { 99 if (!res) {
100 inc_nlink(dir); 100 inc_nlink(dir);
101 fsnotify_mkdir(dir, dentry); 101 fsnotify_mkdir(dir, dentry);
102 } 102 }
103 return res; 103 return res;
104 } 104 }
105 105
106 static int debugfs_link(struct inode *dir, struct dentry *dentry, umode_t mode, 106 static int debugfs_link(struct inode *dir, struct dentry *dentry, umode_t mode,
107 void *data) 107 void *data)
108 { 108 {
109 mode = (mode & S_IALLUGO) | S_IFLNK; 109 mode = (mode & S_IALLUGO) | S_IFLNK;
110 return debugfs_mknod(dir, dentry, mode, 0, data, NULL); 110 return debugfs_mknod(dir, dentry, mode, 0, data, NULL);
111 } 111 }
112 112
113 static int debugfs_create(struct inode *dir, struct dentry *dentry, umode_t mode, 113 static int debugfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
114 void *data, const struct file_operations *fops) 114 void *data, const struct file_operations *fops)
115 { 115 {
116 int res; 116 int res;
117 117
118 mode = (mode & S_IALLUGO) | S_IFREG; 118 mode = (mode & S_IALLUGO) | S_IFREG;
119 res = debugfs_mknod(dir, dentry, mode, 0, data, fops); 119 res = debugfs_mknod(dir, dentry, mode, 0, data, fops);
120 if (!res) 120 if (!res)
121 fsnotify_create(dir, dentry); 121 fsnotify_create(dir, dentry);
122 return res; 122 return res;
123 } 123 }
124 124
125 static inline int debugfs_positive(struct dentry *dentry) 125 static inline int debugfs_positive(struct dentry *dentry)
126 { 126 {
127 return dentry->d_inode && !d_unhashed(dentry); 127 return dentry->d_inode && !d_unhashed(dentry);
128 } 128 }
129 129
130 struct debugfs_mount_opts { 130 struct debugfs_mount_opts {
131 uid_t uid; 131 kuid_t uid;
132 gid_t gid; 132 kgid_t gid;
133 umode_t mode; 133 umode_t mode;
134 }; 134 };
135 135
136 enum { 136 enum {
137 Opt_uid, 137 Opt_uid,
138 Opt_gid, 138 Opt_gid,
139 Opt_mode, 139 Opt_mode,
140 Opt_err 140 Opt_err
141 }; 141 };
142 142
143 static const match_table_t tokens = { 143 static const match_table_t tokens = {
144 {Opt_uid, "uid=%u"}, 144 {Opt_uid, "uid=%u"},
145 {Opt_gid, "gid=%u"}, 145 {Opt_gid, "gid=%u"},
146 {Opt_mode, "mode=%o"}, 146 {Opt_mode, "mode=%o"},
147 {Opt_err, NULL} 147 {Opt_err, NULL}
148 }; 148 };
149 149
150 struct debugfs_fs_info { 150 struct debugfs_fs_info {
151 struct debugfs_mount_opts mount_opts; 151 struct debugfs_mount_opts mount_opts;
152 }; 152 };
153 153
154 static int debugfs_parse_options(char *data, struct debugfs_mount_opts *opts) 154 static int debugfs_parse_options(char *data, struct debugfs_mount_opts *opts)
155 { 155 {
156 substring_t args[MAX_OPT_ARGS]; 156 substring_t args[MAX_OPT_ARGS];
157 int option; 157 int option;
158 int token; 158 int token;
159 kuid_t uid;
160 kgid_t gid;
159 char *p; 161 char *p;
160 162
161 opts->mode = DEBUGFS_DEFAULT_MODE; 163 opts->mode = DEBUGFS_DEFAULT_MODE;
162 164
163 while ((p = strsep(&data, ",")) != NULL) { 165 while ((p = strsep(&data, ",")) != NULL) {
164 if (!*p) 166 if (!*p)
165 continue; 167 continue;
166 168
167 token = match_token(p, tokens, args); 169 token = match_token(p, tokens, args);
168 switch (token) { 170 switch (token) {
169 case Opt_uid: 171 case Opt_uid:
170 if (match_int(&args[0], &option)) 172 if (match_int(&args[0], &option))
171 return -EINVAL; 173 return -EINVAL;
172 opts->uid = option; 174 uid = make_kuid(current_user_ns(), option);
175 if (!uid_valid(uid))
176 return -EINVAL;
177 opts->uid = uid;
173 break; 178 break;
174 case Opt_gid: 179 case Opt_gid:
175 if (match_octal(&args[0], &option)) 180 if (match_octal(&args[0], &option))
176 return -EINVAL; 181 return -EINVAL;
177 opts->gid = option; 182 gid = make_kgid(current_user_ns(), option);
183 if (!gid_valid(gid))
184 return -EINVAL;
185 opts->gid = gid;
178 break; 186 break;
179 case Opt_mode: 187 case Opt_mode:
180 if (match_octal(&args[0], &option)) 188 if (match_octal(&args[0], &option))
181 return -EINVAL; 189 return -EINVAL;
182 opts->mode = option & S_IALLUGO; 190 opts->mode = option & S_IALLUGO;
183 break; 191 break;
184 /* 192 /*
185 * We might like to report bad mount options here; 193 * We might like to report bad mount options here;
186 * but traditionally debugfs has ignored all mount options 194 * but traditionally debugfs has ignored all mount options
187 */ 195 */
188 } 196 }
189 } 197 }
190 198
191 return 0; 199 return 0;
192 } 200 }
193 201
194 static int debugfs_apply_options(struct super_block *sb) 202 static int debugfs_apply_options(struct super_block *sb)
195 { 203 {
196 struct debugfs_fs_info *fsi = sb->s_fs_info; 204 struct debugfs_fs_info *fsi = sb->s_fs_info;
197 struct inode *inode = sb->s_root->d_inode; 205 struct inode *inode = sb->s_root->d_inode;
198 struct debugfs_mount_opts *opts = &fsi->mount_opts; 206 struct debugfs_mount_opts *opts = &fsi->mount_opts;
199 207
200 inode->i_mode &= ~S_IALLUGO; 208 inode->i_mode &= ~S_IALLUGO;
201 inode->i_mode |= opts->mode; 209 inode->i_mode |= opts->mode;
202 210
203 inode->i_uid = opts->uid; 211 inode->i_uid = opts->uid;
204 inode->i_gid = opts->gid; 212 inode->i_gid = opts->gid;
205 213
206 return 0; 214 return 0;
207 } 215 }
208 216
209 static int debugfs_remount(struct super_block *sb, int *flags, char *data) 217 static int debugfs_remount(struct super_block *sb, int *flags, char *data)
210 { 218 {
211 int err; 219 int err;
212 struct debugfs_fs_info *fsi = sb->s_fs_info; 220 struct debugfs_fs_info *fsi = sb->s_fs_info;
213 221
214 err = debugfs_parse_options(data, &fsi->mount_opts); 222 err = debugfs_parse_options(data, &fsi->mount_opts);
215 if (err) 223 if (err)
216 goto fail; 224 goto fail;
217 225
218 debugfs_apply_options(sb); 226 debugfs_apply_options(sb);
219 227
220 fail: 228 fail:
221 return err; 229 return err;
222 } 230 }
223 231
224 static int debugfs_show_options(struct seq_file *m, struct dentry *root) 232 static int debugfs_show_options(struct seq_file *m, struct dentry *root)
225 { 233 {
226 struct debugfs_fs_info *fsi = root->d_sb->s_fs_info; 234 struct debugfs_fs_info *fsi = root->d_sb->s_fs_info;
227 struct debugfs_mount_opts *opts = &fsi->mount_opts; 235 struct debugfs_mount_opts *opts = &fsi->mount_opts;
228 236
229 if (opts->uid != 0) 237 if (!uid_eq(opts->uid, GLOBAL_ROOT_UID))
230 seq_printf(m, ",uid=%u", opts->uid); 238 seq_printf(m, ",uid=%u",
231 if (opts->gid != 0) 239 from_kuid_munged(&init_user_ns, opts->uid));
232 seq_printf(m, ",gid=%u", opts->gid); 240 if (!gid_eq(opts->gid, GLOBAL_ROOT_GID))
241 seq_printf(m, ",gid=%u",
242 from_kgid_munged(&init_user_ns, opts->gid));
233 if (opts->mode != DEBUGFS_DEFAULT_MODE) 243 if (opts->mode != DEBUGFS_DEFAULT_MODE)
234 seq_printf(m, ",mode=%o", opts->mode); 244 seq_printf(m, ",mode=%o", opts->mode);
235 245
236 return 0; 246 return 0;
237 } 247 }
238 248
239 static const struct super_operations debugfs_super_operations = { 249 static const struct super_operations debugfs_super_operations = {
240 .statfs = simple_statfs, 250 .statfs = simple_statfs,
241 .remount_fs = debugfs_remount, 251 .remount_fs = debugfs_remount,
242 .show_options = debugfs_show_options, 252 .show_options = debugfs_show_options,
243 }; 253 };
244 254
245 static int debug_fill_super(struct super_block *sb, void *data, int silent) 255 static int debug_fill_super(struct super_block *sb, void *data, int silent)
246 { 256 {
247 static struct tree_descr debug_files[] = {{""}}; 257 static struct tree_descr debug_files[] = {{""}};
248 struct debugfs_fs_info *fsi; 258 struct debugfs_fs_info *fsi;
249 int err; 259 int err;
250 260
251 save_mount_options(sb, data); 261 save_mount_options(sb, data);
252 262
253 fsi = kzalloc(sizeof(struct debugfs_fs_info), GFP_KERNEL); 263 fsi = kzalloc(sizeof(struct debugfs_fs_info), GFP_KERNEL);
254 sb->s_fs_info = fsi; 264 sb->s_fs_info = fsi;
255 if (!fsi) { 265 if (!fsi) {
256 err = -ENOMEM; 266 err = -ENOMEM;
257 goto fail; 267 goto fail;
258 } 268 }
259 269
260 err = debugfs_parse_options(data, &fsi->mount_opts); 270 err = debugfs_parse_options(data, &fsi->mount_opts);
261 if (err) 271 if (err)
262 goto fail; 272 goto fail;
263 273
264 err = simple_fill_super(sb, DEBUGFS_MAGIC, debug_files); 274 err = simple_fill_super(sb, DEBUGFS_MAGIC, debug_files);
265 if (err) 275 if (err)
266 goto fail; 276 goto fail;
267 277
268 sb->s_op = &debugfs_super_operations; 278 sb->s_op = &debugfs_super_operations;
269 279
270 debugfs_apply_options(sb); 280 debugfs_apply_options(sb);
271 281
272 return 0; 282 return 0;
273 283
274 fail: 284 fail:
275 kfree(fsi); 285 kfree(fsi);
276 sb->s_fs_info = NULL; 286 sb->s_fs_info = NULL;
277 return err; 287 return err;
278 } 288 }
279 289
280 static struct dentry *debug_mount(struct file_system_type *fs_type, 290 static struct dentry *debug_mount(struct file_system_type *fs_type,
281 int flags, const char *dev_name, 291 int flags, const char *dev_name,
282 void *data) 292 void *data)
283 { 293 {
284 return mount_single(fs_type, flags, data, debug_fill_super); 294 return mount_single(fs_type, flags, data, debug_fill_super);
285 } 295 }
286 296
287 static struct file_system_type debug_fs_type = { 297 static struct file_system_type debug_fs_type = {
288 .owner = THIS_MODULE, 298 .owner = THIS_MODULE,
289 .name = "debugfs", 299 .name = "debugfs",
290 .mount = debug_mount, 300 .mount = debug_mount,
291 .kill_sb = kill_litter_super, 301 .kill_sb = kill_litter_super,
292 }; 302 };
293 303
294 struct dentry *__create_file(const char *name, umode_t mode, 304 struct dentry *__create_file(const char *name, umode_t mode,
295 struct dentry *parent, void *data, 305 struct dentry *parent, void *data,
296 const struct file_operations *fops) 306 const struct file_operations *fops)
297 { 307 {
298 struct dentry *dentry = NULL; 308 struct dentry *dentry = NULL;
299 int error; 309 int error;
300 310
301 pr_debug("debugfs: creating file '%s'\n",name); 311 pr_debug("debugfs: creating file '%s'\n",name);
302 312
303 error = simple_pin_fs(&debug_fs_type, &debugfs_mount, 313 error = simple_pin_fs(&debug_fs_type, &debugfs_mount,
304 &debugfs_mount_count); 314 &debugfs_mount_count);
305 if (error) 315 if (error)
306 goto exit; 316 goto exit;
307 317
308 /* If the parent is not specified, we create it in the root. 318 /* If the parent is not specified, we create it in the root.
309 * We need the root dentry to do this, which is in the super 319 * We need the root dentry to do this, which is in the super
310 * block. A pointer to that is in the struct vfsmount that we 320 * block. A pointer to that is in the struct vfsmount that we
311 * have around. 321 * have around.
312 */ 322 */
313 if (!parent) 323 if (!parent)
314 parent = debugfs_mount->mnt_root; 324 parent = debugfs_mount->mnt_root;
315 325
316 dentry = NULL; 326 dentry = NULL;
317 mutex_lock(&parent->d_inode->i_mutex); 327 mutex_lock(&parent->d_inode->i_mutex);
318 dentry = lookup_one_len(name, parent, strlen(name)); 328 dentry = lookup_one_len(name, parent, strlen(name));
319 if (!IS_ERR(dentry)) { 329 if (!IS_ERR(dentry)) {
320 switch (mode & S_IFMT) { 330 switch (mode & S_IFMT) {
321 case S_IFDIR: 331 case S_IFDIR:
322 error = debugfs_mkdir(parent->d_inode, dentry, mode); 332 error = debugfs_mkdir(parent->d_inode, dentry, mode);
323 333
324 break; 334 break;
325 case S_IFLNK: 335 case S_IFLNK:
326 error = debugfs_link(parent->d_inode, dentry, mode, 336 error = debugfs_link(parent->d_inode, dentry, mode,
327 data); 337 data);
328 break; 338 break;
329 default: 339 default:
330 error = debugfs_create(parent->d_inode, dentry, mode, 340 error = debugfs_create(parent->d_inode, dentry, mode,
331 data, fops); 341 data, fops);
332 break; 342 break;
333 } 343 }
334 dput(dentry); 344 dput(dentry);
335 } else 345 } else
336 error = PTR_ERR(dentry); 346 error = PTR_ERR(dentry);
337 mutex_unlock(&parent->d_inode->i_mutex); 347 mutex_unlock(&parent->d_inode->i_mutex);
338 348
339 if (error) { 349 if (error) {
340 dentry = NULL; 350 dentry = NULL;
341 simple_release_fs(&debugfs_mount, &debugfs_mount_count); 351 simple_release_fs(&debugfs_mount, &debugfs_mount_count);
342 } 352 }
343 exit: 353 exit:
344 return dentry; 354 return dentry;
345 } 355 }
346 356
347 /** 357 /**
348 * debugfs_create_file - create a file in the debugfs filesystem 358 * debugfs_create_file - create a file in the debugfs filesystem
349 * @name: a pointer to a string containing the name of the file to create. 359 * @name: a pointer to a string containing the name of the file to create.
350 * @mode: the permission that the file should have. 360 * @mode: the permission that the file should have.
351 * @parent: a pointer to the parent dentry for this file. This should be a 361 * @parent: a pointer to the parent dentry for this file. This should be a
352 * directory dentry if set. If this paramater is NULL, then the 362 * directory dentry if set. If this paramater is NULL, then the
353 * file will be created in the root of the debugfs filesystem. 363 * file will be created in the root of the debugfs filesystem.
354 * @data: a pointer to something that the caller will want to get to later 364 * @data: a pointer to something that the caller will want to get to later
355 * on. The inode.i_private pointer will point to this value on 365 * on. The inode.i_private pointer will point to this value on
356 * the open() call. 366 * the open() call.
357 * @fops: a pointer to a struct file_operations that should be used for 367 * @fops: a pointer to a struct file_operations that should be used for
358 * this file. 368 * this file.
359 * 369 *
360 * This is the basic "create a file" function for debugfs. It allows for a 370 * This is the basic "create a file" function for debugfs. It allows for a
361 * wide range of flexibility in creating a file, or a directory (if you want 371 * wide range of flexibility in creating a file, or a directory (if you want
362 * to create a directory, the debugfs_create_dir() function is 372 * to create a directory, the debugfs_create_dir() function is
363 * recommended to be used instead.) 373 * recommended to be used instead.)
364 * 374 *
365 * This function will return a pointer to a dentry if it succeeds. This 375 * This function will return a pointer to a dentry if it succeeds. This
366 * pointer must be passed to the debugfs_remove() function when the file is 376 * pointer must be passed to the debugfs_remove() function when the file is
367 * to be removed (no automatic cleanup happens if your module is unloaded, 377 * to be removed (no automatic cleanup happens if your module is unloaded,
368 * you are responsible here.) If an error occurs, %NULL will be returned. 378 * you are responsible here.) If an error occurs, %NULL will be returned.
369 * 379 *
370 * If debugfs is not enabled in the kernel, the value -%ENODEV will be 380 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
371 * returned. 381 * returned.
372 */ 382 */
373 struct dentry *debugfs_create_file(const char *name, umode_t mode, 383 struct dentry *debugfs_create_file(const char *name, umode_t mode,
374 struct dentry *parent, void *data, 384 struct dentry *parent, void *data,
375 const struct file_operations *fops) 385 const struct file_operations *fops)
376 { 386 {
377 switch (mode & S_IFMT) { 387 switch (mode & S_IFMT) {
378 case S_IFREG: 388 case S_IFREG:
379 case 0: 389 case 0:
380 break; 390 break;
381 default: 391 default:
382 BUG(); 392 BUG();
383 } 393 }
384 394
385 return __create_file(name, mode, parent, data, fops); 395 return __create_file(name, mode, parent, data, fops);
386 } 396 }
387 EXPORT_SYMBOL_GPL(debugfs_create_file); 397 EXPORT_SYMBOL_GPL(debugfs_create_file);
388 398
389 /** 399 /**
390 * debugfs_create_dir - create a directory in the debugfs filesystem 400 * debugfs_create_dir - create a directory in the debugfs filesystem
391 * @name: a pointer to a string containing the name of the directory to 401 * @name: a pointer to a string containing the name of the directory to
392 * create. 402 * create.
393 * @parent: a pointer to the parent dentry for this file. This should be a 403 * @parent: a pointer to the parent dentry for this file. This should be a
394 * directory dentry if set. If this paramater is NULL, then the 404 * directory dentry if set. If this paramater is NULL, then the
395 * directory will be created in the root of the debugfs filesystem. 405 * directory will be created in the root of the debugfs filesystem.
396 * 406 *
397 * This function creates a directory in debugfs with the given name. 407 * This function creates a directory in debugfs with the given name.
398 * 408 *
399 * This function will return a pointer to a dentry if it succeeds. This 409 * This function will return a pointer to a dentry if it succeeds. This
400 * pointer must be passed to the debugfs_remove() function when the file is 410 * pointer must be passed to the debugfs_remove() function when the file is
401 * to be removed (no automatic cleanup happens if your module is unloaded, 411 * to be removed (no automatic cleanup happens if your module is unloaded,
402 * you are responsible here.) If an error occurs, %NULL will be returned. 412 * you are responsible here.) If an error occurs, %NULL will be returned.
403 * 413 *
404 * If debugfs is not enabled in the kernel, the value -%ENODEV will be 414 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
405 * returned. 415 * returned.
406 */ 416 */
407 struct dentry *debugfs_create_dir(const char *name, struct dentry *parent) 417 struct dentry *debugfs_create_dir(const char *name, struct dentry *parent)
408 { 418 {
409 return __create_file(name, S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO, 419 return __create_file(name, S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO,
410 parent, NULL, NULL); 420 parent, NULL, NULL);
411 } 421 }
412 EXPORT_SYMBOL_GPL(debugfs_create_dir); 422 EXPORT_SYMBOL_GPL(debugfs_create_dir);
413 423
414 /** 424 /**
415 * debugfs_create_symlink- create a symbolic link in the debugfs filesystem 425 * debugfs_create_symlink- create a symbolic link in the debugfs filesystem
416 * @name: a pointer to a string containing the name of the symbolic link to 426 * @name: a pointer to a string containing the name of the symbolic link to
417 * create. 427 * create.
418 * @parent: a pointer to the parent dentry for this symbolic link. This 428 * @parent: a pointer to the parent dentry for this symbolic link. This
419 * should be a directory dentry if set. If this paramater is NULL, 429 * should be a directory dentry if set. If this paramater is NULL,
420 * then the symbolic link will be created in the root of the debugfs 430 * then the symbolic link will be created in the root of the debugfs
421 * filesystem. 431 * filesystem.
422 * @target: a pointer to a string containing the path to the target of the 432 * @target: a pointer to a string containing the path to the target of the
423 * symbolic link. 433 * symbolic link.
424 * 434 *
425 * This function creates a symbolic link with the given name in debugfs that 435 * This function creates a symbolic link with the given name in debugfs that
426 * links to the given target path. 436 * links to the given target path.
427 * 437 *
428 * This function will return a pointer to a dentry if it succeeds. This 438 * This function will return a pointer to a dentry if it succeeds. This
429 * pointer must be passed to the debugfs_remove() function when the symbolic 439 * pointer must be passed to the debugfs_remove() function when the symbolic
430 * link is to be removed (no automatic cleanup happens if your module is 440 * link is to be removed (no automatic cleanup happens if your module is
431 * unloaded, you are responsible here.) If an error occurs, %NULL will be 441 * unloaded, you are responsible here.) If an error occurs, %NULL will be
432 * returned. 442 * returned.
433 * 443 *
434 * If debugfs is not enabled in the kernel, the value -%ENODEV will be 444 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
435 * returned. 445 * returned.
436 */ 446 */
437 struct dentry *debugfs_create_symlink(const char *name, struct dentry *parent, 447 struct dentry *debugfs_create_symlink(const char *name, struct dentry *parent,
438 const char *target) 448 const char *target)
439 { 449 {
440 struct dentry *result; 450 struct dentry *result;
441 char *link; 451 char *link;
442 452
443 link = kstrdup(target, GFP_KERNEL); 453 link = kstrdup(target, GFP_KERNEL);
444 if (!link) 454 if (!link)
445 return NULL; 455 return NULL;
446 456
447 result = __create_file(name, S_IFLNK | S_IRWXUGO, parent, link, NULL); 457 result = __create_file(name, S_IFLNK | S_IRWXUGO, parent, link, NULL);
448 if (!result) 458 if (!result)
449 kfree(link); 459 kfree(link);
450 return result; 460 return result;
451 } 461 }
452 EXPORT_SYMBOL_GPL(debugfs_create_symlink); 462 EXPORT_SYMBOL_GPL(debugfs_create_symlink);
453 463
454 static int __debugfs_remove(struct dentry *dentry, struct dentry *parent) 464 static int __debugfs_remove(struct dentry *dentry, struct dentry *parent)
455 { 465 {
456 int ret = 0; 466 int ret = 0;
457 467
458 if (debugfs_positive(dentry)) { 468 if (debugfs_positive(dentry)) {
459 if (dentry->d_inode) { 469 if (dentry->d_inode) {
460 dget(dentry); 470 dget(dentry);
461 switch (dentry->d_inode->i_mode & S_IFMT) { 471 switch (dentry->d_inode->i_mode & S_IFMT) {
462 case S_IFDIR: 472 case S_IFDIR:
463 ret = simple_rmdir(parent->d_inode, dentry); 473 ret = simple_rmdir(parent->d_inode, dentry);
464 break; 474 break;
465 case S_IFLNK: 475 case S_IFLNK:
466 kfree(dentry->d_inode->i_private); 476 kfree(dentry->d_inode->i_private);
467 /* fall through */ 477 /* fall through */
468 default: 478 default:
469 simple_unlink(parent->d_inode, dentry); 479 simple_unlink(parent->d_inode, dentry);
470 break; 480 break;
471 } 481 }
472 if (!ret) 482 if (!ret)
473 d_delete(dentry); 483 d_delete(dentry);
474 dput(dentry); 484 dput(dentry);
475 } 485 }
476 } 486 }
477 return ret; 487 return ret;
478 } 488 }
479 489
480 /** 490 /**
481 * debugfs_remove - removes a file or directory from the debugfs filesystem 491 * debugfs_remove - removes a file or directory from the debugfs filesystem
482 * @dentry: a pointer to a the dentry of the file or directory to be 492 * @dentry: a pointer to a the dentry of the file or directory to be
483 * removed. 493 * removed.
484 * 494 *
485 * This function removes a file or directory in debugfs that was previously 495 * This function removes a file or directory in debugfs that was previously
486 * created with a call to another debugfs function (like 496 * created with a call to another debugfs function (like
487 * debugfs_create_file() or variants thereof.) 497 * debugfs_create_file() or variants thereof.)
488 * 498 *
489 * This function is required to be called in order for the file to be 499 * This function is required to be called in order for the file to be
490 * removed, no automatic cleanup of files will happen when a module is 500 * removed, no automatic cleanup of files will happen when a module is
491 * removed, you are responsible here. 501 * removed, you are responsible here.
492 */ 502 */
493 void debugfs_remove(struct dentry *dentry) 503 void debugfs_remove(struct dentry *dentry)
494 { 504 {
495 struct dentry *parent; 505 struct dentry *parent;
496 int ret; 506 int ret;
497 507
498 if (IS_ERR_OR_NULL(dentry)) 508 if (IS_ERR_OR_NULL(dentry))
499 return; 509 return;
500 510
501 parent = dentry->d_parent; 511 parent = dentry->d_parent;
502 if (!parent || !parent->d_inode) 512 if (!parent || !parent->d_inode)
503 return; 513 return;
504 514
505 mutex_lock(&parent->d_inode->i_mutex); 515 mutex_lock(&parent->d_inode->i_mutex);
506 ret = __debugfs_remove(dentry, parent); 516 ret = __debugfs_remove(dentry, parent);
507 mutex_unlock(&parent->d_inode->i_mutex); 517 mutex_unlock(&parent->d_inode->i_mutex);
508 if (!ret) 518 if (!ret)
509 simple_release_fs(&debugfs_mount, &debugfs_mount_count); 519 simple_release_fs(&debugfs_mount, &debugfs_mount_count);
510 } 520 }
511 EXPORT_SYMBOL_GPL(debugfs_remove); 521 EXPORT_SYMBOL_GPL(debugfs_remove);
512 522
513 /** 523 /**
514 * debugfs_remove_recursive - recursively removes a directory 524 * debugfs_remove_recursive - recursively removes a directory
515 * @dentry: a pointer to a the dentry of the directory to be removed. 525 * @dentry: a pointer to a the dentry of the directory to be removed.
516 * 526 *
517 * This function recursively removes a directory tree in debugfs that 527 * This function recursively removes a directory tree in debugfs that
518 * was previously created with a call to another debugfs function 528 * was previously created with a call to another debugfs function
519 * (like debugfs_create_file() or variants thereof.) 529 * (like debugfs_create_file() or variants thereof.)
520 * 530 *
521 * This function is required to be called in order for the file to be 531 * This function is required to be called in order for the file to be
522 * removed, no automatic cleanup of files will happen when a module is 532 * removed, no automatic cleanup of files will happen when a module is
523 * removed, you are responsible here. 533 * removed, you are responsible here.
524 */ 534 */
525 void debugfs_remove_recursive(struct dentry *dentry) 535 void debugfs_remove_recursive(struct dentry *dentry)
526 { 536 {
527 struct dentry *child; 537 struct dentry *child;
528 struct dentry *parent; 538 struct dentry *parent;
529 539
530 if (IS_ERR_OR_NULL(dentry)) 540 if (IS_ERR_OR_NULL(dentry))
531 return; 541 return;
532 542
533 parent = dentry->d_parent; 543 parent = dentry->d_parent;
534 if (!parent || !parent->d_inode) 544 if (!parent || !parent->d_inode)
535 return; 545 return;
536 546
537 parent = dentry; 547 parent = dentry;
538 mutex_lock(&parent->d_inode->i_mutex); 548 mutex_lock(&parent->d_inode->i_mutex);
539 549
540 while (1) { 550 while (1) {
541 /* 551 /*
542 * When all dentries under "parent" has been removed, 552 * When all dentries under "parent" has been removed,
543 * walk up the tree until we reach our starting point. 553 * walk up the tree until we reach our starting point.
544 */ 554 */
545 if (list_empty(&parent->d_subdirs)) { 555 if (list_empty(&parent->d_subdirs)) {
546 mutex_unlock(&parent->d_inode->i_mutex); 556 mutex_unlock(&parent->d_inode->i_mutex);
547 if (parent == dentry) 557 if (parent == dentry)
548 break; 558 break;
549 parent = parent->d_parent; 559 parent = parent->d_parent;
550 mutex_lock(&parent->d_inode->i_mutex); 560 mutex_lock(&parent->d_inode->i_mutex);
551 } 561 }
552 child = list_entry(parent->d_subdirs.next, struct dentry, 562 child = list_entry(parent->d_subdirs.next, struct dentry,
553 d_u.d_child); 563 d_u.d_child);
554 next_sibling: 564 next_sibling:
555 565
556 /* 566 /*
557 * If "child" isn't empty, walk down the tree and 567 * If "child" isn't empty, walk down the tree and
558 * remove all its descendants first. 568 * remove all its descendants first.
559 */ 569 */
560 if (!list_empty(&child->d_subdirs)) { 570 if (!list_empty(&child->d_subdirs)) {
561 mutex_unlock(&parent->d_inode->i_mutex); 571 mutex_unlock(&parent->d_inode->i_mutex);
562 parent = child; 572 parent = child;
563 mutex_lock(&parent->d_inode->i_mutex); 573 mutex_lock(&parent->d_inode->i_mutex);
564 continue; 574 continue;
565 } 575 }
566 __debugfs_remove(child, parent); 576 __debugfs_remove(child, parent);
567 if (parent->d_subdirs.next == &child->d_u.d_child) { 577 if (parent->d_subdirs.next == &child->d_u.d_child) {
568 /* 578 /*
569 * Try the next sibling. 579 * Try the next sibling.
570 */ 580 */
571 if (child->d_u.d_child.next != &parent->d_subdirs) { 581 if (child->d_u.d_child.next != &parent->d_subdirs) {
572 child = list_entry(child->d_u.d_child.next, 582 child = list_entry(child->d_u.d_child.next,
573 struct dentry, 583 struct dentry,
574 d_u.d_child); 584 d_u.d_child);
575 goto next_sibling; 585 goto next_sibling;
576 } 586 }
577 587
578 /* 588 /*
579 * Avoid infinite loop if we fail to remove 589 * Avoid infinite loop if we fail to remove
580 * one dentry. 590 * one dentry.
581 */ 591 */
582 mutex_unlock(&parent->d_inode->i_mutex); 592 mutex_unlock(&parent->d_inode->i_mutex);
583 break; 593 break;
584 } 594 }
585 simple_release_fs(&debugfs_mount, &debugfs_mount_count); 595 simple_release_fs(&debugfs_mount, &debugfs_mount_count);
586 } 596 }
587 597
588 parent = dentry->d_parent; 598 parent = dentry->d_parent;
589 mutex_lock(&parent->d_inode->i_mutex); 599 mutex_lock(&parent->d_inode->i_mutex);
590 __debugfs_remove(dentry, parent); 600 __debugfs_remove(dentry, parent);
591 mutex_unlock(&parent->d_inode->i_mutex); 601 mutex_unlock(&parent->d_inode->i_mutex);
592 simple_release_fs(&debugfs_mount, &debugfs_mount_count); 602 simple_release_fs(&debugfs_mount, &debugfs_mount_count);
593 } 603 }
594 EXPORT_SYMBOL_GPL(debugfs_remove_recursive); 604 EXPORT_SYMBOL_GPL(debugfs_remove_recursive);
595 605
596 /** 606 /**
597 * debugfs_rename - rename a file/directory in the debugfs filesystem 607 * debugfs_rename - rename a file/directory in the debugfs filesystem
598 * @old_dir: a pointer to the parent dentry for the renamed object. This 608 * @old_dir: a pointer to the parent dentry for the renamed object. This
599 * should be a directory dentry. 609 * should be a directory dentry.
600 * @old_dentry: dentry of an object to be renamed. 610 * @old_dentry: dentry of an object to be renamed.
601 * @new_dir: a pointer to the parent dentry where the object should be 611 * @new_dir: a pointer to the parent dentry where the object should be
602 * moved. This should be a directory dentry. 612 * moved. This should be a directory dentry.
603 * @new_name: a pointer to a string containing the target name. 613 * @new_name: a pointer to a string containing the target name.
604 * 614 *
605 * This function renames a file/directory in debugfs. The target must not 615 * This function renames a file/directory in debugfs. The target must not
606 * exist for rename to succeed. 616 * exist for rename to succeed.
607 * 617 *
608 * This function will return a pointer to old_dentry (which is updated to 618 * This function will return a pointer to old_dentry (which is updated to
609 * reflect renaming) if it succeeds. If an error occurs, %NULL will be 619 * reflect renaming) if it succeeds. If an error occurs, %NULL will be
610 * returned. 620 * returned.
611 * 621 *
612 * If debugfs is not enabled in the kernel, the value -%ENODEV will be 622 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
613 * returned. 623 * returned.
614 */ 624 */
615 struct dentry *debugfs_rename(struct dentry *old_dir, struct dentry *old_dentry, 625 struct dentry *debugfs_rename(struct dentry *old_dir, struct dentry *old_dentry,
616 struct dentry *new_dir, const char *new_name) 626 struct dentry *new_dir, const char *new_name)
617 { 627 {
618 int error; 628 int error;
619 struct dentry *dentry = NULL, *trap; 629 struct dentry *dentry = NULL, *trap;
620 const char *old_name; 630 const char *old_name;
621 631
622 trap = lock_rename(new_dir, old_dir); 632 trap = lock_rename(new_dir, old_dir);
623 /* Source or destination directories don't exist? */ 633 /* Source or destination directories don't exist? */
624 if (!old_dir->d_inode || !new_dir->d_inode) 634 if (!old_dir->d_inode || !new_dir->d_inode)
625 goto exit; 635 goto exit;
626 /* Source does not exist, cyclic rename, or mountpoint? */ 636 /* Source does not exist, cyclic rename, or mountpoint? */
627 if (!old_dentry->d_inode || old_dentry == trap || 637 if (!old_dentry->d_inode || old_dentry == trap ||
628 d_mountpoint(old_dentry)) 638 d_mountpoint(old_dentry))
629 goto exit; 639 goto exit;
630 dentry = lookup_one_len(new_name, new_dir, strlen(new_name)); 640 dentry = lookup_one_len(new_name, new_dir, strlen(new_name));
631 /* Lookup failed, cyclic rename or target exists? */ 641 /* Lookup failed, cyclic rename or target exists? */
632 if (IS_ERR(dentry) || dentry == trap || dentry->d_inode) 642 if (IS_ERR(dentry) || dentry == trap || dentry->d_inode)
633 goto exit; 643 goto exit;
634 644
635 old_name = fsnotify_oldname_init(old_dentry->d_name.name); 645 old_name = fsnotify_oldname_init(old_dentry->d_name.name);
636 646
637 error = simple_rename(old_dir->d_inode, old_dentry, new_dir->d_inode, 647 error = simple_rename(old_dir->d_inode, old_dentry, new_dir->d_inode,
638 dentry); 648 dentry);
639 if (error) { 649 if (error) {
640 fsnotify_oldname_free(old_name); 650 fsnotify_oldname_free(old_name);
641 goto exit; 651 goto exit;
642 } 652 }
643 d_move(old_dentry, dentry); 653 d_move(old_dentry, dentry);
644 fsnotify_move(old_dir->d_inode, new_dir->d_inode, old_name, 654 fsnotify_move(old_dir->d_inode, new_dir->d_inode, old_name,
645 S_ISDIR(old_dentry->d_inode->i_mode), 655 S_ISDIR(old_dentry->d_inode->i_mode),
646 NULL, old_dentry); 656 NULL, old_dentry);
647 fsnotify_oldname_free(old_name); 657 fsnotify_oldname_free(old_name);
648 unlock_rename(new_dir, old_dir); 658 unlock_rename(new_dir, old_dir);
649 dput(dentry); 659 dput(dentry);
650 return old_dentry; 660 return old_dentry;
651 exit: 661 exit:
652 if (dentry && !IS_ERR(dentry)) 662 if (dentry && !IS_ERR(dentry))
653 dput(dentry); 663 dput(dentry);
654 unlock_rename(new_dir, old_dir); 664 unlock_rename(new_dir, old_dir);
655 return NULL; 665 return NULL;
656 } 666 }
657 EXPORT_SYMBOL_GPL(debugfs_rename); 667 EXPORT_SYMBOL_GPL(debugfs_rename);
658 668
659 /** 669 /**
660 * debugfs_initialized - Tells whether debugfs has been registered 670 * debugfs_initialized - Tells whether debugfs has been registered
661 */ 671 */
662 bool debugfs_initialized(void) 672 bool debugfs_initialized(void)
663 { 673 {
664 return debugfs_registered; 674 return debugfs_registered;
665 } 675 }
666 EXPORT_SYMBOL_GPL(debugfs_initialized); 676 EXPORT_SYMBOL_GPL(debugfs_initialized);
667 677
668 678
669 static struct kobject *debug_kobj; 679 static struct kobject *debug_kobj;
670 680
671 static int __init debugfs_init(void) 681 static int __init debugfs_init(void)
672 { 682 {
673 int retval; 683 int retval;
674 684
675 debug_kobj = kobject_create_and_add("debug", kernel_kobj); 685 debug_kobj = kobject_create_and_add("debug", kernel_kobj);
676 if (!debug_kobj) 686 if (!debug_kobj)
677 return -EINVAL; 687 return -EINVAL;
678 688
679 retval = register_filesystem(&debug_fs_type); 689 retval = register_filesystem(&debug_fs_type);
680 if (retval) 690 if (retval)
681 kobject_put(debug_kobj); 691 kobject_put(debug_kobj);
682 else 692 else
683 debugfs_registered = true; 693 debugfs_registered = true;
684 694
685 return retval; 695 return retval;
686 } 696 }
687 core_initcall(debugfs_init); 697 core_initcall(debugfs_init);
688 698
689 699
1 config ARCH 1 config ARCH
2 string 2 string
3 option env="ARCH" 3 option env="ARCH"
4 4
5 config KERNELVERSION 5 config KERNELVERSION
6 string 6 string
7 option env="KERNELVERSION" 7 option env="KERNELVERSION"
8 8
9 config DEFCONFIG_LIST 9 config DEFCONFIG_LIST
10 string 10 string
11 depends on !UML 11 depends on !UML
12 option defconfig_list 12 option defconfig_list
13 default "/lib/modules/$UNAME_RELEASE/.config" 13 default "/lib/modules/$UNAME_RELEASE/.config"
14 default "/etc/kernel-config" 14 default "/etc/kernel-config"
15 default "/boot/config-$UNAME_RELEASE" 15 default "/boot/config-$UNAME_RELEASE"
16 default "$ARCH_DEFCONFIG" 16 default "$ARCH_DEFCONFIG"
17 default "arch/$ARCH/defconfig" 17 default "arch/$ARCH/defconfig"
18 18
19 config CONSTRUCTORS 19 config CONSTRUCTORS
20 bool 20 bool
21 depends on !UML 21 depends on !UML
22 22
23 config HAVE_IRQ_WORK 23 config HAVE_IRQ_WORK
24 bool 24 bool
25 25
26 config IRQ_WORK 26 config IRQ_WORK
27 bool 27 bool
28 depends on HAVE_IRQ_WORK 28 depends on HAVE_IRQ_WORK
29 29
30 config BUILDTIME_EXTABLE_SORT 30 config BUILDTIME_EXTABLE_SORT
31 bool 31 bool
32 32
33 menu "General setup" 33 menu "General setup"
34 34
35 config EXPERIMENTAL 35 config EXPERIMENTAL
36 bool "Prompt for development and/or incomplete code/drivers" 36 bool "Prompt for development and/or incomplete code/drivers"
37 ---help--- 37 ---help---
38 Some of the various things that Linux supports (such as network 38 Some of the various things that Linux supports (such as network
39 drivers, file systems, network protocols, etc.) can be in a state 39 drivers, file systems, network protocols, etc.) can be in a state
40 of development where the functionality, stability, or the level of 40 of development where the functionality, stability, or the level of
41 testing is not yet high enough for general use. This is usually 41 testing is not yet high enough for general use. This is usually
42 known as the "alpha-test" phase among developers. If a feature is 42 known as the "alpha-test" phase among developers. If a feature is
43 currently in alpha-test, then the developers usually discourage 43 currently in alpha-test, then the developers usually discourage
44 uninformed widespread use of this feature by the general public to 44 uninformed widespread use of this feature by the general public to
45 avoid "Why doesn't this work?" type mail messages. However, active 45 avoid "Why doesn't this work?" type mail messages. However, active
46 testing and use of these systems is welcomed. Just be aware that it 46 testing and use of these systems is welcomed. Just be aware that it
47 may not meet the normal level of reliability or it may fail to work 47 may not meet the normal level of reliability or it may fail to work
48 in some special cases. Detailed bug reports from people familiar 48 in some special cases. Detailed bug reports from people familiar
49 with the kernel internals are usually welcomed by the developers 49 with the kernel internals are usually welcomed by the developers
50 (before submitting bug reports, please read the documents 50 (before submitting bug reports, please read the documents
51 <file:README>, <file:MAINTAINERS>, <file:REPORTING-BUGS>, 51 <file:README>, <file:MAINTAINERS>, <file:REPORTING-BUGS>,
52 <file:Documentation/BUG-HUNTING>, and 52 <file:Documentation/BUG-HUNTING>, and
53 <file:Documentation/oops-tracing.txt> in the kernel source). 53 <file:Documentation/oops-tracing.txt> in the kernel source).
54 54
55 This option will also make obsoleted drivers available. These are 55 This option will also make obsoleted drivers available. These are
56 drivers that have been replaced by something else, and/or are 56 drivers that have been replaced by something else, and/or are
57 scheduled to be removed in a future kernel release. 57 scheduled to be removed in a future kernel release.
58 58
59 Unless you intend to help test and develop a feature or driver that 59 Unless you intend to help test and develop a feature or driver that
60 falls into this category, or you have a situation that requires 60 falls into this category, or you have a situation that requires
61 using these features, you should probably say N here, which will 61 using these features, you should probably say N here, which will
62 cause the configurator to present you with fewer choices. If 62 cause the configurator to present you with fewer choices. If
63 you say Y here, you will be offered the choice of using features or 63 you say Y here, you will be offered the choice of using features or
64 drivers that are currently considered to be in the alpha-test phase. 64 drivers that are currently considered to be in the alpha-test phase.
65 65
66 config BROKEN 66 config BROKEN
67 bool 67 bool
68 68
69 config BROKEN_ON_SMP 69 config BROKEN_ON_SMP
70 bool 70 bool
71 depends on BROKEN || !SMP 71 depends on BROKEN || !SMP
72 default y 72 default y
73 73
74 config INIT_ENV_ARG_LIMIT 74 config INIT_ENV_ARG_LIMIT
75 int 75 int
76 default 32 if !UML 76 default 32 if !UML
77 default 128 if UML 77 default 128 if UML
78 help 78 help
79 Maximum of each of the number of arguments and environment 79 Maximum of each of the number of arguments and environment
80 variables passed to init from the kernel command line. 80 variables passed to init from the kernel command line.
81 81
82 82
83 config CROSS_COMPILE 83 config CROSS_COMPILE
84 string "Cross-compiler tool prefix" 84 string "Cross-compiler tool prefix"
85 help 85 help
86 Same as running 'make CROSS_COMPILE=prefix-' but stored for 86 Same as running 'make CROSS_COMPILE=prefix-' but stored for
87 default make runs in this kernel build directory. You don't 87 default make runs in this kernel build directory. You don't
88 need to set this unless you want the configured kernel build 88 need to set this unless you want the configured kernel build
89 directory to select the cross-compiler automatically. 89 directory to select the cross-compiler automatically.
90 90
91 config LOCALVERSION 91 config LOCALVERSION
92 string "Local version - append to kernel release" 92 string "Local version - append to kernel release"
93 help 93 help
94 Append an extra string to the end of your kernel version. 94 Append an extra string to the end of your kernel version.
95 This will show up when you type uname, for example. 95 This will show up when you type uname, for example.
96 The string you set here will be appended after the contents of 96 The string you set here will be appended after the contents of
97 any files with a filename matching localversion* in your 97 any files with a filename matching localversion* in your
98 object and source tree, in that order. Your total string can 98 object and source tree, in that order. Your total string can
99 be a maximum of 64 characters. 99 be a maximum of 64 characters.
100 100
101 config LOCALVERSION_AUTO 101 config LOCALVERSION_AUTO
102 bool "Automatically append version information to the version string" 102 bool "Automatically append version information to the version string"
103 default y 103 default y
104 help 104 help
105 This will try to automatically determine if the current tree is a 105 This will try to automatically determine if the current tree is a
106 release tree by looking for git tags that belong to the current 106 release tree by looking for git tags that belong to the current
107 top of tree revision. 107 top of tree revision.
108 108
109 A string of the format -gxxxxxxxx will be added to the localversion 109 A string of the format -gxxxxxxxx will be added to the localversion
110 if a git-based tree is found. The string generated by this will be 110 if a git-based tree is found. The string generated by this will be
111 appended after any matching localversion* files, and after the value 111 appended after any matching localversion* files, and after the value
112 set in CONFIG_LOCALVERSION. 112 set in CONFIG_LOCALVERSION.
113 113
114 (The actual string used here is the first eight characters produced 114 (The actual string used here is the first eight characters produced
115 by running the command: 115 by running the command:
116 116
117 $ git rev-parse --verify HEAD 117 $ git rev-parse --verify HEAD
118 118
119 which is done within the script "scripts/setlocalversion".) 119 which is done within the script "scripts/setlocalversion".)
120 120
121 config HAVE_KERNEL_GZIP 121 config HAVE_KERNEL_GZIP
122 bool 122 bool
123 123
124 config HAVE_KERNEL_BZIP2 124 config HAVE_KERNEL_BZIP2
125 bool 125 bool
126 126
127 config HAVE_KERNEL_LZMA 127 config HAVE_KERNEL_LZMA
128 bool 128 bool
129 129
130 config HAVE_KERNEL_XZ 130 config HAVE_KERNEL_XZ
131 bool 131 bool
132 132
133 config HAVE_KERNEL_LZO 133 config HAVE_KERNEL_LZO
134 bool 134 bool
135 135
136 choice 136 choice
137 prompt "Kernel compression mode" 137 prompt "Kernel compression mode"
138 default KERNEL_GZIP 138 default KERNEL_GZIP
139 depends on HAVE_KERNEL_GZIP || HAVE_KERNEL_BZIP2 || HAVE_KERNEL_LZMA || HAVE_KERNEL_XZ || HAVE_KERNEL_LZO 139 depends on HAVE_KERNEL_GZIP || HAVE_KERNEL_BZIP2 || HAVE_KERNEL_LZMA || HAVE_KERNEL_XZ || HAVE_KERNEL_LZO
140 help 140 help
141 The linux kernel is a kind of self-extracting executable. 141 The linux kernel is a kind of self-extracting executable.
142 Several compression algorithms are available, which differ 142 Several compression algorithms are available, which differ
143 in efficiency, compression and decompression speed. 143 in efficiency, compression and decompression speed.
144 Compression speed is only relevant when building a kernel. 144 Compression speed is only relevant when building a kernel.
145 Decompression speed is relevant at each boot. 145 Decompression speed is relevant at each boot.
146 146
147 If you have any problems with bzip2 or lzma compressed 147 If you have any problems with bzip2 or lzma compressed
148 kernels, mail me (Alain Knaff) <alain@knaff.lu>. (An older 148 kernels, mail me (Alain Knaff) <alain@knaff.lu>. (An older
149 version of this functionality (bzip2 only), for 2.4, was 149 version of this functionality (bzip2 only), for 2.4, was
150 supplied by Christian Ludwig) 150 supplied by Christian Ludwig)
151 151
152 High compression options are mostly useful for users, who 152 High compression options are mostly useful for users, who
153 are low on disk space (embedded systems), but for whom ram 153 are low on disk space (embedded systems), but for whom ram
154 size matters less. 154 size matters less.
155 155
156 If in doubt, select 'gzip' 156 If in doubt, select 'gzip'
157 157
158 config KERNEL_GZIP 158 config KERNEL_GZIP
159 bool "Gzip" 159 bool "Gzip"
160 depends on HAVE_KERNEL_GZIP 160 depends on HAVE_KERNEL_GZIP
161 help 161 help
162 The old and tried gzip compression. It provides a good balance 162 The old and tried gzip compression. It provides a good balance
163 between compression ratio and decompression speed. 163 between compression ratio and decompression speed.
164 164
165 config KERNEL_BZIP2 165 config KERNEL_BZIP2
166 bool "Bzip2" 166 bool "Bzip2"
167 depends on HAVE_KERNEL_BZIP2 167 depends on HAVE_KERNEL_BZIP2
168 help 168 help
169 Its compression ratio and speed is intermediate. 169 Its compression ratio and speed is intermediate.
170 Decompression speed is slowest among the choices. The kernel 170 Decompression speed is slowest among the choices. The kernel
171 size is about 10% smaller with bzip2, in comparison to gzip. 171 size is about 10% smaller with bzip2, in comparison to gzip.
172 Bzip2 uses a large amount of memory. For modern kernels you 172 Bzip2 uses a large amount of memory. For modern kernels you
173 will need at least 8MB RAM or more for booting. 173 will need at least 8MB RAM or more for booting.
174 174
175 config KERNEL_LZMA 175 config KERNEL_LZMA
176 bool "LZMA" 176 bool "LZMA"
177 depends on HAVE_KERNEL_LZMA 177 depends on HAVE_KERNEL_LZMA
178 help 178 help
179 This compression algorithm's ratio is best. Decompression speed 179 This compression algorithm's ratio is best. Decompression speed
180 is between gzip and bzip2. Compression is slowest. 180 is between gzip and bzip2. Compression is slowest.
181 The kernel size is about 33% smaller with LZMA in comparison to gzip. 181 The kernel size is about 33% smaller with LZMA in comparison to gzip.
182 182
183 config KERNEL_XZ 183 config KERNEL_XZ
184 bool "XZ" 184 bool "XZ"
185 depends on HAVE_KERNEL_XZ 185 depends on HAVE_KERNEL_XZ
186 help 186 help
187 XZ uses the LZMA2 algorithm and instruction set specific 187 XZ uses the LZMA2 algorithm and instruction set specific
188 BCJ filters which can improve compression ratio of executable 188 BCJ filters which can improve compression ratio of executable
189 code. The size of the kernel is about 30% smaller with XZ in 189 code. The size of the kernel is about 30% smaller with XZ in
190 comparison to gzip. On architectures for which there is a BCJ 190 comparison to gzip. On architectures for which there is a BCJ
191 filter (i386, x86_64, ARM, IA-64, PowerPC, and SPARC), XZ 191 filter (i386, x86_64, ARM, IA-64, PowerPC, and SPARC), XZ
192 will create a few percent smaller kernel than plain LZMA. 192 will create a few percent smaller kernel than plain LZMA.
193 193
194 The speed is about the same as with LZMA: The decompression 194 The speed is about the same as with LZMA: The decompression
195 speed of XZ is better than that of bzip2 but worse than gzip 195 speed of XZ is better than that of bzip2 but worse than gzip
196 and LZO. Compression is slow. 196 and LZO. Compression is slow.
197 197
198 config KERNEL_LZO 198 config KERNEL_LZO
199 bool "LZO" 199 bool "LZO"
200 depends on HAVE_KERNEL_LZO 200 depends on HAVE_KERNEL_LZO
201 help 201 help
202 Its compression ratio is the poorest among the choices. The kernel 202 Its compression ratio is the poorest among the choices. The kernel
203 size is about 10% bigger than gzip; however its speed 203 size is about 10% bigger than gzip; however its speed
204 (both compression and decompression) is the fastest. 204 (both compression and decompression) is the fastest.
205 205
206 endchoice 206 endchoice
207 207
208 config DEFAULT_HOSTNAME 208 config DEFAULT_HOSTNAME
209 string "Default hostname" 209 string "Default hostname"
210 default "(none)" 210 default "(none)"
211 help 211 help
212 This option determines the default system hostname before userspace 212 This option determines the default system hostname before userspace
213 calls sethostname(2). The kernel traditionally uses "(none)" here, 213 calls sethostname(2). The kernel traditionally uses "(none)" here,
214 but you may wish to use a different default here to make a minimal 214 but you may wish to use a different default here to make a minimal
215 system more usable with less configuration. 215 system more usable with less configuration.
216 216
217 config SWAP 217 config SWAP
218 bool "Support for paging of anonymous memory (swap)" 218 bool "Support for paging of anonymous memory (swap)"
219 depends on MMU && BLOCK 219 depends on MMU && BLOCK
220 default y 220 default y
221 help 221 help
222 This option allows you to choose whether you want to have support 222 This option allows you to choose whether you want to have support
223 for so called swap devices or swap files in your kernel that are 223 for so called swap devices or swap files in your kernel that are
224 used to provide more virtual memory than the actual RAM present 224 used to provide more virtual memory than the actual RAM present
225 in your computer. If unsure say Y. 225 in your computer. If unsure say Y.
226 226
227 config SYSVIPC 227 config SYSVIPC
228 bool "System V IPC" 228 bool "System V IPC"
229 ---help--- 229 ---help---
230 Inter Process Communication is a suite of library functions and 230 Inter Process Communication is a suite of library functions and
231 system calls which let processes (running programs) synchronize and 231 system calls which let processes (running programs) synchronize and
232 exchange information. It is generally considered to be a good thing, 232 exchange information. It is generally considered to be a good thing,
233 and some programs won't run unless you say Y here. In particular, if 233 and some programs won't run unless you say Y here. In particular, if
234 you want to run the DOS emulator dosemu under Linux (read the 234 you want to run the DOS emulator dosemu under Linux (read the
235 DOSEMU-HOWTO, available from <http://www.tldp.org/docs.html#howto>), 235 DOSEMU-HOWTO, available from <http://www.tldp.org/docs.html#howto>),
236 you'll need to say Y here. 236 you'll need to say Y here.
237 237
238 You can find documentation about IPC with "info ipc" and also in 238 You can find documentation about IPC with "info ipc" and also in
239 section 6.4 of the Linux Programmer's Guide, available from 239 section 6.4 of the Linux Programmer's Guide, available from
240 <http://www.tldp.org/guides.html>. 240 <http://www.tldp.org/guides.html>.
241 241
242 config SYSVIPC_SYSCTL 242 config SYSVIPC_SYSCTL
243 bool 243 bool
244 depends on SYSVIPC 244 depends on SYSVIPC
245 depends on SYSCTL 245 depends on SYSCTL
246 default y 246 default y
247 247
248 config POSIX_MQUEUE 248 config POSIX_MQUEUE
249 bool "POSIX Message Queues" 249 bool "POSIX Message Queues"
250 depends on NET && EXPERIMENTAL 250 depends on NET && EXPERIMENTAL
251 ---help--- 251 ---help---
252 POSIX variant of message queues is a part of IPC. In POSIX message 252 POSIX variant of message queues is a part of IPC. In POSIX message
253 queues every message has a priority which decides about succession 253 queues every message has a priority which decides about succession
254 of receiving it by a process. If you want to compile and run 254 of receiving it by a process. If you want to compile and run
255 programs written e.g. for Solaris with use of its POSIX message 255 programs written e.g. for Solaris with use of its POSIX message
256 queues (functions mq_*) say Y here. 256 queues (functions mq_*) say Y here.
257 257
258 POSIX message queues are visible as a filesystem called 'mqueue' 258 POSIX message queues are visible as a filesystem called 'mqueue'
259 and can be mounted somewhere if you want to do filesystem 259 and can be mounted somewhere if you want to do filesystem
260 operations on message queues. 260 operations on message queues.
261 261
262 If unsure, say Y. 262 If unsure, say Y.
263 263
264 config POSIX_MQUEUE_SYSCTL 264 config POSIX_MQUEUE_SYSCTL
265 bool 265 bool
266 depends on POSIX_MQUEUE 266 depends on POSIX_MQUEUE
267 depends on SYSCTL 267 depends on SYSCTL
268 default y 268 default y
269 269
270 config BSD_PROCESS_ACCT 270 config BSD_PROCESS_ACCT
271 bool "BSD Process Accounting" 271 bool "BSD Process Accounting"
272 help 272 help
273 If you say Y here, a user level program will be able to instruct the 273 If you say Y here, a user level program will be able to instruct the
274 kernel (via a special system call) to write process accounting 274 kernel (via a special system call) to write process accounting
275 information to a file: whenever a process exits, information about 275 information to a file: whenever a process exits, information about
276 that process will be appended to the file by the kernel. The 276 that process will be appended to the file by the kernel. The
277 information includes things such as creation time, owning user, 277 information includes things such as creation time, owning user,
278 command name, memory usage, controlling terminal etc. (the complete 278 command name, memory usage, controlling terminal etc. (the complete
279 list is in the struct acct in <file:include/linux/acct.h>). It is 279 list is in the struct acct in <file:include/linux/acct.h>). It is
280 up to the user level program to do useful things with this 280 up to the user level program to do useful things with this
281 information. This is generally a good idea, so say Y. 281 information. This is generally a good idea, so say Y.
282 282
283 config BSD_PROCESS_ACCT_V3 283 config BSD_PROCESS_ACCT_V3
284 bool "BSD Process Accounting version 3 file format" 284 bool "BSD Process Accounting version 3 file format"
285 depends on BSD_PROCESS_ACCT 285 depends on BSD_PROCESS_ACCT
286 default n 286 default n
287 help 287 help
288 If you say Y here, the process accounting information is written 288 If you say Y here, the process accounting information is written
289 in a new file format that also logs the process IDs of each 289 in a new file format that also logs the process IDs of each
290 process and it's parent. Note that this file format is incompatible 290 process and it's parent. Note that this file format is incompatible
291 with previous v0/v1/v2 file formats, so you will need updated tools 291 with previous v0/v1/v2 file formats, so you will need updated tools
292 for processing it. A preliminary version of these tools is available 292 for processing it. A preliminary version of these tools is available
293 at <http://www.gnu.org/software/acct/>. 293 at <http://www.gnu.org/software/acct/>.
294 294
295 config FHANDLE 295 config FHANDLE
296 bool "open by fhandle syscalls" 296 bool "open by fhandle syscalls"
297 select EXPORTFS 297 select EXPORTFS
298 help 298 help
299 If you say Y here, a user level program will be able to map 299 If you say Y here, a user level program will be able to map
300 file names to handle and then later use the handle for 300 file names to handle and then later use the handle for
301 different file system operations. This is useful in implementing 301 different file system operations. This is useful in implementing
302 userspace file servers, which now track files using handles instead 302 userspace file servers, which now track files using handles instead
303 of names. The handle would remain the same even if file names 303 of names. The handle would remain the same even if file names
304 get renamed. Enables open_by_handle_at(2) and name_to_handle_at(2) 304 get renamed. Enables open_by_handle_at(2) and name_to_handle_at(2)
305 syscalls. 305 syscalls.
306 306
307 config TASKSTATS 307 config TASKSTATS
308 bool "Export task/process statistics through netlink (EXPERIMENTAL)" 308 bool "Export task/process statistics through netlink (EXPERIMENTAL)"
309 depends on NET 309 depends on NET
310 default n 310 default n
311 help 311 help
312 Export selected statistics for tasks/processes through the 312 Export selected statistics for tasks/processes through the
313 generic netlink interface. Unlike BSD process accounting, the 313 generic netlink interface. Unlike BSD process accounting, the
314 statistics are available during the lifetime of tasks/processes as 314 statistics are available during the lifetime of tasks/processes as
315 responses to commands. Like BSD accounting, they are sent to user 315 responses to commands. Like BSD accounting, they are sent to user
316 space on task exit. 316 space on task exit.
317 317
318 Say N if unsure. 318 Say N if unsure.
319 319
320 config TASK_DELAY_ACCT 320 config TASK_DELAY_ACCT
321 bool "Enable per-task delay accounting (EXPERIMENTAL)" 321 bool "Enable per-task delay accounting (EXPERIMENTAL)"
322 depends on TASKSTATS 322 depends on TASKSTATS
323 help 323 help
324 Collect information on time spent by a task waiting for system 324 Collect information on time spent by a task waiting for system
325 resources like cpu, synchronous block I/O completion and swapping 325 resources like cpu, synchronous block I/O completion and swapping
326 in pages. Such statistics can help in setting a task's priorities 326 in pages. Such statistics can help in setting a task's priorities
327 relative to other tasks for cpu, io, rss limits etc. 327 relative to other tasks for cpu, io, rss limits etc.
328 328
329 Say N if unsure. 329 Say N if unsure.
330 330
331 config TASK_XACCT 331 config TASK_XACCT
332 bool "Enable extended accounting over taskstats (EXPERIMENTAL)" 332 bool "Enable extended accounting over taskstats (EXPERIMENTAL)"
333 depends on TASKSTATS 333 depends on TASKSTATS
334 help 334 help
335 Collect extended task accounting data and send the data 335 Collect extended task accounting data and send the data
336 to userland for processing over the taskstats interface. 336 to userland for processing over the taskstats interface.
337 337
338 Say N if unsure. 338 Say N if unsure.
339 339
340 config TASK_IO_ACCOUNTING 340 config TASK_IO_ACCOUNTING
341 bool "Enable per-task storage I/O accounting (EXPERIMENTAL)" 341 bool "Enable per-task storage I/O accounting (EXPERIMENTAL)"
342 depends on TASK_XACCT 342 depends on TASK_XACCT
343 help 343 help
344 Collect information on the number of bytes of storage I/O which this 344 Collect information on the number of bytes of storage I/O which this
345 task has caused. 345 task has caused.
346 346
347 Say N if unsure. 347 Say N if unsure.
348 348
349 config AUDIT 349 config AUDIT
350 bool "Auditing support" 350 bool "Auditing support"
351 depends on NET 351 depends on NET
352 help 352 help
353 Enable auditing infrastructure that can be used with another 353 Enable auditing infrastructure that can be used with another
354 kernel subsystem, such as SELinux (which requires this for 354 kernel subsystem, such as SELinux (which requires this for
355 logging of avc messages output). Does not do system-call 355 logging of avc messages output). Does not do system-call
356 auditing without CONFIG_AUDITSYSCALL. 356 auditing without CONFIG_AUDITSYSCALL.
357 357
358 config AUDITSYSCALL 358 config AUDITSYSCALL
359 bool "Enable system-call auditing support" 359 bool "Enable system-call auditing support"
360 depends on AUDIT && (X86 || PPC || S390 || IA64 || UML || SPARC64 || SUPERH || (ARM && AEABI && !OABI_COMPAT)) 360 depends on AUDIT && (X86 || PPC || S390 || IA64 || UML || SPARC64 || SUPERH || (ARM && AEABI && !OABI_COMPAT))
361 default y if SECURITY_SELINUX 361 default y if SECURITY_SELINUX
362 help 362 help
363 Enable low-overhead system-call auditing infrastructure that 363 Enable low-overhead system-call auditing infrastructure that
364 can be used independently or with another kernel subsystem, 364 can be used independently or with another kernel subsystem,
365 such as SELinux. 365 such as SELinux.
366 366
367 config AUDIT_WATCH 367 config AUDIT_WATCH
368 def_bool y 368 def_bool y
369 depends on AUDITSYSCALL 369 depends on AUDITSYSCALL
370 select FSNOTIFY 370 select FSNOTIFY
371 371
372 config AUDIT_TREE 372 config AUDIT_TREE
373 def_bool y 373 def_bool y
374 depends on AUDITSYSCALL 374 depends on AUDITSYSCALL
375 select FSNOTIFY 375 select FSNOTIFY
376 376
377 config AUDIT_LOGINUID_IMMUTABLE 377 config AUDIT_LOGINUID_IMMUTABLE
378 bool "Make audit loginuid immutable" 378 bool "Make audit loginuid immutable"
379 depends on AUDIT 379 depends on AUDIT
380 help 380 help
381 The config option toggles if a task setting its loginuid requires 381 The config option toggles if a task setting its loginuid requires
382 CAP_SYS_AUDITCONTROL or if that task should require no special permissions 382 CAP_SYS_AUDITCONTROL or if that task should require no special permissions
383 but should instead only allow setting its loginuid if it was never 383 but should instead only allow setting its loginuid if it was never
384 previously set. On systems which use systemd or a similar central 384 previously set. On systems which use systemd or a similar central
385 process to restart login services this should be set to true. On older 385 process to restart login services this should be set to true. On older
386 systems in which an admin would typically have to directly stop and 386 systems in which an admin would typically have to directly stop and
387 start processes this should be set to false. Setting this to true allows 387 start processes this should be set to false. Setting this to true allows
388 one to drop potentially dangerous capabilites from the login tasks, 388 one to drop potentially dangerous capabilites from the login tasks,
389 but may not be backwards compatible with older init systems. 389 but may not be backwards compatible with older init systems.
390 390
391 source "kernel/irq/Kconfig" 391 source "kernel/irq/Kconfig"
392 source "kernel/time/Kconfig" 392 source "kernel/time/Kconfig"
393 393
394 menu "RCU Subsystem" 394 menu "RCU Subsystem"
395 395
396 choice 396 choice
397 prompt "RCU Implementation" 397 prompt "RCU Implementation"
398 default TREE_RCU 398 default TREE_RCU
399 399
400 config TREE_RCU 400 config TREE_RCU
401 bool "Tree-based hierarchical RCU" 401 bool "Tree-based hierarchical RCU"
402 depends on !PREEMPT && SMP 402 depends on !PREEMPT && SMP
403 help 403 help
404 This option selects the RCU implementation that is 404 This option selects the RCU implementation that is
405 designed for very large SMP system with hundreds or 405 designed for very large SMP system with hundreds or
406 thousands of CPUs. It also scales down nicely to 406 thousands of CPUs. It also scales down nicely to
407 smaller systems. 407 smaller systems.
408 408
409 config TREE_PREEMPT_RCU 409 config TREE_PREEMPT_RCU
410 bool "Preemptible tree-based hierarchical RCU" 410 bool "Preemptible tree-based hierarchical RCU"
411 depends on PREEMPT && SMP 411 depends on PREEMPT && SMP
412 help 412 help
413 This option selects the RCU implementation that is 413 This option selects the RCU implementation that is
414 designed for very large SMP systems with hundreds or 414 designed for very large SMP systems with hundreds or
415 thousands of CPUs, but for which real-time response 415 thousands of CPUs, but for which real-time response
416 is also required. It also scales down nicely to 416 is also required. It also scales down nicely to
417 smaller systems. 417 smaller systems.
418 418
419 config TINY_RCU 419 config TINY_RCU
420 bool "UP-only small-memory-footprint RCU" 420 bool "UP-only small-memory-footprint RCU"
421 depends on !PREEMPT && !SMP 421 depends on !PREEMPT && !SMP
422 help 422 help
423 This option selects the RCU implementation that is 423 This option selects the RCU implementation that is
424 designed for UP systems from which real-time response 424 designed for UP systems from which real-time response
425 is not required. This option greatly reduces the 425 is not required. This option greatly reduces the
426 memory footprint of RCU. 426 memory footprint of RCU.
427 427
428 config TINY_PREEMPT_RCU 428 config TINY_PREEMPT_RCU
429 bool "Preemptible UP-only small-memory-footprint RCU" 429 bool "Preemptible UP-only small-memory-footprint RCU"
430 depends on PREEMPT && !SMP 430 depends on PREEMPT && !SMP
431 help 431 help
432 This option selects the RCU implementation that is designed 432 This option selects the RCU implementation that is designed
433 for real-time UP systems. This option greatly reduces the 433 for real-time UP systems. This option greatly reduces the
434 memory footprint of RCU. 434 memory footprint of RCU.
435 435
436 endchoice 436 endchoice
437 437
438 config PREEMPT_RCU 438 config PREEMPT_RCU
439 def_bool ( TREE_PREEMPT_RCU || TINY_PREEMPT_RCU ) 439 def_bool ( TREE_PREEMPT_RCU || TINY_PREEMPT_RCU )
440 help 440 help
441 This option enables preemptible-RCU code that is common between 441 This option enables preemptible-RCU code that is common between
442 the TREE_PREEMPT_RCU and TINY_PREEMPT_RCU implementations. 442 the TREE_PREEMPT_RCU and TINY_PREEMPT_RCU implementations.
443 443
444 config RCU_FANOUT 444 config RCU_FANOUT
445 int "Tree-based hierarchical RCU fanout value" 445 int "Tree-based hierarchical RCU fanout value"
446 range 2 64 if 64BIT 446 range 2 64 if 64BIT
447 range 2 32 if !64BIT 447 range 2 32 if !64BIT
448 depends on TREE_RCU || TREE_PREEMPT_RCU 448 depends on TREE_RCU || TREE_PREEMPT_RCU
449 default 64 if 64BIT 449 default 64 if 64BIT
450 default 32 if !64BIT 450 default 32 if !64BIT
451 help 451 help
452 This option controls the fanout of hierarchical implementations 452 This option controls the fanout of hierarchical implementations
453 of RCU, allowing RCU to work efficiently on machines with 453 of RCU, allowing RCU to work efficiently on machines with
454 large numbers of CPUs. This value must be at least the fourth 454 large numbers of CPUs. This value must be at least the fourth
455 root of NR_CPUS, which allows NR_CPUS to be insanely large. 455 root of NR_CPUS, which allows NR_CPUS to be insanely large.
456 The default value of RCU_FANOUT should be used for production 456 The default value of RCU_FANOUT should be used for production
457 systems, but if you are stress-testing the RCU implementation 457 systems, but if you are stress-testing the RCU implementation
458 itself, small RCU_FANOUT values allow you to test large-system 458 itself, small RCU_FANOUT values allow you to test large-system
459 code paths on small(er) systems. 459 code paths on small(er) systems.
460 460
461 Select a specific number if testing RCU itself. 461 Select a specific number if testing RCU itself.
462 Take the default if unsure. 462 Take the default if unsure.
463 463
464 config RCU_FANOUT_LEAF 464 config RCU_FANOUT_LEAF
465 int "Tree-based hierarchical RCU leaf-level fanout value" 465 int "Tree-based hierarchical RCU leaf-level fanout value"
466 range 2 RCU_FANOUT if 64BIT 466 range 2 RCU_FANOUT if 64BIT
467 range 2 RCU_FANOUT if !64BIT 467 range 2 RCU_FANOUT if !64BIT
468 depends on TREE_RCU || TREE_PREEMPT_RCU 468 depends on TREE_RCU || TREE_PREEMPT_RCU
469 default 16 469 default 16
470 help 470 help
471 This option controls the leaf-level fanout of hierarchical 471 This option controls the leaf-level fanout of hierarchical
472 implementations of RCU, and allows trading off cache misses 472 implementations of RCU, and allows trading off cache misses
473 against lock contention. Systems that synchronize their 473 against lock contention. Systems that synchronize their
474 scheduling-clock interrupts for energy-efficiency reasons will 474 scheduling-clock interrupts for energy-efficiency reasons will
475 want the default because the smaller leaf-level fanout keeps 475 want the default because the smaller leaf-level fanout keeps
476 lock contention levels acceptably low. Very large systems 476 lock contention levels acceptably low. Very large systems
477 (hundreds or thousands of CPUs) will instead want to set this 477 (hundreds or thousands of CPUs) will instead want to set this
478 value to the maximum value possible in order to reduce the 478 value to the maximum value possible in order to reduce the
479 number of cache misses incurred during RCU's grace-period 479 number of cache misses incurred during RCU's grace-period
480 initialization. These systems tend to run CPU-bound, and thus 480 initialization. These systems tend to run CPU-bound, and thus
481 are not helped by synchronized interrupts, and thus tend to 481 are not helped by synchronized interrupts, and thus tend to
482 skew them, which reduces lock contention enough that large 482 skew them, which reduces lock contention enough that large
483 leaf-level fanouts work well. 483 leaf-level fanouts work well.
484 484
485 Select a specific number if testing RCU itself. 485 Select a specific number if testing RCU itself.
486 486
487 Select the maximum permissible value for large systems. 487 Select the maximum permissible value for large systems.
488 488
489 Take the default if unsure. 489 Take the default if unsure.
490 490
491 config RCU_FANOUT_EXACT 491 config RCU_FANOUT_EXACT
492 bool "Disable tree-based hierarchical RCU auto-balancing" 492 bool "Disable tree-based hierarchical RCU auto-balancing"
493 depends on TREE_RCU || TREE_PREEMPT_RCU 493 depends on TREE_RCU || TREE_PREEMPT_RCU
494 default n 494 default n
495 help 495 help
496 This option forces use of the exact RCU_FANOUT value specified, 496 This option forces use of the exact RCU_FANOUT value specified,
497 regardless of imbalances in the hierarchy. This is useful for 497 regardless of imbalances in the hierarchy. This is useful for
498 testing RCU itself, and might one day be useful on systems with 498 testing RCU itself, and might one day be useful on systems with
499 strong NUMA behavior. 499 strong NUMA behavior.
500 500
501 Without RCU_FANOUT_EXACT, the code will balance the hierarchy. 501 Without RCU_FANOUT_EXACT, the code will balance the hierarchy.
502 502
503 Say N if unsure. 503 Say N if unsure.
504 504
505 config RCU_FAST_NO_HZ 505 config RCU_FAST_NO_HZ
506 bool "Accelerate last non-dyntick-idle CPU's grace periods" 506 bool "Accelerate last non-dyntick-idle CPU's grace periods"
507 depends on NO_HZ && SMP 507 depends on NO_HZ && SMP
508 default n 508 default n
509 help 509 help
510 This option causes RCU to attempt to accelerate grace periods 510 This option causes RCU to attempt to accelerate grace periods
511 in order to allow CPUs to enter dynticks-idle state more 511 in order to allow CPUs to enter dynticks-idle state more
512 quickly. On the other hand, this option increases the overhead 512 quickly. On the other hand, this option increases the overhead
513 of the dynticks-idle checking, particularly on systems with 513 of the dynticks-idle checking, particularly on systems with
514 large numbers of CPUs. 514 large numbers of CPUs.
515 515
516 Say Y if energy efficiency is critically important, particularly 516 Say Y if energy efficiency is critically important, particularly
517 if you have relatively few CPUs. 517 if you have relatively few CPUs.
518 518
519 Say N if you are unsure. 519 Say N if you are unsure.
520 520
521 config TREE_RCU_TRACE 521 config TREE_RCU_TRACE
522 def_bool RCU_TRACE && ( TREE_RCU || TREE_PREEMPT_RCU ) 522 def_bool RCU_TRACE && ( TREE_RCU || TREE_PREEMPT_RCU )
523 select DEBUG_FS 523 select DEBUG_FS
524 help 524 help
525 This option provides tracing for the TREE_RCU and 525 This option provides tracing for the TREE_RCU and
526 TREE_PREEMPT_RCU implementations, permitting Makefile to 526 TREE_PREEMPT_RCU implementations, permitting Makefile to
527 trivially select kernel/rcutree_trace.c. 527 trivially select kernel/rcutree_trace.c.
528 528
529 config RCU_BOOST 529 config RCU_BOOST
530 bool "Enable RCU priority boosting" 530 bool "Enable RCU priority boosting"
531 depends on RT_MUTEXES && PREEMPT_RCU 531 depends on RT_MUTEXES && PREEMPT_RCU
532 default n 532 default n
533 help 533 help
534 This option boosts the priority of preempted RCU readers that 534 This option boosts the priority of preempted RCU readers that
535 block the current preemptible RCU grace period for too long. 535 block the current preemptible RCU grace period for too long.
536 This option also prevents heavy loads from blocking RCU 536 This option also prevents heavy loads from blocking RCU
537 callback invocation for all flavors of RCU. 537 callback invocation for all flavors of RCU.
538 538
539 Say Y here if you are working with real-time apps or heavy loads 539 Say Y here if you are working with real-time apps or heavy loads
540 Say N here if you are unsure. 540 Say N here if you are unsure.
541 541
542 config RCU_BOOST_PRIO 542 config RCU_BOOST_PRIO
543 int "Real-time priority to boost RCU readers to" 543 int "Real-time priority to boost RCU readers to"
544 range 1 99 544 range 1 99
545 depends on RCU_BOOST 545 depends on RCU_BOOST
546 default 1 546 default 1
547 help 547 help
548 This option specifies the real-time priority to which long-term 548 This option specifies the real-time priority to which long-term
549 preempted RCU readers are to be boosted. If you are working 549 preempted RCU readers are to be boosted. If you are working
550 with a real-time application that has one or more CPU-bound 550 with a real-time application that has one or more CPU-bound
551 threads running at a real-time priority level, you should set 551 threads running at a real-time priority level, you should set
552 RCU_BOOST_PRIO to a priority higher then the highest-priority 552 RCU_BOOST_PRIO to a priority higher then the highest-priority
553 real-time CPU-bound thread. The default RCU_BOOST_PRIO value 553 real-time CPU-bound thread. The default RCU_BOOST_PRIO value
554 of 1 is appropriate in the common case, which is real-time 554 of 1 is appropriate in the common case, which is real-time
555 applications that do not have any CPU-bound threads. 555 applications that do not have any CPU-bound threads.
556 556
557 Some real-time applications might not have a single real-time 557 Some real-time applications might not have a single real-time
558 thread that saturates a given CPU, but instead might have 558 thread that saturates a given CPU, but instead might have
559 multiple real-time threads that, taken together, fully utilize 559 multiple real-time threads that, taken together, fully utilize
560 that CPU. In this case, you should set RCU_BOOST_PRIO to 560 that CPU. In this case, you should set RCU_BOOST_PRIO to
561 a priority higher than the lowest-priority thread that is 561 a priority higher than the lowest-priority thread that is
562 conspiring to prevent the CPU from running any non-real-time 562 conspiring to prevent the CPU from running any non-real-time
563 tasks. For example, if one thread at priority 10 and another 563 tasks. For example, if one thread at priority 10 and another
564 thread at priority 5 are between themselves fully consuming 564 thread at priority 5 are between themselves fully consuming
565 the CPU time on a given CPU, then RCU_BOOST_PRIO should be 565 the CPU time on a given CPU, then RCU_BOOST_PRIO should be
566 set to priority 6 or higher. 566 set to priority 6 or higher.
567 567
568 Specify the real-time priority, or take the default if unsure. 568 Specify the real-time priority, or take the default if unsure.
569 569
570 config RCU_BOOST_DELAY 570 config RCU_BOOST_DELAY
571 int "Milliseconds to delay boosting after RCU grace-period start" 571 int "Milliseconds to delay boosting after RCU grace-period start"
572 range 0 3000 572 range 0 3000
573 depends on RCU_BOOST 573 depends on RCU_BOOST
574 default 500 574 default 500
575 help 575 help
576 This option specifies the time to wait after the beginning of 576 This option specifies the time to wait after the beginning of
577 a given grace period before priority-boosting preempted RCU 577 a given grace period before priority-boosting preempted RCU
578 readers blocking that grace period. Note that any RCU reader 578 readers blocking that grace period. Note that any RCU reader
579 blocking an expedited RCU grace period is boosted immediately. 579 blocking an expedited RCU grace period is boosted immediately.
580 580
581 Accept the default if unsure. 581 Accept the default if unsure.
582 582
583 endmenu # "RCU Subsystem" 583 endmenu # "RCU Subsystem"
584 584
585 config IKCONFIG 585 config IKCONFIG
586 tristate "Kernel .config support" 586 tristate "Kernel .config support"
587 ---help--- 587 ---help---
588 This option enables the complete Linux kernel ".config" file 588 This option enables the complete Linux kernel ".config" file
589 contents to be saved in the kernel. It provides documentation 589 contents to be saved in the kernel. It provides documentation
590 of which kernel options are used in a running kernel or in an 590 of which kernel options are used in a running kernel or in an
591 on-disk kernel. This information can be extracted from the kernel 591 on-disk kernel. This information can be extracted from the kernel
592 image file with the script scripts/extract-ikconfig and used as 592 image file with the script scripts/extract-ikconfig and used as
593 input to rebuild the current kernel or to build another kernel. 593 input to rebuild the current kernel or to build another kernel.
594 It can also be extracted from a running kernel by reading 594 It can also be extracted from a running kernel by reading
595 /proc/config.gz if enabled (below). 595 /proc/config.gz if enabled (below).
596 596
597 config IKCONFIG_PROC 597 config IKCONFIG_PROC
598 bool "Enable access to .config through /proc/config.gz" 598 bool "Enable access to .config through /proc/config.gz"
599 depends on IKCONFIG && PROC_FS 599 depends on IKCONFIG && PROC_FS
600 ---help--- 600 ---help---
601 This option enables access to the kernel configuration file 601 This option enables access to the kernel configuration file
602 through /proc/config.gz. 602 through /proc/config.gz.
603 603
604 config LOG_BUF_SHIFT 604 config LOG_BUF_SHIFT
605 int "Kernel log buffer size (16 => 64KB, 17 => 128KB)" 605 int "Kernel log buffer size (16 => 64KB, 17 => 128KB)"
606 range 12 21 606 range 12 21
607 default 17 607 default 17
608 help 608 help
609 Select kernel log buffer size as a power of 2. 609 Select kernel log buffer size as a power of 2.
610 Examples: 610 Examples:
611 17 => 128 KB 611 17 => 128 KB
612 16 => 64 KB 612 16 => 64 KB
613 15 => 32 KB 613 15 => 32 KB
614 14 => 16 KB 614 14 => 16 KB
615 13 => 8 KB 615 13 => 8 KB
616 12 => 4 KB 616 12 => 4 KB
617 617
618 # 618 #
619 # Architectures with an unreliable sched_clock() should select this: 619 # Architectures with an unreliable sched_clock() should select this:
620 # 620 #
621 config HAVE_UNSTABLE_SCHED_CLOCK 621 config HAVE_UNSTABLE_SCHED_CLOCK
622 bool 622 bool
623 623
624 menuconfig CGROUPS 624 menuconfig CGROUPS
625 boolean "Control Group support" 625 boolean "Control Group support"
626 depends on EVENTFD 626 depends on EVENTFD
627 help 627 help
628 This option adds support for grouping sets of processes together, for 628 This option adds support for grouping sets of processes together, for
629 use with process control subsystems such as Cpusets, CFS, memory 629 use with process control subsystems such as Cpusets, CFS, memory
630 controls or device isolation. 630 controls or device isolation.
631 See 631 See
632 - Documentation/scheduler/sched-design-CFS.txt (CFS) 632 - Documentation/scheduler/sched-design-CFS.txt (CFS)
633 - Documentation/cgroups/ (features for grouping, isolation 633 - Documentation/cgroups/ (features for grouping, isolation
634 and resource control) 634 and resource control)
635 635
636 Say N if unsure. 636 Say N if unsure.
637 637
638 if CGROUPS 638 if CGROUPS
639 639
640 config CGROUP_DEBUG 640 config CGROUP_DEBUG
641 bool "Example debug cgroup subsystem" 641 bool "Example debug cgroup subsystem"
642 default n 642 default n
643 help 643 help
644 This option enables a simple cgroup subsystem that 644 This option enables a simple cgroup subsystem that
645 exports useful debugging information about the cgroups 645 exports useful debugging information about the cgroups
646 framework. 646 framework.
647 647
648 Say N if unsure. 648 Say N if unsure.
649 649
650 config CGROUP_FREEZER 650 config CGROUP_FREEZER
651 bool "Freezer cgroup subsystem" 651 bool "Freezer cgroup subsystem"
652 help 652 help
653 Provides a way to freeze and unfreeze all tasks in a 653 Provides a way to freeze and unfreeze all tasks in a
654 cgroup. 654 cgroup.
655 655
656 config CGROUP_DEVICE 656 config CGROUP_DEVICE
657 bool "Device controller for cgroups" 657 bool "Device controller for cgroups"
658 help 658 help
659 Provides a cgroup implementing whitelists for devices which 659 Provides a cgroup implementing whitelists for devices which
660 a process in the cgroup can mknod or open. 660 a process in the cgroup can mknod or open.
661 661
662 config CPUSETS 662 config CPUSETS
663 bool "Cpuset support" 663 bool "Cpuset support"
664 help 664 help
665 This option will let you create and manage CPUSETs which 665 This option will let you create and manage CPUSETs which
666 allow dynamically partitioning a system into sets of CPUs and 666 allow dynamically partitioning a system into sets of CPUs and
667 Memory Nodes and assigning tasks to run only within those sets. 667 Memory Nodes and assigning tasks to run only within those sets.
668 This is primarily useful on large SMP or NUMA systems. 668 This is primarily useful on large SMP or NUMA systems.
669 669
670 Say N if unsure. 670 Say N if unsure.
671 671
672 config PROC_PID_CPUSET 672 config PROC_PID_CPUSET
673 bool "Include legacy /proc/<pid>/cpuset file" 673 bool "Include legacy /proc/<pid>/cpuset file"
674 depends on CPUSETS 674 depends on CPUSETS
675 default y 675 default y
676 676
677 config CGROUP_CPUACCT 677 config CGROUP_CPUACCT
678 bool "Simple CPU accounting cgroup subsystem" 678 bool "Simple CPU accounting cgroup subsystem"
679 help 679 help
680 Provides a simple Resource Controller for monitoring the 680 Provides a simple Resource Controller for monitoring the
681 total CPU consumed by the tasks in a cgroup. 681 total CPU consumed by the tasks in a cgroup.
682 682
683 config RESOURCE_COUNTERS 683 config RESOURCE_COUNTERS
684 bool "Resource counters" 684 bool "Resource counters"
685 help 685 help
686 This option enables controller independent resource accounting 686 This option enables controller independent resource accounting
687 infrastructure that works with cgroups. 687 infrastructure that works with cgroups.
688 688
689 config MEMCG 689 config MEMCG
690 bool "Memory Resource Controller for Control Groups" 690 bool "Memory Resource Controller for Control Groups"
691 depends on RESOURCE_COUNTERS 691 depends on RESOURCE_COUNTERS
692 select MM_OWNER 692 select MM_OWNER
693 help 693 help
694 Provides a memory resource controller that manages both anonymous 694 Provides a memory resource controller that manages both anonymous
695 memory and page cache. (See Documentation/cgroups/memory.txt) 695 memory and page cache. (See Documentation/cgroups/memory.txt)
696 696
697 Note that setting this option increases fixed memory overhead 697 Note that setting this option increases fixed memory overhead
698 associated with each page of memory in the system. By this, 698 associated with each page of memory in the system. By this,
699 20(40)bytes/PAGE_SIZE on 32(64)bit system will be occupied by memory 699 20(40)bytes/PAGE_SIZE on 32(64)bit system will be occupied by memory
700 usage tracking struct at boot. Total amount of this is printed out 700 usage tracking struct at boot. Total amount of this is printed out
701 at boot. 701 at boot.
702 702
703 Only enable when you're ok with these trade offs and really 703 Only enable when you're ok with these trade offs and really
704 sure you need the memory resource controller. Even when you enable 704 sure you need the memory resource controller. Even when you enable
705 this, you can set "cgroup_disable=memory" at your boot option to 705 this, you can set "cgroup_disable=memory" at your boot option to
706 disable memory resource controller and you can avoid overheads. 706 disable memory resource controller and you can avoid overheads.
707 (and lose benefits of memory resource controller) 707 (and lose benefits of memory resource controller)
708 708
709 This config option also selects MM_OWNER config option, which 709 This config option also selects MM_OWNER config option, which
710 could in turn add some fork/exit overhead. 710 could in turn add some fork/exit overhead.
711 711
712 config MEMCG_SWAP 712 config MEMCG_SWAP
713 bool "Memory Resource Controller Swap Extension" 713 bool "Memory Resource Controller Swap Extension"
714 depends on MEMCG && SWAP 714 depends on MEMCG && SWAP
715 help 715 help
716 Add swap management feature to memory resource controller. When you 716 Add swap management feature to memory resource controller. When you
717 enable this, you can limit mem+swap usage per cgroup. In other words, 717 enable this, you can limit mem+swap usage per cgroup. In other words,
718 when you disable this, memory resource controller has no cares to 718 when you disable this, memory resource controller has no cares to
719 usage of swap...a process can exhaust all of the swap. This extension 719 usage of swap...a process can exhaust all of the swap. This extension
720 is useful when you want to avoid exhaustion swap but this itself 720 is useful when you want to avoid exhaustion swap but this itself
721 adds more overheads and consumes memory for remembering information. 721 adds more overheads and consumes memory for remembering information.
722 Especially if you use 32bit system or small memory system, please 722 Especially if you use 32bit system or small memory system, please
723 be careful about enabling this. When memory resource controller 723 be careful about enabling this. When memory resource controller
724 is disabled by boot option, this will be automatically disabled and 724 is disabled by boot option, this will be automatically disabled and
725 there will be no overhead from this. Even when you set this config=y, 725 there will be no overhead from this. Even when you set this config=y,
726 if boot option "swapaccount=0" is set, swap will not be accounted. 726 if boot option "swapaccount=0" is set, swap will not be accounted.
727 Now, memory usage of swap_cgroup is 2 bytes per entry. If swap page 727 Now, memory usage of swap_cgroup is 2 bytes per entry. If swap page
728 size is 4096bytes, 512k per 1Gbytes of swap. 728 size is 4096bytes, 512k per 1Gbytes of swap.
729 config MEMCG_SWAP_ENABLED 729 config MEMCG_SWAP_ENABLED
730 bool "Memory Resource Controller Swap Extension enabled by default" 730 bool "Memory Resource Controller Swap Extension enabled by default"
731 depends on MEMCG_SWAP 731 depends on MEMCG_SWAP
732 default y 732 default y
733 help 733 help
734 Memory Resource Controller Swap Extension comes with its price in 734 Memory Resource Controller Swap Extension comes with its price in
735 a bigger memory consumption. General purpose distribution kernels 735 a bigger memory consumption. General purpose distribution kernels
736 which want to enable the feature but keep it disabled by default 736 which want to enable the feature but keep it disabled by default
737 and let the user enable it by swapaccount boot command line 737 and let the user enable it by swapaccount boot command line
738 parameter should have this option unselected. 738 parameter should have this option unselected.
739 For those who want to have the feature enabled by default should 739 For those who want to have the feature enabled by default should
740 select this option (if, for some reason, they need to disable it 740 select this option (if, for some reason, they need to disable it
741 then swapaccount=0 does the trick). 741 then swapaccount=0 does the trick).
742 config MEMCG_KMEM 742 config MEMCG_KMEM
743 bool "Memory Resource Controller Kernel Memory accounting (EXPERIMENTAL)" 743 bool "Memory Resource Controller Kernel Memory accounting (EXPERIMENTAL)"
744 depends on MEMCG && EXPERIMENTAL 744 depends on MEMCG && EXPERIMENTAL
745 default n 745 default n
746 help 746 help
747 The Kernel Memory extension for Memory Resource Controller can limit 747 The Kernel Memory extension for Memory Resource Controller can limit
748 the amount of memory used by kernel objects in the system. Those are 748 the amount of memory used by kernel objects in the system. Those are
749 fundamentally different from the entities handled by the standard 749 fundamentally different from the entities handled by the standard
750 Memory Controller, which are page-based, and can be swapped. Users of 750 Memory Controller, which are page-based, and can be swapped. Users of
751 the kmem extension can use it to guarantee that no group of processes 751 the kmem extension can use it to guarantee that no group of processes
752 will ever exhaust kernel resources alone. 752 will ever exhaust kernel resources alone.
753 753
754 config CGROUP_HUGETLB 754 config CGROUP_HUGETLB
755 bool "HugeTLB Resource Controller for Control Groups" 755 bool "HugeTLB Resource Controller for Control Groups"
756 depends on RESOURCE_COUNTERS && HUGETLB_PAGE && EXPERIMENTAL 756 depends on RESOURCE_COUNTERS && HUGETLB_PAGE && EXPERIMENTAL
757 default n 757 default n
758 help 758 help
759 Provides a cgroup Resource Controller for HugeTLB pages. 759 Provides a cgroup Resource Controller for HugeTLB pages.
760 When you enable this, you can put a per cgroup limit on HugeTLB usage. 760 When you enable this, you can put a per cgroup limit on HugeTLB usage.
761 The limit is enforced during page fault. Since HugeTLB doesn't 761 The limit is enforced during page fault. Since HugeTLB doesn't
762 support page reclaim, enforcing the limit at page fault time implies 762 support page reclaim, enforcing the limit at page fault time implies
763 that, the application will get SIGBUS signal if it tries to access 763 that, the application will get SIGBUS signal if it tries to access
764 HugeTLB pages beyond its limit. This requires the application to know 764 HugeTLB pages beyond its limit. This requires the application to know
765 beforehand how much HugeTLB pages it would require for its use. The 765 beforehand how much HugeTLB pages it would require for its use. The
766 control group is tracked in the third page lru pointer. This means 766 control group is tracked in the third page lru pointer. This means
767 that we cannot use the controller with huge page less than 3 pages. 767 that we cannot use the controller with huge page less than 3 pages.
768 768
769 config CGROUP_PERF 769 config CGROUP_PERF
770 bool "Enable perf_event per-cpu per-container group (cgroup) monitoring" 770 bool "Enable perf_event per-cpu per-container group (cgroup) monitoring"
771 depends on PERF_EVENTS && CGROUPS 771 depends on PERF_EVENTS && CGROUPS
772 help 772 help
773 This option extends the per-cpu mode to restrict monitoring to 773 This option extends the per-cpu mode to restrict monitoring to
774 threads which belong to the cgroup specified and run on the 774 threads which belong to the cgroup specified and run on the
775 designated cpu. 775 designated cpu.
776 776
777 Say N if unsure. 777 Say N if unsure.
778 778
779 menuconfig CGROUP_SCHED 779 menuconfig CGROUP_SCHED
780 bool "Group CPU scheduler" 780 bool "Group CPU scheduler"
781 default n 781 default n
782 help 782 help
783 This feature lets CPU scheduler recognize task groups and control CPU 783 This feature lets CPU scheduler recognize task groups and control CPU
784 bandwidth allocation to such task groups. It uses cgroups to group 784 bandwidth allocation to such task groups. It uses cgroups to group
785 tasks. 785 tasks.
786 786
787 if CGROUP_SCHED 787 if CGROUP_SCHED
788 config FAIR_GROUP_SCHED 788 config FAIR_GROUP_SCHED
789 bool "Group scheduling for SCHED_OTHER" 789 bool "Group scheduling for SCHED_OTHER"
790 depends on CGROUP_SCHED 790 depends on CGROUP_SCHED
791 default CGROUP_SCHED 791 default CGROUP_SCHED
792 792
793 config CFS_BANDWIDTH 793 config CFS_BANDWIDTH
794 bool "CPU bandwidth provisioning for FAIR_GROUP_SCHED" 794 bool "CPU bandwidth provisioning for FAIR_GROUP_SCHED"
795 depends on EXPERIMENTAL 795 depends on EXPERIMENTAL
796 depends on FAIR_GROUP_SCHED 796 depends on FAIR_GROUP_SCHED
797 default n 797 default n
798 help 798 help
799 This option allows users to define CPU bandwidth rates (limits) for 799 This option allows users to define CPU bandwidth rates (limits) for
800 tasks running within the fair group scheduler. Groups with no limit 800 tasks running within the fair group scheduler. Groups with no limit
801 set are considered to be unconstrained and will run with no 801 set are considered to be unconstrained and will run with no
802 restriction. 802 restriction.
803 See tip/Documentation/scheduler/sched-bwc.txt for more information. 803 See tip/Documentation/scheduler/sched-bwc.txt for more information.
804 804
805 config RT_GROUP_SCHED 805 config RT_GROUP_SCHED
806 bool "Group scheduling for SCHED_RR/FIFO" 806 bool "Group scheduling for SCHED_RR/FIFO"
807 depends on EXPERIMENTAL 807 depends on EXPERIMENTAL
808 depends on CGROUP_SCHED 808 depends on CGROUP_SCHED
809 default n 809 default n
810 help 810 help
811 This feature lets you explicitly allocate real CPU bandwidth 811 This feature lets you explicitly allocate real CPU bandwidth
812 to task groups. If enabled, it will also make it impossible to 812 to task groups. If enabled, it will also make it impossible to
813 schedule realtime tasks for non-root users until you allocate 813 schedule realtime tasks for non-root users until you allocate
814 realtime bandwidth for them. 814 realtime bandwidth for them.
815 See Documentation/scheduler/sched-rt-group.txt for more information. 815 See Documentation/scheduler/sched-rt-group.txt for more information.
816 816
817 endif #CGROUP_SCHED 817 endif #CGROUP_SCHED
818 818
819 config BLK_CGROUP 819 config BLK_CGROUP
820 bool "Block IO controller" 820 bool "Block IO controller"
821 depends on BLOCK 821 depends on BLOCK
822 default n 822 default n
823 ---help--- 823 ---help---
824 Generic block IO controller cgroup interface. This is the common 824 Generic block IO controller cgroup interface. This is the common
825 cgroup interface which should be used by various IO controlling 825 cgroup interface which should be used by various IO controlling
826 policies. 826 policies.
827 827
828 Currently, CFQ IO scheduler uses it to recognize task groups and 828 Currently, CFQ IO scheduler uses it to recognize task groups and
829 control disk bandwidth allocation (proportional time slice allocation) 829 control disk bandwidth allocation (proportional time slice allocation)
830 to such task groups. It is also used by bio throttling logic in 830 to such task groups. It is also used by bio throttling logic in
831 block layer to implement upper limit in IO rates on a device. 831 block layer to implement upper limit in IO rates on a device.
832 832
833 This option only enables generic Block IO controller infrastructure. 833 This option only enables generic Block IO controller infrastructure.
834 One needs to also enable actual IO controlling logic/policy. For 834 One needs to also enable actual IO controlling logic/policy. For
835 enabling proportional weight division of disk bandwidth in CFQ, set 835 enabling proportional weight division of disk bandwidth in CFQ, set
836 CONFIG_CFQ_GROUP_IOSCHED=y; for enabling throttling policy, set 836 CONFIG_CFQ_GROUP_IOSCHED=y; for enabling throttling policy, set
837 CONFIG_BLK_DEV_THROTTLING=y. 837 CONFIG_BLK_DEV_THROTTLING=y.
838 838
839 See Documentation/cgroups/blkio-controller.txt for more information. 839 See Documentation/cgroups/blkio-controller.txt for more information.
840 840
841 config DEBUG_BLK_CGROUP 841 config DEBUG_BLK_CGROUP
842 bool "Enable Block IO controller debugging" 842 bool "Enable Block IO controller debugging"
843 depends on BLK_CGROUP 843 depends on BLK_CGROUP
844 default n 844 default n
845 ---help--- 845 ---help---
846 Enable some debugging help. Currently it exports additional stat 846 Enable some debugging help. Currently it exports additional stat
847 files in a cgroup which can be useful for debugging. 847 files in a cgroup which can be useful for debugging.
848 848
849 endif # CGROUPS 849 endif # CGROUPS
850 850
851 config CHECKPOINT_RESTORE 851 config CHECKPOINT_RESTORE
852 bool "Checkpoint/restore support" if EXPERT 852 bool "Checkpoint/restore support" if EXPERT
853 default n 853 default n
854 help 854 help
855 Enables additional kernel features in a sake of checkpoint/restore. 855 Enables additional kernel features in a sake of checkpoint/restore.
856 In particular it adds auxiliary prctl codes to setup process text, 856 In particular it adds auxiliary prctl codes to setup process text,
857 data and heap segment sizes, and a few additional /proc filesystem 857 data and heap segment sizes, and a few additional /proc filesystem
858 entries. 858 entries.
859 859
860 If unsure, say N here. 860 If unsure, say N here.
861 861
862 menuconfig NAMESPACES 862 menuconfig NAMESPACES
863 bool "Namespaces support" if EXPERT 863 bool "Namespaces support" if EXPERT
864 default !EXPERT 864 default !EXPERT
865 help 865 help
866 Provides the way to make tasks work with different objects using 866 Provides the way to make tasks work with different objects using
867 the same id. For example same IPC id may refer to different objects 867 the same id. For example same IPC id may refer to different objects
868 or same user id or pid may refer to different tasks when used in 868 or same user id or pid may refer to different tasks when used in
869 different namespaces. 869 different namespaces.
870 870
871 if NAMESPACES 871 if NAMESPACES
872 872
873 config UTS_NS 873 config UTS_NS
874 bool "UTS namespace" 874 bool "UTS namespace"
875 default y 875 default y
876 help 876 help
877 In this namespace tasks see different info provided with the 877 In this namespace tasks see different info provided with the
878 uname() system call 878 uname() system call
879 879
880 config IPC_NS 880 config IPC_NS
881 bool "IPC namespace" 881 bool "IPC namespace"
882 depends on (SYSVIPC || POSIX_MQUEUE) 882 depends on (SYSVIPC || POSIX_MQUEUE)
883 default y 883 default y
884 help 884 help
885 In this namespace tasks work with IPC ids which correspond to 885 In this namespace tasks work with IPC ids which correspond to
886 different IPC objects in different namespaces. 886 different IPC objects in different namespaces.
887 887
888 config USER_NS 888 config USER_NS
889 bool "User namespace (EXPERIMENTAL)" 889 bool "User namespace (EXPERIMENTAL)"
890 depends on EXPERIMENTAL 890 depends on EXPERIMENTAL
891 depends on UIDGID_CONVERTED 891 depends on UIDGID_CONVERTED
892 select UIDGID_STRICT_TYPE_CHECKS 892 select UIDGID_STRICT_TYPE_CHECKS
893 893
894 default n 894 default n
895 help 895 help
896 This allows containers, i.e. vservers, to use user namespaces 896 This allows containers, i.e. vservers, to use user namespaces
897 to provide different user info for different servers. 897 to provide different user info for different servers.
898 If unsure, say N. 898 If unsure, say N.
899 899
900 config PID_NS 900 config PID_NS
901 bool "PID Namespaces" 901 bool "PID Namespaces"
902 default y 902 default y
903 help 903 help
904 Support process id namespaces. This allows having multiple 904 Support process id namespaces. This allows having multiple
905 processes with the same pid as long as they are in different 905 processes with the same pid as long as they are in different
906 pid namespaces. This is a building block of containers. 906 pid namespaces. This is a building block of containers.
907 907
908 config NET_NS 908 config NET_NS
909 bool "Network namespace" 909 bool "Network namespace"
910 depends on NET 910 depends on NET
911 default y 911 default y
912 help 912 help
913 Allow user space to create what appear to be multiple instances 913 Allow user space to create what appear to be multiple instances
914 of the network stack. 914 of the network stack.
915 915
916 endif # NAMESPACES 916 endif # NAMESPACES
917 917
918 config UIDGID_CONVERTED 918 config UIDGID_CONVERTED
919 # True if all of the selected software conmponents are known 919 # True if all of the selected software conmponents are known
920 # to have uid_t and gid_t converted to kuid_t and kgid_t 920 # to have uid_t and gid_t converted to kuid_t and kgid_t
921 # where appropriate and are otherwise safe to use with 921 # where appropriate and are otherwise safe to use with
922 # the user namespace. 922 # the user namespace.
923 bool 923 bool
924 default y 924 default y
925 925
926 # List of kernel pieces that need user namespace work 926 # List of kernel pieces that need user namespace work
927 # Features 927 # Features
928 depends on SYSVIPC = n 928 depends on SYSVIPC = n
929 depends on IMA = n 929 depends on IMA = n
930 depends on EVM = n 930 depends on EVM = n
931 depends on KEYS = n 931 depends on KEYS = n
932 depends on AUDIT = n 932 depends on AUDIT = n
933 depends on AUDITSYSCALL = n 933 depends on AUDITSYSCALL = n
934 depends on TASKSTATS = n 934 depends on TASKSTATS = n
935 depends on TRACING = n 935 depends on TRACING = n
936 depends on FS_POSIX_ACL = n 936 depends on FS_POSIX_ACL = n
937 depends on QUOTA = n 937 depends on QUOTA = n
938 depends on QUOTACTL = n 938 depends on QUOTACTL = n
939 depends on BSD_PROCESS_ACCT = n 939 depends on BSD_PROCESS_ACCT = n
940 depends on DRM = n 940 depends on DRM = n
941 depends on PROC_EVENTS = n 941 depends on PROC_EVENTS = n
942 942
943 # Networking 943 # Networking
944 depends on NET_9P = n 944 depends on NET_9P = n
945 depends on AF_RXRPC = n 945 depends on AF_RXRPC = n
946 depends on DNS_RESOLVER = n 946 depends on DNS_RESOLVER = n
947 947
948 # Filesystems 948 # Filesystems
949 depends on USB_GADGETFS = n 949 depends on USB_GADGETFS = n
950 depends on USB_FUNCTIONFS = n 950 depends on USB_FUNCTIONFS = n
951 depends on DEVTMPFS = n 951 depends on DEVTMPFS = n
952 depends on XENFS = n 952 depends on XENFS = n
953 953
954 depends on 9P_FS = n 954 depends on 9P_FS = n
955 depends on ADFS_FS = n 955 depends on ADFS_FS = n
956 depends on AFFS_FS = n 956 depends on AFFS_FS = n
957 depends on AFS_FS = n 957 depends on AFS_FS = n
958 depends on AUTOFS4_FS = n 958 depends on AUTOFS4_FS = n
959 depends on BEFS_FS = n 959 depends on BEFS_FS = n
960 depends on BFS_FS = n 960 depends on BFS_FS = n
961 depends on BTRFS_FS = n 961 depends on BTRFS_FS = n
962 depends on CEPH_FS = n 962 depends on CEPH_FS = n
963 depends on CIFS = n 963 depends on CIFS = n
964 depends on CODA_FS = n 964 depends on CODA_FS = n
965 depends on CONFIGFS_FS = n 965 depends on CONFIGFS_FS = n
966 depends on CRAMFS = n 966 depends on CRAMFS = n
967 depends on DEBUG_FS = n
968 depends on ECRYPT_FS = n 967 depends on ECRYPT_FS = n
969 depends on EFS_FS = n 968 depends on EFS_FS = n
970 depends on EXOFS_FS = n 969 depends on EXOFS_FS = n
971 depends on FAT_FS = n 970 depends on FAT_FS = n
972 depends on FUSE_FS = n 971 depends on FUSE_FS = n
973 depends on GFS2_FS = n 972 depends on GFS2_FS = n
974 depends on HFS_FS = n 973 depends on HFS_FS = n
975 depends on HFSPLUS_FS = n 974 depends on HFSPLUS_FS = n
976 depends on HPFS_FS = n 975 depends on HPFS_FS = n
977 depends on HUGETLBFS = n 976 depends on HUGETLBFS = n
978 depends on ISO9660_FS = n 977 depends on ISO9660_FS = n
979 depends on JFFS2_FS = n 978 depends on JFFS2_FS = n
980 depends on JFS_FS = n 979 depends on JFS_FS = n
981 depends on LOGFS = n 980 depends on LOGFS = n
982 depends on MINIX_FS = n 981 depends on MINIX_FS = n
983 depends on NCP_FS = n 982 depends on NCP_FS = n
984 depends on NFSD = n 983 depends on NFSD = n
985 depends on NFS_FS = n 984 depends on NFS_FS = n
986 depends on NILFS2_FS = n 985 depends on NILFS2_FS = n
987 depends on NTFS_FS = n 986 depends on NTFS_FS = n
988 depends on OCFS2_FS = n 987 depends on OCFS2_FS = n
989 depends on OMFS_FS = n 988 depends on OMFS_FS = n
990 depends on QNX4FS_FS = n 989 depends on QNX4FS_FS = n
991 depends on QNX6FS_FS = n 990 depends on QNX6FS_FS = n
992 depends on REISERFS_FS = n 991 depends on REISERFS_FS = n
993 depends on SQUASHFS = n 992 depends on SQUASHFS = n
994 depends on SYSV_FS = n 993 depends on SYSV_FS = n
995 depends on UBIFS_FS = n 994 depends on UBIFS_FS = n
996 depends on UDF_FS = n 995 depends on UDF_FS = n
997 depends on UFS_FS = n 996 depends on UFS_FS = n
998 depends on VXFS_FS = n 997 depends on VXFS_FS = n
999 depends on XFS_FS = n 998 depends on XFS_FS = n
1000 999
1001 depends on !UML || HOSTFS = n 1000 depends on !UML || HOSTFS = n
1002 1001
1003 # The rare drivers that won't build 1002 # The rare drivers that won't build
1004 depends on INFINIBAND_QIB = n 1003 depends on INFINIBAND_QIB = n
1005 depends on BLK_DEV_LOOP = n 1004 depends on BLK_DEV_LOOP = n
1006 depends on ANDROID_BINDER_IPC = n 1005 depends on ANDROID_BINDER_IPC = n
1007 1006
1008 # Security modules 1007 # Security modules
1009 depends on SECURITY_TOMOYO = n 1008 depends on SECURITY_TOMOYO = n
1010 depends on SECURITY_APPARMOR = n 1009 depends on SECURITY_APPARMOR = n
1011 1010
1012 config UIDGID_STRICT_TYPE_CHECKS 1011 config UIDGID_STRICT_TYPE_CHECKS
1013 bool "Require conversions between uid/gids and their internal representation" 1012 bool "Require conversions between uid/gids and their internal representation"
1014 depends on UIDGID_CONVERTED 1013 depends on UIDGID_CONVERTED
1015 default n 1014 default n
1016 help 1015 help
1017 While the nececessary conversions are being added to all subsystems this option allows 1016 While the nececessary conversions are being added to all subsystems this option allows
1018 the code to continue to build for unconverted subsystems. 1017 the code to continue to build for unconverted subsystems.
1019 1018
1020 Say Y here if you want the strict type checking enabled 1019 Say Y here if you want the strict type checking enabled
1021 1020
1022 config SCHED_AUTOGROUP 1021 config SCHED_AUTOGROUP
1023 bool "Automatic process group scheduling" 1022 bool "Automatic process group scheduling"
1024 select EVENTFD 1023 select EVENTFD
1025 select CGROUPS 1024 select CGROUPS
1026 select CGROUP_SCHED 1025 select CGROUP_SCHED
1027 select FAIR_GROUP_SCHED 1026 select FAIR_GROUP_SCHED
1028 help 1027 help
1029 This option optimizes the scheduler for common desktop workloads by 1028 This option optimizes the scheduler for common desktop workloads by
1030 automatically creating and populating task groups. This separation 1029 automatically creating and populating task groups. This separation
1031 of workloads isolates aggressive CPU burners (like build jobs) from 1030 of workloads isolates aggressive CPU burners (like build jobs) from
1032 desktop applications. Task group autogeneration is currently based 1031 desktop applications. Task group autogeneration is currently based
1033 upon task session. 1032 upon task session.
1034 1033
1035 config MM_OWNER 1034 config MM_OWNER
1036 bool 1035 bool
1037 1036
1038 config SYSFS_DEPRECATED 1037 config SYSFS_DEPRECATED
1039 bool "Enable deprecated sysfs features to support old userspace tools" 1038 bool "Enable deprecated sysfs features to support old userspace tools"
1040 depends on SYSFS 1039 depends on SYSFS
1041 default n 1040 default n
1042 help 1041 help
1043 This option adds code that switches the layout of the "block" class 1042 This option adds code that switches the layout of the "block" class
1044 devices, to not show up in /sys/class/block/, but only in 1043 devices, to not show up in /sys/class/block/, but only in
1045 /sys/block/. 1044 /sys/block/.
1046 1045
1047 This switch is only active when the sysfs.deprecated=1 boot option is 1046 This switch is only active when the sysfs.deprecated=1 boot option is
1048 passed or the SYSFS_DEPRECATED_V2 option is set. 1047 passed or the SYSFS_DEPRECATED_V2 option is set.
1049 1048
1050 This option allows new kernels to run on old distributions and tools, 1049 This option allows new kernels to run on old distributions and tools,
1051 which might get confused by /sys/class/block/. Since 2007/2008 all 1050 which might get confused by /sys/class/block/. Since 2007/2008 all
1052 major distributions and tools handle this just fine. 1051 major distributions and tools handle this just fine.
1053 1052
1054 Recent distributions and userspace tools after 2009/2010 depend on 1053 Recent distributions and userspace tools after 2009/2010 depend on
1055 the existence of /sys/class/block/, and will not work with this 1054 the existence of /sys/class/block/, and will not work with this
1056 option enabled. 1055 option enabled.
1057 1056
1058 Only if you are using a new kernel on an old distribution, you might 1057 Only if you are using a new kernel on an old distribution, you might
1059 need to say Y here. 1058 need to say Y here.
1060 1059
1061 config SYSFS_DEPRECATED_V2 1060 config SYSFS_DEPRECATED_V2
1062 bool "Enable deprecated sysfs features by default" 1061 bool "Enable deprecated sysfs features by default"
1063 default n 1062 default n
1064 depends on SYSFS 1063 depends on SYSFS
1065 depends on SYSFS_DEPRECATED 1064 depends on SYSFS_DEPRECATED
1066 help 1065 help
1067 Enable deprecated sysfs by default. 1066 Enable deprecated sysfs by default.
1068 1067
1069 See the CONFIG_SYSFS_DEPRECATED option for more details about this 1068 See the CONFIG_SYSFS_DEPRECATED option for more details about this
1070 option. 1069 option.
1071 1070
1072 Only if you are using a new kernel on an old distribution, you might 1071 Only if you are using a new kernel on an old distribution, you might
1073 need to say Y here. Even then, odds are you would not need it 1072 need to say Y here. Even then, odds are you would not need it
1074 enabled, you can always pass the boot option if absolutely necessary. 1073 enabled, you can always pass the boot option if absolutely necessary.
1075 1074
1076 config RELAY 1075 config RELAY
1077 bool "Kernel->user space relay support (formerly relayfs)" 1076 bool "Kernel->user space relay support (formerly relayfs)"
1078 help 1077 help
1079 This option enables support for relay interface support in 1078 This option enables support for relay interface support in
1080 certain file systems (such as debugfs). 1079 certain file systems (such as debugfs).
1081 It is designed to provide an efficient mechanism for tools and 1080 It is designed to provide an efficient mechanism for tools and
1082 facilities to relay large amounts of data from kernel space to 1081 facilities to relay large amounts of data from kernel space to
1083 user space. 1082 user space.
1084 1083
1085 If unsure, say N. 1084 If unsure, say N.
1086 1085
1087 config BLK_DEV_INITRD 1086 config BLK_DEV_INITRD
1088 bool "Initial RAM filesystem and RAM disk (initramfs/initrd) support" 1087 bool "Initial RAM filesystem and RAM disk (initramfs/initrd) support"
1089 depends on BROKEN || !FRV 1088 depends on BROKEN || !FRV
1090 help 1089 help
1091 The initial RAM filesystem is a ramfs which is loaded by the 1090 The initial RAM filesystem is a ramfs which is loaded by the
1092 boot loader (loadlin or lilo) and that is mounted as root 1091 boot loader (loadlin or lilo) and that is mounted as root
1093 before the normal boot procedure. It is typically used to 1092 before the normal boot procedure. It is typically used to
1094 load modules needed to mount the "real" root file system, 1093 load modules needed to mount the "real" root file system,
1095 etc. See <file:Documentation/initrd.txt> for details. 1094 etc. See <file:Documentation/initrd.txt> for details.
1096 1095
1097 If RAM disk support (BLK_DEV_RAM) is also included, this 1096 If RAM disk support (BLK_DEV_RAM) is also included, this
1098 also enables initial RAM disk (initrd) support and adds 1097 also enables initial RAM disk (initrd) support and adds
1099 15 Kbytes (more on some other architectures) to the kernel size. 1098 15 Kbytes (more on some other architectures) to the kernel size.
1100 1099
1101 If unsure say Y. 1100 If unsure say Y.
1102 1101
1103 if BLK_DEV_INITRD 1102 if BLK_DEV_INITRD
1104 1103
1105 source "usr/Kconfig" 1104 source "usr/Kconfig"
1106 1105
1107 endif 1106 endif
1108 1107
1109 config CC_OPTIMIZE_FOR_SIZE 1108 config CC_OPTIMIZE_FOR_SIZE
1110 bool "Optimize for size" 1109 bool "Optimize for size"
1111 help 1110 help
1112 Enabling this option will pass "-Os" instead of "-O2" to gcc 1111 Enabling this option will pass "-Os" instead of "-O2" to gcc
1113 resulting in a smaller kernel. 1112 resulting in a smaller kernel.
1114 1113
1115 If unsure, say Y. 1114 If unsure, say Y.
1116 1115
1117 config SYSCTL 1116 config SYSCTL
1118 bool 1117 bool
1119 1118
1120 config ANON_INODES 1119 config ANON_INODES
1121 bool 1120 bool
1122 1121
1123 menuconfig EXPERT 1122 menuconfig EXPERT
1124 bool "Configure standard kernel features (expert users)" 1123 bool "Configure standard kernel features (expert users)"
1125 # Unhide debug options, to make the on-by-default options visible 1124 # Unhide debug options, to make the on-by-default options visible
1126 select DEBUG_KERNEL 1125 select DEBUG_KERNEL
1127 help 1126 help
1128 This option allows certain base kernel options and settings 1127 This option allows certain base kernel options and settings
1129 to be disabled or tweaked. This is for specialized 1128 to be disabled or tweaked. This is for specialized
1130 environments which can tolerate a "non-standard" kernel. 1129 environments which can tolerate a "non-standard" kernel.
1131 Only use this if you really know what you are doing. 1130 Only use this if you really know what you are doing.
1132 1131
1133 config UID16 1132 config UID16
1134 bool "Enable 16-bit UID system calls" if EXPERT 1133 bool "Enable 16-bit UID system calls" if EXPERT
1135 depends on ARM || BLACKFIN || CRIS || FRV || H8300 || X86_32 || M68K || (S390 && !64BIT) || SUPERH || SPARC32 || (SPARC64 && COMPAT) || UML || (X86_64 && IA32_EMULATION) 1134 depends on ARM || BLACKFIN || CRIS || FRV || H8300 || X86_32 || M68K || (S390 && !64BIT) || SUPERH || SPARC32 || (SPARC64 && COMPAT) || UML || (X86_64 && IA32_EMULATION)
1136 default y 1135 default y
1137 help 1136 help
1138 This enables the legacy 16-bit UID syscall wrappers. 1137 This enables the legacy 16-bit UID syscall wrappers.
1139 1138
1140 config SYSCTL_SYSCALL 1139 config SYSCTL_SYSCALL
1141 bool "Sysctl syscall support" if EXPERT 1140 bool "Sysctl syscall support" if EXPERT
1142 depends on PROC_SYSCTL 1141 depends on PROC_SYSCTL
1143 default n 1142 default n
1144 select SYSCTL 1143 select SYSCTL
1145 ---help--- 1144 ---help---
1146 sys_sysctl uses binary paths that have been found challenging 1145 sys_sysctl uses binary paths that have been found challenging
1147 to properly maintain and use. The interface in /proc/sys 1146 to properly maintain and use. The interface in /proc/sys
1148 using paths with ascii names is now the primary path to this 1147 using paths with ascii names is now the primary path to this
1149 information. 1148 information.
1150 1149
1151 Almost nothing using the binary sysctl interface so if you are 1150 Almost nothing using the binary sysctl interface so if you are
1152 trying to save some space it is probably safe to disable this, 1151 trying to save some space it is probably safe to disable this,
1153 making your kernel marginally smaller. 1152 making your kernel marginally smaller.
1154 1153
1155 If unsure say N here. 1154 If unsure say N here.
1156 1155
1157 config KALLSYMS 1156 config KALLSYMS
1158 bool "Load all symbols for debugging/ksymoops" if EXPERT 1157 bool "Load all symbols for debugging/ksymoops" if EXPERT
1159 default y 1158 default y
1160 help 1159 help
1161 Say Y here to let the kernel print out symbolic crash information and 1160 Say Y here to let the kernel print out symbolic crash information and
1162 symbolic stack backtraces. This increases the size of the kernel 1161 symbolic stack backtraces. This increases the size of the kernel
1163 somewhat, as all symbols have to be loaded into the kernel image. 1162 somewhat, as all symbols have to be loaded into the kernel image.
1164 1163
1165 config KALLSYMS_ALL 1164 config KALLSYMS_ALL
1166 bool "Include all symbols in kallsyms" 1165 bool "Include all symbols in kallsyms"
1167 depends on DEBUG_KERNEL && KALLSYMS 1166 depends on DEBUG_KERNEL && KALLSYMS
1168 help 1167 help
1169 Normally kallsyms only contains the symbols of functions for nicer 1168 Normally kallsyms only contains the symbols of functions for nicer
1170 OOPS messages and backtraces (i.e., symbols from the text and inittext 1169 OOPS messages and backtraces (i.e., symbols from the text and inittext
1171 sections). This is sufficient for most cases. And only in very rare 1170 sections). This is sufficient for most cases. And only in very rare
1172 cases (e.g., when a debugger is used) all symbols are required (e.g., 1171 cases (e.g., when a debugger is used) all symbols are required (e.g.,
1173 names of variables from the data sections, etc). 1172 names of variables from the data sections, etc).
1174 1173
1175 This option makes sure that all symbols are loaded into the kernel 1174 This option makes sure that all symbols are loaded into the kernel
1176 image (i.e., symbols from all sections) in cost of increased kernel 1175 image (i.e., symbols from all sections) in cost of increased kernel
1177 size (depending on the kernel configuration, it may be 300KiB or 1176 size (depending on the kernel configuration, it may be 300KiB or
1178 something like this). 1177 something like this).
1179 1178
1180 Say N unless you really need all symbols. 1179 Say N unless you really need all symbols.
1181 1180
1182 config HOTPLUG 1181 config HOTPLUG
1183 bool "Support for hot-pluggable devices" if EXPERT 1182 bool "Support for hot-pluggable devices" if EXPERT
1184 default y 1183 default y
1185 help 1184 help
1186 This option is provided for the case where no hotplug or uevent 1185 This option is provided for the case where no hotplug or uevent
1187 capabilities is wanted by the kernel. You should only consider 1186 capabilities is wanted by the kernel. You should only consider
1188 disabling this option for embedded systems that do not use modules, a 1187 disabling this option for embedded systems that do not use modules, a
1189 dynamic /dev tree, or dynamic device discovery. Just say Y. 1188 dynamic /dev tree, or dynamic device discovery. Just say Y.
1190 1189
1191 config PRINTK 1190 config PRINTK
1192 default y 1191 default y
1193 bool "Enable support for printk" if EXPERT 1192 bool "Enable support for printk" if EXPERT
1194 help 1193 help
1195 This option enables normal printk support. Removing it 1194 This option enables normal printk support. Removing it
1196 eliminates most of the message strings from the kernel image 1195 eliminates most of the message strings from the kernel image
1197 and makes the kernel more or less silent. As this makes it 1196 and makes the kernel more or less silent. As this makes it
1198 very difficult to diagnose system problems, saying N here is 1197 very difficult to diagnose system problems, saying N here is
1199 strongly discouraged. 1198 strongly discouraged.
1200 1199
1201 config BUG 1200 config BUG
1202 bool "BUG() support" if EXPERT 1201 bool "BUG() support" if EXPERT
1203 default y 1202 default y
1204 help 1203 help
1205 Disabling this option eliminates support for BUG and WARN, reducing 1204 Disabling this option eliminates support for BUG and WARN, reducing
1206 the size of your kernel image and potentially quietly ignoring 1205 the size of your kernel image and potentially quietly ignoring
1207 numerous fatal conditions. You should only consider disabling this 1206 numerous fatal conditions. You should only consider disabling this
1208 option for embedded systems with no facilities for reporting errors. 1207 option for embedded systems with no facilities for reporting errors.
1209 Just say Y. 1208 Just say Y.
1210 1209
1211 config ELF_CORE 1210 config ELF_CORE
1212 default y 1211 default y
1213 bool "Enable ELF core dumps" if EXPERT 1212 bool "Enable ELF core dumps" if EXPERT
1214 help 1213 help
1215 Enable support for generating core dumps. Disabling saves about 4k. 1214 Enable support for generating core dumps. Disabling saves about 4k.
1216 1215
1217 1216
1218 config PCSPKR_PLATFORM 1217 config PCSPKR_PLATFORM
1219 bool "Enable PC-Speaker support" if EXPERT 1218 bool "Enable PC-Speaker support" if EXPERT
1220 depends on HAVE_PCSPKR_PLATFORM 1219 depends on HAVE_PCSPKR_PLATFORM
1221 select I8253_LOCK 1220 select I8253_LOCK
1222 default y 1221 default y
1223 help 1222 help
1224 This option allows to disable the internal PC-Speaker 1223 This option allows to disable the internal PC-Speaker
1225 support, saving some memory. 1224 support, saving some memory.
1226 1225
1227 config HAVE_PCSPKR_PLATFORM 1226 config HAVE_PCSPKR_PLATFORM
1228 bool 1227 bool
1229 1228
1230 config BASE_FULL 1229 config BASE_FULL
1231 default y 1230 default y
1232 bool "Enable full-sized data structures for core" if EXPERT 1231 bool "Enable full-sized data structures for core" if EXPERT
1233 help 1232 help
1234 Disabling this option reduces the size of miscellaneous core 1233 Disabling this option reduces the size of miscellaneous core
1235 kernel data structures. This saves memory on small machines, 1234 kernel data structures. This saves memory on small machines,
1236 but may reduce performance. 1235 but may reduce performance.
1237 1236
1238 config FUTEX 1237 config FUTEX
1239 bool "Enable futex support" if EXPERT 1238 bool "Enable futex support" if EXPERT
1240 default y 1239 default y
1241 select RT_MUTEXES 1240 select RT_MUTEXES
1242 help 1241 help
1243 Disabling this option will cause the kernel to be built without 1242 Disabling this option will cause the kernel to be built without
1244 support for "fast userspace mutexes". The resulting kernel may not 1243 support for "fast userspace mutexes". The resulting kernel may not
1245 run glibc-based applications correctly. 1244 run glibc-based applications correctly.
1246 1245
1247 config EPOLL 1246 config EPOLL
1248 bool "Enable eventpoll support" if EXPERT 1247 bool "Enable eventpoll support" if EXPERT
1249 default y 1248 default y
1250 select ANON_INODES 1249 select ANON_INODES
1251 help 1250 help
1252 Disabling this option will cause the kernel to be built without 1251 Disabling this option will cause the kernel to be built without
1253 support for epoll family of system calls. 1252 support for epoll family of system calls.
1254 1253
1255 config SIGNALFD 1254 config SIGNALFD
1256 bool "Enable signalfd() system call" if EXPERT 1255 bool "Enable signalfd() system call" if EXPERT
1257 select ANON_INODES 1256 select ANON_INODES
1258 default y 1257 default y
1259 help 1258 help
1260 Enable the signalfd() system call that allows to receive signals 1259 Enable the signalfd() system call that allows to receive signals
1261 on a file descriptor. 1260 on a file descriptor.
1262 1261
1263 If unsure, say Y. 1262 If unsure, say Y.
1264 1263
1265 config TIMERFD 1264 config TIMERFD
1266 bool "Enable timerfd() system call" if EXPERT 1265 bool "Enable timerfd() system call" if EXPERT
1267 select ANON_INODES 1266 select ANON_INODES
1268 default y 1267 default y
1269 help 1268 help
1270 Enable the timerfd() system call that allows to receive timer 1269 Enable the timerfd() system call that allows to receive timer
1271 events on a file descriptor. 1270 events on a file descriptor.
1272 1271
1273 If unsure, say Y. 1272 If unsure, say Y.
1274 1273
1275 config EVENTFD 1274 config EVENTFD
1276 bool "Enable eventfd() system call" if EXPERT 1275 bool "Enable eventfd() system call" if EXPERT
1277 select ANON_INODES 1276 select ANON_INODES
1278 default y 1277 default y
1279 help 1278 help
1280 Enable the eventfd() system call that allows to receive both 1279 Enable the eventfd() system call that allows to receive both
1281 kernel notification (ie. KAIO) or userspace notifications. 1280 kernel notification (ie. KAIO) or userspace notifications.
1282 1281
1283 If unsure, say Y. 1282 If unsure, say Y.
1284 1283
1285 config SHMEM 1284 config SHMEM
1286 bool "Use full shmem filesystem" if EXPERT 1285 bool "Use full shmem filesystem" if EXPERT
1287 default y 1286 default y
1288 depends on MMU 1287 depends on MMU
1289 help 1288 help
1290 The shmem is an internal filesystem used to manage shared memory. 1289 The shmem is an internal filesystem used to manage shared memory.
1291 It is backed by swap and manages resource limits. It is also exported 1290 It is backed by swap and manages resource limits. It is also exported
1292 to userspace as tmpfs if TMPFS is enabled. Disabling this 1291 to userspace as tmpfs if TMPFS is enabled. Disabling this
1293 option replaces shmem and tmpfs with the much simpler ramfs code, 1292 option replaces shmem and tmpfs with the much simpler ramfs code,
1294 which may be appropriate on small systems without swap. 1293 which may be appropriate on small systems without swap.
1295 1294
1296 config AIO 1295 config AIO
1297 bool "Enable AIO support" if EXPERT 1296 bool "Enable AIO support" if EXPERT
1298 default y 1297 default y
1299 help 1298 help
1300 This option enables POSIX asynchronous I/O which may by used 1299 This option enables POSIX asynchronous I/O which may by used
1301 by some high performance threaded applications. Disabling 1300 by some high performance threaded applications. Disabling
1302 this option saves about 7k. 1301 this option saves about 7k.
1303 1302
1304 config EMBEDDED 1303 config EMBEDDED
1305 bool "Embedded system" 1304 bool "Embedded system"
1306 select EXPERT 1305 select EXPERT
1307 help 1306 help
1308 This option should be enabled if compiling the kernel for 1307 This option should be enabled if compiling the kernel for
1309 an embedded system so certain expert options are available 1308 an embedded system so certain expert options are available
1310 for configuration. 1309 for configuration.
1311 1310
1312 config HAVE_PERF_EVENTS 1311 config HAVE_PERF_EVENTS
1313 bool 1312 bool
1314 help 1313 help
1315 See tools/perf/design.txt for details. 1314 See tools/perf/design.txt for details.
1316 1315
1317 config PERF_USE_VMALLOC 1316 config PERF_USE_VMALLOC
1318 bool 1317 bool
1319 help 1318 help
1320 See tools/perf/design.txt for details 1319 See tools/perf/design.txt for details
1321 1320
1322 menu "Kernel Performance Events And Counters" 1321 menu "Kernel Performance Events And Counters"
1323 1322
1324 config PERF_EVENTS 1323 config PERF_EVENTS
1325 bool "Kernel performance events and counters" 1324 bool "Kernel performance events and counters"
1326 default y if PROFILING 1325 default y if PROFILING
1327 depends on HAVE_PERF_EVENTS 1326 depends on HAVE_PERF_EVENTS
1328 select ANON_INODES 1327 select ANON_INODES
1329 select IRQ_WORK 1328 select IRQ_WORK
1330 help 1329 help
1331 Enable kernel support for various performance events provided 1330 Enable kernel support for various performance events provided
1332 by software and hardware. 1331 by software and hardware.
1333 1332
1334 Software events are supported either built-in or via the 1333 Software events are supported either built-in or via the
1335 use of generic tracepoints. 1334 use of generic tracepoints.
1336 1335
1337 Most modern CPUs support performance events via performance 1336 Most modern CPUs support performance events via performance
1338 counter registers. These registers count the number of certain 1337 counter registers. These registers count the number of certain
1339 types of hw events: such as instructions executed, cachemisses 1338 types of hw events: such as instructions executed, cachemisses
1340 suffered, or branches mis-predicted - without slowing down the 1339 suffered, or branches mis-predicted - without slowing down the
1341 kernel or applications. These registers can also trigger interrupts 1340 kernel or applications. These registers can also trigger interrupts
1342 when a threshold number of events have passed - and can thus be 1341 when a threshold number of events have passed - and can thus be
1343 used to profile the code that runs on that CPU. 1342 used to profile the code that runs on that CPU.
1344 1343
1345 The Linux Performance Event subsystem provides an abstraction of 1344 The Linux Performance Event subsystem provides an abstraction of
1346 these software and hardware event capabilities, available via a 1345 these software and hardware event capabilities, available via a
1347 system call and used by the "perf" utility in tools/perf/. It 1346 system call and used by the "perf" utility in tools/perf/. It
1348 provides per task and per CPU counters, and it provides event 1347 provides per task and per CPU counters, and it provides event
1349 capabilities on top of those. 1348 capabilities on top of those.
1350 1349
1351 Say Y if unsure. 1350 Say Y if unsure.
1352 1351
1353 config DEBUG_PERF_USE_VMALLOC 1352 config DEBUG_PERF_USE_VMALLOC
1354 default n 1353 default n
1355 bool "Debug: use vmalloc to back perf mmap() buffers" 1354 bool "Debug: use vmalloc to back perf mmap() buffers"
1356 depends on PERF_EVENTS && DEBUG_KERNEL 1355 depends on PERF_EVENTS && DEBUG_KERNEL
1357 select PERF_USE_VMALLOC 1356 select PERF_USE_VMALLOC
1358 help 1357 help
1359 Use vmalloc memory to back perf mmap() buffers. 1358 Use vmalloc memory to back perf mmap() buffers.
1360 1359
1361 Mostly useful for debugging the vmalloc code on platforms 1360 Mostly useful for debugging the vmalloc code on platforms
1362 that don't require it. 1361 that don't require it.
1363 1362
1364 Say N if unsure. 1363 Say N if unsure.
1365 1364
1366 endmenu 1365 endmenu
1367 1366
1368 config VM_EVENT_COUNTERS 1367 config VM_EVENT_COUNTERS
1369 default y 1368 default y
1370 bool "Enable VM event counters for /proc/vmstat" if EXPERT 1369 bool "Enable VM event counters for /proc/vmstat" if EXPERT
1371 help 1370 help
1372 VM event counters are needed for event counts to be shown. 1371 VM event counters are needed for event counts to be shown.
1373 This option allows the disabling of the VM event counters 1372 This option allows the disabling of the VM event counters
1374 on EXPERT systems. /proc/vmstat will only show page counts 1373 on EXPERT systems. /proc/vmstat will only show page counts
1375 if VM event counters are disabled. 1374 if VM event counters are disabled.
1376 1375
1377 config PCI_QUIRKS 1376 config PCI_QUIRKS
1378 default y 1377 default y
1379 bool "Enable PCI quirk workarounds" if EXPERT 1378 bool "Enable PCI quirk workarounds" if EXPERT
1380 depends on PCI 1379 depends on PCI
1381 help 1380 help
1382 This enables workarounds for various PCI chipset 1381 This enables workarounds for various PCI chipset
1383 bugs/quirks. Disable this only if your target machine is 1382 bugs/quirks. Disable this only if your target machine is
1384 unaffected by PCI quirks. 1383 unaffected by PCI quirks.
1385 1384
1386 config SLUB_DEBUG 1385 config SLUB_DEBUG
1387 default y 1386 default y
1388 bool "Enable SLUB debugging support" if EXPERT 1387 bool "Enable SLUB debugging support" if EXPERT
1389 depends on SLUB && SYSFS 1388 depends on SLUB && SYSFS
1390 help 1389 help
1391 SLUB has extensive debug support features. Disabling these can 1390 SLUB has extensive debug support features. Disabling these can
1392 result in significant savings in code size. This also disables 1391 result in significant savings in code size. This also disables
1393 SLUB sysfs support. /sys/slab will not exist and there will be 1392 SLUB sysfs support. /sys/slab will not exist and there will be
1394 no support for cache validation etc. 1393 no support for cache validation etc.
1395 1394
1396 config COMPAT_BRK 1395 config COMPAT_BRK
1397 bool "Disable heap randomization" 1396 bool "Disable heap randomization"
1398 default y 1397 default y
1399 help 1398 help
1400 Randomizing heap placement makes heap exploits harder, but it 1399 Randomizing heap placement makes heap exploits harder, but it
1401 also breaks ancient binaries (including anything libc5 based). 1400 also breaks ancient binaries (including anything libc5 based).
1402 This option changes the bootup default to heap randomization 1401 This option changes the bootup default to heap randomization
1403 disabled, and can be overridden at runtime by setting 1402 disabled, and can be overridden at runtime by setting
1404 /proc/sys/kernel/randomize_va_space to 2. 1403 /proc/sys/kernel/randomize_va_space to 2.
1405 1404
1406 On non-ancient distros (post-2000 ones) N is usually a safe choice. 1405 On non-ancient distros (post-2000 ones) N is usually a safe choice.
1407 1406
1408 choice 1407 choice
1409 prompt "Choose SLAB allocator" 1408 prompt "Choose SLAB allocator"
1410 default SLUB 1409 default SLUB
1411 help 1410 help
1412 This option allows to select a slab allocator. 1411 This option allows to select a slab allocator.
1413 1412
1414 config SLAB 1413 config SLAB
1415 bool "SLAB" 1414 bool "SLAB"
1416 help 1415 help
1417 The regular slab allocator that is established and known to work 1416 The regular slab allocator that is established and known to work
1418 well in all environments. It organizes cache hot objects in 1417 well in all environments. It organizes cache hot objects in
1419 per cpu and per node queues. 1418 per cpu and per node queues.
1420 1419
1421 config SLUB 1420 config SLUB
1422 bool "SLUB (Unqueued Allocator)" 1421 bool "SLUB (Unqueued Allocator)"
1423 help 1422 help
1424 SLUB is a slab allocator that minimizes cache line usage 1423 SLUB is a slab allocator that minimizes cache line usage
1425 instead of managing queues of cached objects (SLAB approach). 1424 instead of managing queues of cached objects (SLAB approach).
1426 Per cpu caching is realized using slabs of objects instead 1425 Per cpu caching is realized using slabs of objects instead
1427 of queues of objects. SLUB can use memory efficiently 1426 of queues of objects. SLUB can use memory efficiently
1428 and has enhanced diagnostics. SLUB is the default choice for 1427 and has enhanced diagnostics. SLUB is the default choice for
1429 a slab allocator. 1428 a slab allocator.
1430 1429
1431 config SLOB 1430 config SLOB
1432 depends on EXPERT 1431 depends on EXPERT
1433 bool "SLOB (Simple Allocator)" 1432 bool "SLOB (Simple Allocator)"
1434 help 1433 help
1435 SLOB replaces the stock allocator with a drastically simpler 1434 SLOB replaces the stock allocator with a drastically simpler
1436 allocator. SLOB is generally more space efficient but 1435 allocator. SLOB is generally more space efficient but
1437 does not perform as well on large systems. 1436 does not perform as well on large systems.
1438 1437
1439 endchoice 1438 endchoice
1440 1439
1441 config MMAP_ALLOW_UNINITIALIZED 1440 config MMAP_ALLOW_UNINITIALIZED
1442 bool "Allow mmapped anonymous memory to be uninitialized" 1441 bool "Allow mmapped anonymous memory to be uninitialized"
1443 depends on EXPERT && !MMU 1442 depends on EXPERT && !MMU
1444 default n 1443 default n
1445 help 1444 help
1446 Normally, and according to the Linux spec, anonymous memory obtained 1445 Normally, and according to the Linux spec, anonymous memory obtained
1447 from mmap() has it's contents cleared before it is passed to 1446 from mmap() has it's contents cleared before it is passed to
1448 userspace. Enabling this config option allows you to request that 1447 userspace. Enabling this config option allows you to request that
1449 mmap() skip that if it is given an MAP_UNINITIALIZED flag, thus 1448 mmap() skip that if it is given an MAP_UNINITIALIZED flag, thus
1450 providing a huge performance boost. If this option is not enabled, 1449 providing a huge performance boost. If this option is not enabled,
1451 then the flag will be ignored. 1450 then the flag will be ignored.
1452 1451
1453 This is taken advantage of by uClibc's malloc(), and also by 1452 This is taken advantage of by uClibc's malloc(), and also by
1454 ELF-FDPIC binfmt's brk and stack allocator. 1453 ELF-FDPIC binfmt's brk and stack allocator.
1455 1454
1456 Because of the obvious security issues, this option should only be 1455 Because of the obvious security issues, this option should only be
1457 enabled on embedded devices where you control what is run in 1456 enabled on embedded devices where you control what is run in
1458 userspace. Since that isn't generally a problem on no-MMU systems, 1457 userspace. Since that isn't generally a problem on no-MMU systems,
1459 it is normally safe to say Y here. 1458 it is normally safe to say Y here.
1460 1459
1461 See Documentation/nommu-mmap.txt for more information. 1460 See Documentation/nommu-mmap.txt for more information.
1462 1461
1463 config PROFILING 1462 config PROFILING
1464 bool "Profiling support" 1463 bool "Profiling support"
1465 help 1464 help
1466 Say Y here to enable the extended profiling support mechanisms used 1465 Say Y here to enable the extended profiling support mechanisms used
1467 by profilers such as OProfile. 1466 by profilers such as OProfile.
1468 1467
1469 # 1468 #
1470 # Place an empty function call at each tracepoint site. Can be 1469 # Place an empty function call at each tracepoint site. Can be
1471 # dynamically changed for a probe function. 1470 # dynamically changed for a probe function.
1472 # 1471 #
1473 config TRACEPOINTS 1472 config TRACEPOINTS
1474 bool 1473 bool
1475 1474
1476 source "arch/Kconfig" 1475 source "arch/Kconfig"
1477 1476
1478 endmenu # General setup 1477 endmenu # General setup
1479 1478
1480 config HAVE_GENERIC_DMA_COHERENT 1479 config HAVE_GENERIC_DMA_COHERENT
1481 bool 1480 bool
1482 default n 1481 default n
1483 1482
1484 config SLABINFO 1483 config SLABINFO
1485 bool 1484 bool
1486 depends on PROC_FS 1485 depends on PROC_FS
1487 depends on SLAB || SLUB_DEBUG 1486 depends on SLAB || SLUB_DEBUG
1488 default y 1487 default y
1489 1488
1490 config RT_MUTEXES 1489 config RT_MUTEXES
1491 boolean 1490 boolean
1492 1491
1493 config BASE_SMALL 1492 config BASE_SMALL
1494 int 1493 int
1495 default 0 if BASE_FULL 1494 default 0 if BASE_FULL
1496 default 1 if !BASE_FULL 1495 default 1 if !BASE_FULL
1497 1496
1498 menuconfig MODULES 1497 menuconfig MODULES
1499 bool "Enable loadable module support" 1498 bool "Enable loadable module support"
1500 help 1499 help
1501 Kernel modules are small pieces of compiled code which can 1500 Kernel modules are small pieces of compiled code which can
1502 be inserted in the running kernel, rather than being 1501 be inserted in the running kernel, rather than being
1503 permanently built into the kernel. You use the "modprobe" 1502 permanently built into the kernel. You use the "modprobe"
1504 tool to add (and sometimes remove) them. If you say Y here, 1503 tool to add (and sometimes remove) them. If you say Y here,
1505 many parts of the kernel can be built as modules (by 1504 many parts of the kernel can be built as modules (by
1506 answering M instead of Y where indicated): this is most 1505 answering M instead of Y where indicated): this is most
1507 useful for infrequently used options which are not required 1506 useful for infrequently used options which are not required
1508 for booting. For more information, see the man pages for 1507 for booting. For more information, see the man pages for
1509 modprobe, lsmod, modinfo, insmod and rmmod. 1508 modprobe, lsmod, modinfo, insmod and rmmod.
1510 1509
1511 If you say Y here, you will need to run "make 1510 If you say Y here, you will need to run "make
1512 modules_install" to put the modules under /lib/modules/ 1511 modules_install" to put the modules under /lib/modules/
1513 where modprobe can find them (you may need to be root to do 1512 where modprobe can find them (you may need to be root to do
1514 this). 1513 this).
1515 1514
1516 If unsure, say Y. 1515 If unsure, say Y.
1517 1516
1518 if MODULES 1517 if MODULES
1519 1518
1520 config MODULE_FORCE_LOAD 1519 config MODULE_FORCE_LOAD
1521 bool "Forced module loading" 1520 bool "Forced module loading"
1522 default n 1521 default n
1523 help 1522 help
1524 Allow loading of modules without version information (ie. modprobe 1523 Allow loading of modules without version information (ie. modprobe
1525 --force). Forced module loading sets the 'F' (forced) taint flag and 1524 --force). Forced module loading sets the 'F' (forced) taint flag and
1526 is usually a really bad idea. 1525 is usually a really bad idea.
1527 1526
1528 config MODULE_UNLOAD 1527 config MODULE_UNLOAD
1529 bool "Module unloading" 1528 bool "Module unloading"
1530 help 1529 help
1531 Without this option you will not be able to unload any 1530 Without this option you will not be able to unload any
1532 modules (note that some modules may not be unloadable 1531 modules (note that some modules may not be unloadable
1533 anyway), which makes your kernel smaller, faster 1532 anyway), which makes your kernel smaller, faster
1534 and simpler. If unsure, say Y. 1533 and simpler. If unsure, say Y.
1535 1534
1536 config MODULE_FORCE_UNLOAD 1535 config MODULE_FORCE_UNLOAD
1537 bool "Forced module unloading" 1536 bool "Forced module unloading"
1538 depends on MODULE_UNLOAD && EXPERIMENTAL 1537 depends on MODULE_UNLOAD && EXPERIMENTAL
1539 help 1538 help
1540 This option allows you to force a module to unload, even if the 1539 This option allows you to force a module to unload, even if the
1541 kernel believes it is unsafe: the kernel will remove the module 1540 kernel believes it is unsafe: the kernel will remove the module
1542 without waiting for anyone to stop using it (using the -f option to 1541 without waiting for anyone to stop using it (using the -f option to
1543 rmmod). This is mainly for kernel developers and desperate users. 1542 rmmod). This is mainly for kernel developers and desperate users.
1544 If unsure, say N. 1543 If unsure, say N.
1545 1544
1546 config MODVERSIONS 1545 config MODVERSIONS
1547 bool "Module versioning support" 1546 bool "Module versioning support"
1548 help 1547 help
1549 Usually, you have to use modules compiled with your kernel. 1548 Usually, you have to use modules compiled with your kernel.
1550 Saying Y here makes it sometimes possible to use modules 1549 Saying Y here makes it sometimes possible to use modules
1551 compiled for different kernels, by adding enough information 1550 compiled for different kernels, by adding enough information
1552 to the modules to (hopefully) spot any changes which would 1551 to the modules to (hopefully) spot any changes which would
1553 make them incompatible with the kernel you are running. If 1552 make them incompatible with the kernel you are running. If
1554 unsure, say N. 1553 unsure, say N.
1555 1554
1556 config MODULE_SRCVERSION_ALL 1555 config MODULE_SRCVERSION_ALL
1557 bool "Source checksum for all modules" 1556 bool "Source checksum for all modules"
1558 help 1557 help
1559 Modules which contain a MODULE_VERSION get an extra "srcversion" 1558 Modules which contain a MODULE_VERSION get an extra "srcversion"
1560 field inserted into their modinfo section, which contains a 1559 field inserted into their modinfo section, which contains a
1561 sum of the source files which made it. This helps maintainers 1560 sum of the source files which made it. This helps maintainers
1562 see exactly which source was used to build a module (since 1561 see exactly which source was used to build a module (since
1563 others sometimes change the module source without updating 1562 others sometimes change the module source without updating
1564 the version). With this option, such a "srcversion" field 1563 the version). With this option, such a "srcversion" field
1565 will be created for all modules. If unsure, say N. 1564 will be created for all modules. If unsure, say N.
1566 1565
1567 endif # MODULES 1566 endif # MODULES
1568 1567
1569 config INIT_ALL_POSSIBLE 1568 config INIT_ALL_POSSIBLE
1570 bool 1569 bool
1571 help 1570 help
1572 Back when each arch used to define their own cpu_online_mask and 1571 Back when each arch used to define their own cpu_online_mask and
1573 cpu_possible_mask, some of them chose to initialize cpu_possible_mask 1572 cpu_possible_mask, some of them chose to initialize cpu_possible_mask
1574 with all 1s, and others with all 0s. When they were centralised, 1573 with all 1s, and others with all 0s. When they were centralised,
1575 it was better to provide this option than to break all the archs 1574 it was better to provide this option than to break all the archs
1576 and have several arch maintainers pursuing me down dark alleys. 1575 and have several arch maintainers pursuing me down dark alleys.
1577 1576
1578 config STOP_MACHINE 1577 config STOP_MACHINE
1579 bool 1578 bool
1580 default y 1579 default y
1581 depends on (SMP && MODULE_UNLOAD) || HOTPLUG_CPU 1580 depends on (SMP && MODULE_UNLOAD) || HOTPLUG_CPU
1582 help 1581 help
1583 Need stop_machine() primitive. 1582 Need stop_machine() primitive.
1584 1583
1585 source "block/Kconfig" 1584 source "block/Kconfig"
1586 1585
1587 config PREEMPT_NOTIFIERS 1586 config PREEMPT_NOTIFIERS
1588 bool 1587 bool
1589 1588
1590 config PADATA 1589 config PADATA
1591 depends on SMP 1590 depends on SMP
1592 bool 1591 bool
1593 1592
1594 source "kernel/Kconfig.locks" 1593 source "kernel/Kconfig.locks"
1595 1594