[PATCH] remove the syslog interface when printk is disabled
[linux-2.6.git] / fs / proc / proc_misc.c
1 /*
2  *  linux/fs/proc/proc_misc.c
3  *
4  *  linux/fs/proc/array.c
5  *  Copyright (C) 1992  by Linus Torvalds
6  *  based on ideas by Darren Senn
7  *
8  *  This used to be the part of array.c. See the rest of history and credits
9  *  there. I took this into a separate file and switched the thing to generic
10  *  proc_file_inode_operations, leaving in array.c only per-process stuff.
11  *  Inumbers allocation made dynamic (via create_proc_entry()).  AV, May 1999.
12  *
13  * Changes:
14  * Fulton Green      :  Encapsulated position metric calculations.
15  *                      <kernel@FultonGreen.com>
16  */
17
18 #include <linux/types.h>
19 #include <linux/errno.h>
20 #include <linux/time.h>
21 #include <linux/kernel.h>
22 #include <linux/kernel_stat.h>
23 #include <linux/fs.h>
24 #include <linux/tty.h>
25 #include <linux/string.h>
26 #include <linux/mman.h>
27 #include <linux/proc_fs.h>
28 #include <linux/ioport.h>
29 #include <linux/mm.h>
30 #include <linux/mmzone.h>
31 #include <linux/pagemap.h>
32 #include <linux/swap.h>
33 #include <linux/slab.h>
34 #include <linux/smp.h>
35 #include <linux/signal.h>
36 #include <linux/module.h>
37 #include <linux/init.h>
38 #include <linux/smp_lock.h>
39 #include <linux/seq_file.h>
40 #include <linux/times.h>
41 #include <linux/profile.h>
42 #include <linux/blkdev.h>
43 #include <linux/hugetlb.h>
44 #include <linux/jiffies.h>
45 #include <linux/sysrq.h>
46 #include <linux/vmalloc.h>
47 #include <linux/crash_dump.h>
48 #include <linux/pspace.h>
49 #include <asm/uaccess.h>
50 #include <asm/pgtable.h>
51 #include <asm/io.h>
52 #include <asm/tlb.h>
53 #include <asm/div64.h>
54 #include "internal.h"
55
56 #define LOAD_INT(x) ((x) >> FSHIFT)
57 #define LOAD_FRAC(x) LOAD_INT(((x) & (FIXED_1-1)) * 100)
58 /*
59  * Warning: stuff below (imported functions) assumes that its output will fit
60  * into one page. For some of those functions it may be wrong. Moreover, we
61  * have a way to deal with that gracefully. Right now I used straightforward
62  * wrappers, but this needs further analysis wrt potential overflows.
63  */
64 extern int get_hardware_list(char *);
65 extern int get_stram_list(char *);
66 extern int get_filesystem_list(char *);
67 extern int get_exec_domain_list(char *);
68 extern int get_dma_list(char *);
69 extern int get_locks_status (char *, char **, off_t, int);
70
71 static int proc_calc_metrics(char *page, char **start, off_t off,
72                                  int count, int *eof, int len)
73 {
74         if (len <= off+count) *eof = 1;
75         *start = page + off;
76         len -= off;
77         if (len>count) len = count;
78         if (len<0) len = 0;
79         return len;
80 }
81
82 static int loadavg_read_proc(char *page, char **start, off_t off,
83                                  int count, int *eof, void *data)
84 {
85         int a, b, c;
86         int len;
87
88         a = avenrun[0] + (FIXED_1/200);
89         b = avenrun[1] + (FIXED_1/200);
90         c = avenrun[2] + (FIXED_1/200);
91         len = sprintf(page,"%d.%02d %d.%02d %d.%02d %ld/%d %d\n",
92                 LOAD_INT(a), LOAD_FRAC(a),
93                 LOAD_INT(b), LOAD_FRAC(b),
94                 LOAD_INT(c), LOAD_FRAC(c),
95                 nr_running(), nr_threads, init_pspace.last_pid);
96         return proc_calc_metrics(page, start, off, count, eof, len);
97 }
98
99 static int uptime_read_proc(char *page, char **start, off_t off,
100                                  int count, int *eof, void *data)
101 {
102         struct timespec uptime;
103         struct timespec idle;
104         int len;
105         cputime_t idletime = cputime_add(init_task.utime, init_task.stime);
106
107         do_posix_clock_monotonic_gettime(&uptime);
108         cputime_to_timespec(idletime, &idle);
109         len = sprintf(page,"%lu.%02lu %lu.%02lu\n",
110                         (unsigned long) uptime.tv_sec,
111                         (uptime.tv_nsec / (NSEC_PER_SEC / 100)),
112                         (unsigned long) idle.tv_sec,
113                         (idle.tv_nsec / (NSEC_PER_SEC / 100)));
114
115         return proc_calc_metrics(page, start, off, count, eof, len);
116 }
117
118 static int meminfo_read_proc(char *page, char **start, off_t off,
119                                  int count, int *eof, void *data)
120 {
121         struct sysinfo i;
122         int len;
123         unsigned long inactive;
124         unsigned long active;
125         unsigned long free;
126         unsigned long committed;
127         unsigned long allowed;
128         struct vmalloc_info vmi;
129         long cached;
130
131         get_zone_counts(&active, &inactive, &free);
132
133 /*
134  * display in kilobytes.
135  */
136 #define K(x) ((x) << (PAGE_SHIFT - 10))
137         si_meminfo(&i);
138         si_swapinfo(&i);
139         committed = atomic_read(&vm_committed_space);
140         allowed = ((totalram_pages - hugetlb_total_pages())
141                 * sysctl_overcommit_ratio / 100) + total_swap_pages;
142
143         cached = global_page_state(NR_FILE_PAGES) -
144                         total_swapcache_pages - i.bufferram;
145         if (cached < 0)
146                 cached = 0;
147
148         get_vmalloc_info(&vmi);
149
150         /*
151          * Tagged format, for easy grepping and expansion.
152          */
153         len = sprintf(page,
154                 "MemTotal:     %8lu kB\n"
155                 "MemFree:      %8lu kB\n"
156                 "Buffers:      %8lu kB\n"
157                 "Cached:       %8lu kB\n"
158                 "SwapCached:   %8lu kB\n"
159                 "Active:       %8lu kB\n"
160                 "Inactive:     %8lu kB\n"
161 #ifdef CONFIG_HIGHMEM
162                 "HighTotal:    %8lu kB\n"
163                 "HighFree:     %8lu kB\n"
164                 "LowTotal:     %8lu kB\n"
165                 "LowFree:      %8lu kB\n"
166 #endif
167                 "SwapTotal:    %8lu kB\n"
168                 "SwapFree:     %8lu kB\n"
169                 "Dirty:        %8lu kB\n"
170                 "Writeback:    %8lu kB\n"
171                 "AnonPages:    %8lu kB\n"
172                 "Mapped:       %8lu kB\n"
173                 "Slab:         %8lu kB\n"
174                 "SReclaimable: %8lu kB\n"
175                 "SUnreclaim:   %8lu kB\n"
176                 "PageTables:   %8lu kB\n"
177                 "NFS_Unstable: %8lu kB\n"
178                 "Bounce:       %8lu kB\n"
179                 "CommitLimit:  %8lu kB\n"
180                 "Committed_AS: %8lu kB\n"
181                 "VmallocTotal: %8lu kB\n"
182                 "VmallocUsed:  %8lu kB\n"
183                 "VmallocChunk: %8lu kB\n",
184                 K(i.totalram),
185                 K(i.freeram),
186                 K(i.bufferram),
187                 K(cached),
188                 K(total_swapcache_pages),
189                 K(active),
190                 K(inactive),
191 #ifdef CONFIG_HIGHMEM
192                 K(i.totalhigh),
193                 K(i.freehigh),
194                 K(i.totalram-i.totalhigh),
195                 K(i.freeram-i.freehigh),
196 #endif
197                 K(i.totalswap),
198                 K(i.freeswap),
199                 K(global_page_state(NR_FILE_DIRTY)),
200                 K(global_page_state(NR_WRITEBACK)),
201                 K(global_page_state(NR_ANON_PAGES)),
202                 K(global_page_state(NR_FILE_MAPPED)),
203                 K(global_page_state(NR_SLAB_RECLAIMABLE) +
204                                 global_page_state(NR_SLAB_UNRECLAIMABLE)),
205                 K(global_page_state(NR_SLAB_RECLAIMABLE)),
206                 K(global_page_state(NR_SLAB_UNRECLAIMABLE)),
207                 K(global_page_state(NR_PAGETABLE)),
208                 K(global_page_state(NR_UNSTABLE_NFS)),
209                 K(global_page_state(NR_BOUNCE)),
210                 K(allowed),
211                 K(committed),
212                 (unsigned long)VMALLOC_TOTAL >> 10,
213                 vmi.used >> 10,
214                 vmi.largest_chunk >> 10
215                 );
216
217                 len += hugetlb_report_meminfo(page + len);
218
219         return proc_calc_metrics(page, start, off, count, eof, len);
220 #undef K
221 }
222
223 extern struct seq_operations fragmentation_op;
224 static int fragmentation_open(struct inode *inode, struct file *file)
225 {
226         (void)inode;
227         return seq_open(file, &fragmentation_op);
228 }
229
230 static struct file_operations fragmentation_file_operations = {
231         .open           = fragmentation_open,
232         .read           = seq_read,
233         .llseek         = seq_lseek,
234         .release        = seq_release,
235 };
236
237 extern struct seq_operations zoneinfo_op;
238 static int zoneinfo_open(struct inode *inode, struct file *file)
239 {
240         return seq_open(file, &zoneinfo_op);
241 }
242
243 static struct file_operations proc_zoneinfo_file_operations = {
244         .open           = zoneinfo_open,
245         .read           = seq_read,
246         .llseek         = seq_lseek,
247         .release        = seq_release,
248 };
249
250 static int version_read_proc(char *page, char **start, off_t off,
251                                  int count, int *eof, void *data)
252 {
253         int len;
254
255         strcpy(page, linux_banner);
256         len = strlen(page);
257         return proc_calc_metrics(page, start, off, count, eof, len);
258 }
259
260 extern struct seq_operations cpuinfo_op;
261 static int cpuinfo_open(struct inode *inode, struct file *file)
262 {
263         return seq_open(file, &cpuinfo_op);
264 }
265
266 static struct file_operations proc_cpuinfo_operations = {
267         .open           = cpuinfo_open,
268         .read           = seq_read,
269         .llseek         = seq_lseek,
270         .release        = seq_release,
271 };
272
273 static int devinfo_show(struct seq_file *f, void *v)
274 {
275         int i = *(loff_t *) v;
276
277         if (i < CHRDEV_MAJOR_HASH_SIZE) {
278                 if (i == 0)
279                         seq_printf(f, "Character devices:\n");
280                 chrdev_show(f, i);
281         }
282 #ifdef CONFIG_BLOCK
283         else {
284                 i -= CHRDEV_MAJOR_HASH_SIZE;
285                 if (i == 0)
286                         seq_printf(f, "\nBlock devices:\n");
287                 blkdev_show(f, i);
288         }
289 #endif
290         return 0;
291 }
292
293 static void *devinfo_start(struct seq_file *f, loff_t *pos)
294 {
295         if (*pos < (BLKDEV_MAJOR_HASH_SIZE + CHRDEV_MAJOR_HASH_SIZE))
296                 return pos;
297         return NULL;
298 }
299
300 static void *devinfo_next(struct seq_file *f, void *v, loff_t *pos)
301 {
302         (*pos)++;
303         if (*pos >= (BLKDEV_MAJOR_HASH_SIZE + CHRDEV_MAJOR_HASH_SIZE))
304                 return NULL;
305         return pos;
306 }
307
308 static void devinfo_stop(struct seq_file *f, void *v)
309 {
310         /* Nothing to do */
311 }
312
313 static struct seq_operations devinfo_ops = {
314         .start = devinfo_start,
315         .next  = devinfo_next,
316         .stop  = devinfo_stop,
317         .show  = devinfo_show
318 };
319
320 static int devinfo_open(struct inode *inode, struct file *filp)
321 {
322         return seq_open(filp, &devinfo_ops);
323 }
324
325 static struct file_operations proc_devinfo_operations = {
326         .open           = devinfo_open,
327         .read           = seq_read,
328         .llseek         = seq_lseek,
329         .release        = seq_release,
330 };
331
332 extern struct seq_operations vmstat_op;
333 static int vmstat_open(struct inode *inode, struct file *file)
334 {
335         return seq_open(file, &vmstat_op);
336 }
337 static struct file_operations proc_vmstat_file_operations = {
338         .open           = vmstat_open,
339         .read           = seq_read,
340         .llseek         = seq_lseek,
341         .release        = seq_release,
342 };
343
344 #ifdef CONFIG_PROC_HARDWARE
345 static int hardware_read_proc(char *page, char **start, off_t off,
346                                  int count, int *eof, void *data)
347 {
348         int len = get_hardware_list(page);
349         return proc_calc_metrics(page, start, off, count, eof, len);
350 }
351 #endif
352
353 #ifdef CONFIG_STRAM_PROC
354 static int stram_read_proc(char *page, char **start, off_t off,
355                                  int count, int *eof, void *data)
356 {
357         int len = get_stram_list(page);
358         return proc_calc_metrics(page, start, off, count, eof, len);
359 }
360 #endif
361
362 #ifdef CONFIG_BLOCK
363 extern struct seq_operations partitions_op;
364 static int partitions_open(struct inode *inode, struct file *file)
365 {
366         return seq_open(file, &partitions_op);
367 }
368 static struct file_operations proc_partitions_operations = {
369         .open           = partitions_open,
370         .read           = seq_read,
371         .llseek         = seq_lseek,
372         .release        = seq_release,
373 };
374
375 extern struct seq_operations diskstats_op;
376 static int diskstats_open(struct inode *inode, struct file *file)
377 {
378         return seq_open(file, &diskstats_op);
379 }
380 static struct file_operations proc_diskstats_operations = {
381         .open           = diskstats_open,
382         .read           = seq_read,
383         .llseek         = seq_lseek,
384         .release        = seq_release,
385 };
386 #endif
387
388 #ifdef CONFIG_MODULES
389 extern struct seq_operations modules_op;
390 static int modules_open(struct inode *inode, struct file *file)
391 {
392         return seq_open(file, &modules_op);
393 }
394 static struct file_operations proc_modules_operations = {
395         .open           = modules_open,
396         .read           = seq_read,
397         .llseek         = seq_lseek,
398         .release        = seq_release,
399 };
400 #endif
401
402 #ifdef CONFIG_SLAB
403 extern struct seq_operations slabinfo_op;
404 extern ssize_t slabinfo_write(struct file *, const char __user *, size_t, loff_t *);
405 static int slabinfo_open(struct inode *inode, struct file *file)
406 {
407         return seq_open(file, &slabinfo_op);
408 }
409 static struct file_operations proc_slabinfo_operations = {
410         .open           = slabinfo_open,
411         .read           = seq_read,
412         .write          = slabinfo_write,
413         .llseek         = seq_lseek,
414         .release        = seq_release,
415 };
416
417 #ifdef CONFIG_DEBUG_SLAB_LEAK
418 extern struct seq_operations slabstats_op;
419 static int slabstats_open(struct inode *inode, struct file *file)
420 {
421         unsigned long *n = kzalloc(PAGE_SIZE, GFP_KERNEL);
422         int ret = -ENOMEM;
423         if (n) {
424                 ret = seq_open(file, &slabstats_op);
425                 if (!ret) {
426                         struct seq_file *m = file->private_data;
427                         *n = PAGE_SIZE / (2 * sizeof(unsigned long));
428                         m->private = n;
429                         n = NULL;
430                 }
431                 kfree(n);
432         }
433         return ret;
434 }
435
436 static int slabstats_release(struct inode *inode, struct file *file)
437 {
438         struct seq_file *m = file->private_data;
439         kfree(m->private);
440         return seq_release(inode, file);
441 }
442
443 static struct file_operations proc_slabstats_operations = {
444         .open           = slabstats_open,
445         .read           = seq_read,
446         .llseek         = seq_lseek,
447         .release        = slabstats_release,
448 };
449 #endif
450 #endif
451
452 static int show_stat(struct seq_file *p, void *v)
453 {
454         int i;
455         unsigned long jif;
456         cputime64_t user, nice, system, idle, iowait, irq, softirq, steal;
457         u64 sum = 0;
458
459         user = nice = system = idle = iowait =
460                 irq = softirq = steal = cputime64_zero;
461         jif = - wall_to_monotonic.tv_sec;
462         if (wall_to_monotonic.tv_nsec)
463                 --jif;
464
465         for_each_possible_cpu(i) {
466                 int j;
467
468                 user = cputime64_add(user, kstat_cpu(i).cpustat.user);
469                 nice = cputime64_add(nice, kstat_cpu(i).cpustat.nice);
470                 system = cputime64_add(system, kstat_cpu(i).cpustat.system);
471                 idle = cputime64_add(idle, kstat_cpu(i).cpustat.idle);
472                 iowait = cputime64_add(iowait, kstat_cpu(i).cpustat.iowait);
473                 irq = cputime64_add(irq, kstat_cpu(i).cpustat.irq);
474                 softirq = cputime64_add(softirq, kstat_cpu(i).cpustat.softirq);
475                 steal = cputime64_add(steal, kstat_cpu(i).cpustat.steal);
476                 for (j = 0 ; j < NR_IRQS ; j++)
477                         sum += kstat_cpu(i).irqs[j];
478         }
479
480         seq_printf(p, "cpu  %llu %llu %llu %llu %llu %llu %llu %llu\n",
481                 (unsigned long long)cputime64_to_clock_t(user),
482                 (unsigned long long)cputime64_to_clock_t(nice),
483                 (unsigned long long)cputime64_to_clock_t(system),
484                 (unsigned long long)cputime64_to_clock_t(idle),
485                 (unsigned long long)cputime64_to_clock_t(iowait),
486                 (unsigned long long)cputime64_to_clock_t(irq),
487                 (unsigned long long)cputime64_to_clock_t(softirq),
488                 (unsigned long long)cputime64_to_clock_t(steal));
489         for_each_online_cpu(i) {
490
491                 /* Copy values here to work around gcc-2.95.3, gcc-2.96 */
492                 user = kstat_cpu(i).cpustat.user;
493                 nice = kstat_cpu(i).cpustat.nice;
494                 system = kstat_cpu(i).cpustat.system;
495                 idle = kstat_cpu(i).cpustat.idle;
496                 iowait = kstat_cpu(i).cpustat.iowait;
497                 irq = kstat_cpu(i).cpustat.irq;
498                 softirq = kstat_cpu(i).cpustat.softirq;
499                 steal = kstat_cpu(i).cpustat.steal;
500                 seq_printf(p, "cpu%d %llu %llu %llu %llu %llu %llu %llu %llu\n",
501                         i,
502                         (unsigned long long)cputime64_to_clock_t(user),
503                         (unsigned long long)cputime64_to_clock_t(nice),
504                         (unsigned long long)cputime64_to_clock_t(system),
505                         (unsigned long long)cputime64_to_clock_t(idle),
506                         (unsigned long long)cputime64_to_clock_t(iowait),
507                         (unsigned long long)cputime64_to_clock_t(irq),
508                         (unsigned long long)cputime64_to_clock_t(softirq),
509                         (unsigned long long)cputime64_to_clock_t(steal));
510         }
511         seq_printf(p, "intr %llu", (unsigned long long)sum);
512
513 #if !defined(CONFIG_PPC64) && !defined(CONFIG_ALPHA) && !defined(CONFIG_IA64)
514         for (i = 0; i < NR_IRQS; i++)
515                 seq_printf(p, " %u", kstat_irqs(i));
516 #endif
517
518         seq_printf(p,
519                 "\nctxt %llu\n"
520                 "btime %lu\n"
521                 "processes %lu\n"
522                 "procs_running %lu\n"
523                 "procs_blocked %lu\n",
524                 nr_context_switches(),
525                 (unsigned long)jif,
526                 total_forks,
527                 nr_running(),
528                 nr_iowait());
529
530         return 0;
531 }
532
533 static int stat_open(struct inode *inode, struct file *file)
534 {
535         unsigned size = 4096 * (1 + num_possible_cpus() / 32);
536         char *buf;
537         struct seq_file *m;
538         int res;
539
540         /* don't ask for more than the kmalloc() max size, currently 128 KB */
541         if (size > 128 * 1024)
542                 size = 128 * 1024;
543         buf = kmalloc(size, GFP_KERNEL);
544         if (!buf)
545                 return -ENOMEM;
546
547         res = single_open(file, show_stat, NULL);
548         if (!res) {
549                 m = file->private_data;
550                 m->buf = buf;
551                 m->size = size;
552         } else
553                 kfree(buf);
554         return res;
555 }
556 static struct file_operations proc_stat_operations = {
557         .open           = stat_open,
558         .read           = seq_read,
559         .llseek         = seq_lseek,
560         .release        = single_release,
561 };
562
563 /*
564  * /proc/interrupts
565  */
566 static void *int_seq_start(struct seq_file *f, loff_t *pos)
567 {
568         return (*pos <= NR_IRQS) ? pos : NULL;
569 }
570
571 static void *int_seq_next(struct seq_file *f, void *v, loff_t *pos)
572 {
573         (*pos)++;
574         if (*pos > NR_IRQS)
575                 return NULL;
576         return pos;
577 }
578
579 static void int_seq_stop(struct seq_file *f, void *v)
580 {
581         /* Nothing to do */
582 }
583
584
585 extern int show_interrupts(struct seq_file *f, void *v); /* In arch code */
586 static struct seq_operations int_seq_ops = {
587         .start = int_seq_start,
588         .next  = int_seq_next,
589         .stop  = int_seq_stop,
590         .show  = show_interrupts
591 };
592
593 static int interrupts_open(struct inode *inode, struct file *filp)
594 {
595         return seq_open(filp, &int_seq_ops);
596 }
597
598 static struct file_operations proc_interrupts_operations = {
599         .open           = interrupts_open,
600         .read           = seq_read,
601         .llseek         = seq_lseek,
602         .release        = seq_release,
603 };
604
605 static int filesystems_read_proc(char *page, char **start, off_t off,
606                                  int count, int *eof, void *data)
607 {
608         int len = get_filesystem_list(page);
609         return proc_calc_metrics(page, start, off, count, eof, len);
610 }
611
612 static int cmdline_read_proc(char *page, char **start, off_t off,
613                                  int count, int *eof, void *data)
614 {
615         int len;
616
617         len = sprintf(page, "%s\n", saved_command_line);
618         return proc_calc_metrics(page, start, off, count, eof, len);
619 }
620
621 static int locks_read_proc(char *page, char **start, off_t off,
622                                  int count, int *eof, void *data)
623 {
624         int len = get_locks_status(page, start, off, count);
625
626         if (len < count)
627                 *eof = 1;
628         return len;
629 }
630
631 static int execdomains_read_proc(char *page, char **start, off_t off,
632                                  int count, int *eof, void *data)
633 {
634         int len = get_exec_domain_list(page);
635         return proc_calc_metrics(page, start, off, count, eof, len);
636 }
637
638 #ifdef CONFIG_MAGIC_SYSRQ
639 /*
640  * writing 'C' to /proc/sysrq-trigger is like sysrq-C
641  */
642 static ssize_t write_sysrq_trigger(struct file *file, const char __user *buf,
643                                    size_t count, loff_t *ppos)
644 {
645         if (count) {
646                 char c;
647
648                 if (get_user(c, buf))
649                         return -EFAULT;
650                 __handle_sysrq(c, NULL, 0);
651         }
652         return count;
653 }
654
655 static struct file_operations proc_sysrq_trigger_operations = {
656         .write          = write_sysrq_trigger,
657 };
658 #endif
659
660 struct proc_dir_entry *proc_root_kcore;
661
662 void create_seq_entry(char *name, mode_t mode, const struct file_operations *f)
663 {
664         struct proc_dir_entry *entry;
665         entry = create_proc_entry(name, mode, NULL);
666         if (entry)
667                 entry->proc_fops = f;
668 }
669
670 void __init proc_misc_init(void)
671 {
672         struct proc_dir_entry *entry;
673         static struct {
674                 char *name;
675                 int (*read_proc)(char*,char**,off_t,int,int*,void*);
676         } *p, simple_ones[] = {
677                 {"loadavg",     loadavg_read_proc},
678                 {"uptime",      uptime_read_proc},
679                 {"meminfo",     meminfo_read_proc},
680                 {"version",     version_read_proc},
681 #ifdef CONFIG_PROC_HARDWARE
682                 {"hardware",    hardware_read_proc},
683 #endif
684 #ifdef CONFIG_STRAM_PROC
685                 {"stram",       stram_read_proc},
686 #endif
687                 {"filesystems", filesystems_read_proc},
688                 {"cmdline",     cmdline_read_proc},
689                 {"locks",       locks_read_proc},
690                 {"execdomains", execdomains_read_proc},
691                 {NULL,}
692         };
693         for (p = simple_ones; p->name; p++)
694                 create_proc_read_entry(p->name, 0, NULL, p->read_proc, NULL);
695
696         proc_symlink("mounts", NULL, "self/mounts");
697
698         /* And now for trickier ones */
699 #ifdef CONFIG_PRINTK
700         entry = create_proc_entry("kmsg", S_IRUSR, &proc_root);
701         if (entry)
702                 entry->proc_fops = &proc_kmsg_operations;
703 #endif
704         create_seq_entry("devices", 0, &proc_devinfo_operations);
705         create_seq_entry("cpuinfo", 0, &proc_cpuinfo_operations);
706 #ifdef CONFIG_BLOCK
707         create_seq_entry("partitions", 0, &proc_partitions_operations);
708 #endif
709         create_seq_entry("stat", 0, &proc_stat_operations);
710         create_seq_entry("interrupts", 0, &proc_interrupts_operations);
711 #ifdef CONFIG_SLAB
712         create_seq_entry("slabinfo",S_IWUSR|S_IRUGO,&proc_slabinfo_operations);
713 #ifdef CONFIG_DEBUG_SLAB_LEAK
714         create_seq_entry("slab_allocators", 0 ,&proc_slabstats_operations);
715 #endif
716 #endif
717         create_seq_entry("buddyinfo",S_IRUGO, &fragmentation_file_operations);
718         create_seq_entry("vmstat",S_IRUGO, &proc_vmstat_file_operations);
719         create_seq_entry("zoneinfo",S_IRUGO, &proc_zoneinfo_file_operations);
720 #ifdef CONFIG_BLOCK
721         create_seq_entry("diskstats", 0, &proc_diskstats_operations);
722 #endif
723 #ifdef CONFIG_MODULES
724         create_seq_entry("modules", 0, &proc_modules_operations);
725 #endif
726 #ifdef CONFIG_SCHEDSTATS
727         create_seq_entry("schedstat", 0, &proc_schedstat_operations);
728 #endif
729 #ifdef CONFIG_PROC_KCORE
730         proc_root_kcore = create_proc_entry("kcore", S_IRUSR, NULL);
731         if (proc_root_kcore) {
732                 proc_root_kcore->proc_fops = &proc_kcore_operations;
733                 proc_root_kcore->size =
734                                 (size_t)high_memory - PAGE_OFFSET + PAGE_SIZE;
735         }
736 #endif
737 #ifdef CONFIG_PROC_VMCORE
738         proc_vmcore = create_proc_entry("vmcore", S_IRUSR, NULL);
739         if (proc_vmcore)
740                 proc_vmcore->proc_fops = &proc_vmcore_operations;
741 #endif
742 #ifdef CONFIG_MAGIC_SYSRQ
743         entry = create_proc_entry("sysrq-trigger", S_IWUSR, NULL);
744         if (entry)
745                 entry->proc_fops = &proc_sysrq_trigger_operations;
746 #endif
747 }