ff809656ce3153ff24ede45510fdea713e2468c6
[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/config.h>
30 #include <linux/mm.h>
31 #include <linux/mmzone.h>
32 #include <linux/pagemap.h>
33 #include <linux/swap.h>
34 #include <linux/slab.h>
35 #include <linux/smp.h>
36 #include <linux/signal.h>
37 #include <linux/module.h>
38 #include <linux/init.h>
39 #include <linux/smp_lock.h>
40 #include <linux/seq_file.h>
41 #include <linux/times.h>
42 #include <linux/profile.h>
43 #include <linux/blkdev.h>
44 #include <linux/hugetlb.h>
45 #include <linux/jiffies.h>
46 #include <linux/sysrq.h>
47 #include <linux/vmalloc.h>
48 #include <linux/crash_dump.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, 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         struct page_state ps;
124         unsigned long inactive;
125         unsigned long active;
126         unsigned long free;
127         unsigned long committed;
128         unsigned long allowed;
129         struct vmalloc_info vmi;
130         long cached;
131
132         get_page_state(&ps);
133         get_zone_counts(&active, &inactive, &free);
134
135 /*
136  * display in kilobytes.
137  */
138 #define K(x) ((x) << (PAGE_SHIFT - 10))
139         si_meminfo(&i);
140         si_swapinfo(&i);
141         committed = atomic_read(&vm_committed_space);
142         allowed = ((totalram_pages - hugetlb_total_pages())
143                 * sysctl_overcommit_ratio / 100) + total_swap_pages;
144
145         cached = global_page_state(NR_FILE_PAGES) -
146                         total_swapcache_pages - i.bufferram;
147         if (cached < 0)
148                 cached = 0;
149
150         get_vmalloc_info(&vmi);
151
152         /*
153          * Tagged format, for easy grepping and expansion.
154          */
155         len = sprintf(page,
156                 "MemTotal:     %8lu kB\n"
157                 "MemFree:      %8lu kB\n"
158                 "Buffers:      %8lu kB\n"
159                 "Cached:       %8lu kB\n"
160                 "SwapCached:   %8lu kB\n"
161                 "Active:       %8lu kB\n"
162                 "Inactive:     %8lu kB\n"
163                 "HighTotal:    %8lu kB\n"
164                 "HighFree:     %8lu kB\n"
165                 "LowTotal:     %8lu kB\n"
166                 "LowFree:      %8lu kB\n"
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                 "CommitLimit:  %8lu kB\n"
175                 "Committed_AS: %8lu kB\n"
176                 "PageTables:   %8lu kB\n"
177                 "VmallocTotal: %8lu kB\n"
178                 "VmallocUsed:  %8lu kB\n"
179                 "VmallocChunk: %8lu kB\n",
180                 K(i.totalram),
181                 K(i.freeram),
182                 K(i.bufferram),
183                 K(cached),
184                 K(total_swapcache_pages),
185                 K(active),
186                 K(inactive),
187                 K(i.totalhigh),
188                 K(i.freehigh),
189                 K(i.totalram-i.totalhigh),
190                 K(i.freeram-i.freehigh),
191                 K(i.totalswap),
192                 K(i.freeswap),
193                 K(ps.nr_dirty),
194                 K(ps.nr_writeback),
195                 K(global_page_state(NR_ANON_PAGES)),
196                 K(global_page_state(NR_FILE_MAPPED)),
197                 K(ps.nr_slab),
198                 K(allowed),
199                 K(committed),
200                 K(ps.nr_page_table_pages),
201                 (unsigned long)VMALLOC_TOTAL >> 10,
202                 vmi.used >> 10,
203                 vmi.largest_chunk >> 10
204                 );
205
206                 len += hugetlb_report_meminfo(page + len);
207
208         return proc_calc_metrics(page, start, off, count, eof, len);
209 #undef K
210 }
211
212 extern struct seq_operations fragmentation_op;
213 static int fragmentation_open(struct inode *inode, struct file *file)
214 {
215         (void)inode;
216         return seq_open(file, &fragmentation_op);
217 }
218
219 static struct file_operations fragmentation_file_operations = {
220         .open           = fragmentation_open,
221         .read           = seq_read,
222         .llseek         = seq_lseek,
223         .release        = seq_release,
224 };
225
226 extern struct seq_operations zoneinfo_op;
227 static int zoneinfo_open(struct inode *inode, struct file *file)
228 {
229         return seq_open(file, &zoneinfo_op);
230 }
231
232 static struct file_operations proc_zoneinfo_file_operations = {
233         .open           = zoneinfo_open,
234         .read           = seq_read,
235         .llseek         = seq_lseek,
236         .release        = seq_release,
237 };
238
239 static int version_read_proc(char *page, char **start, off_t off,
240                                  int count, int *eof, void *data)
241 {
242         int len;
243
244         strcpy(page, linux_banner);
245         len = strlen(page);
246         return proc_calc_metrics(page, start, off, count, eof, len);
247 }
248
249 extern struct seq_operations cpuinfo_op;
250 static int cpuinfo_open(struct inode *inode, struct file *file)
251 {
252         return seq_open(file, &cpuinfo_op);
253 }
254
255 static struct file_operations proc_cpuinfo_operations = {
256         .open           = cpuinfo_open,
257         .read           = seq_read,
258         .llseek         = seq_lseek,
259         .release        = seq_release,
260 };
261
262 static int devinfo_show(struct seq_file *f, void *v)
263 {
264         int i = *(loff_t *) v;
265
266         if (i < CHRDEV_MAJOR_HASH_SIZE) {
267                 if (i == 0)
268                         seq_printf(f, "Character devices:\n");
269                 chrdev_show(f, i);
270         } else {
271                 i -= CHRDEV_MAJOR_HASH_SIZE;
272                 if (i == 0)
273                         seq_printf(f, "\nBlock devices:\n");
274                 blkdev_show(f, i);
275         }
276         return 0;
277 }
278
279 static void *devinfo_start(struct seq_file *f, loff_t *pos)
280 {
281         if (*pos < (BLKDEV_MAJOR_HASH_SIZE + CHRDEV_MAJOR_HASH_SIZE))
282                 return pos;
283         return NULL;
284 }
285
286 static void *devinfo_next(struct seq_file *f, void *v, loff_t *pos)
287 {
288         (*pos)++;
289         if (*pos >= (BLKDEV_MAJOR_HASH_SIZE + CHRDEV_MAJOR_HASH_SIZE))
290                 return NULL;
291         return pos;
292 }
293
294 static void devinfo_stop(struct seq_file *f, void *v)
295 {
296         /* Nothing to do */
297 }
298
299 static struct seq_operations devinfo_ops = {
300         .start = devinfo_start,
301         .next  = devinfo_next,
302         .stop  = devinfo_stop,
303         .show  = devinfo_show
304 };
305
306 static int devinfo_open(struct inode *inode, struct file *filp)
307 {
308         return seq_open(filp, &devinfo_ops);
309 }
310
311 static struct file_operations proc_devinfo_operations = {
312         .open           = devinfo_open,
313         .read           = seq_read,
314         .llseek         = seq_lseek,
315         .release        = seq_release,
316 };
317
318 extern struct seq_operations vmstat_op;
319 static int vmstat_open(struct inode *inode, struct file *file)
320 {
321         return seq_open(file, &vmstat_op);
322 }
323 static struct file_operations proc_vmstat_file_operations = {
324         .open           = vmstat_open,
325         .read           = seq_read,
326         .llseek         = seq_lseek,
327         .release        = seq_release,
328 };
329
330 #ifdef CONFIG_PROC_HARDWARE
331 static int hardware_read_proc(char *page, char **start, off_t off,
332                                  int count, int *eof, void *data)
333 {
334         int len = get_hardware_list(page);
335         return proc_calc_metrics(page, start, off, count, eof, len);
336 }
337 #endif
338
339 #ifdef CONFIG_STRAM_PROC
340 static int stram_read_proc(char *page, char **start, off_t off,
341                                  int count, int *eof, void *data)
342 {
343         int len = get_stram_list(page);
344         return proc_calc_metrics(page, start, off, count, eof, len);
345 }
346 #endif
347
348 extern struct seq_operations partitions_op;
349 static int partitions_open(struct inode *inode, struct file *file)
350 {
351         return seq_open(file, &partitions_op);
352 }
353 static struct file_operations proc_partitions_operations = {
354         .open           = partitions_open,
355         .read           = seq_read,
356         .llseek         = seq_lseek,
357         .release        = seq_release,
358 };
359
360 extern struct seq_operations diskstats_op;
361 static int diskstats_open(struct inode *inode, struct file *file)
362 {
363         return seq_open(file, &diskstats_op);
364 }
365 static struct file_operations proc_diskstats_operations = {
366         .open           = diskstats_open,
367         .read           = seq_read,
368         .llseek         = seq_lseek,
369         .release        = seq_release,
370 };
371
372 #ifdef CONFIG_MODULES
373 extern struct seq_operations modules_op;
374 static int modules_open(struct inode *inode, struct file *file)
375 {
376         return seq_open(file, &modules_op);
377 }
378 static struct file_operations proc_modules_operations = {
379         .open           = modules_open,
380         .read           = seq_read,
381         .llseek         = seq_lseek,
382         .release        = seq_release,
383 };
384 #endif
385
386 #ifdef CONFIG_SLAB
387 extern struct seq_operations slabinfo_op;
388 extern ssize_t slabinfo_write(struct file *, const char __user *, size_t, loff_t *);
389 static int slabinfo_open(struct inode *inode, struct file *file)
390 {
391         return seq_open(file, &slabinfo_op);
392 }
393 static struct file_operations proc_slabinfo_operations = {
394         .open           = slabinfo_open,
395         .read           = seq_read,
396         .write          = slabinfo_write,
397         .llseek         = seq_lseek,
398         .release        = seq_release,
399 };
400
401 #ifdef CONFIG_DEBUG_SLAB_LEAK
402 extern struct seq_operations slabstats_op;
403 static int slabstats_open(struct inode *inode, struct file *file)
404 {
405         unsigned long *n = kzalloc(PAGE_SIZE, GFP_KERNEL);
406         int ret = -ENOMEM;
407         if (n) {
408                 ret = seq_open(file, &slabstats_op);
409                 if (!ret) {
410                         struct seq_file *m = file->private_data;
411                         *n = PAGE_SIZE / (2 * sizeof(unsigned long));
412                         m->private = n;
413                         n = NULL;
414                 }
415                 kfree(n);
416         }
417         return ret;
418 }
419
420 static int slabstats_release(struct inode *inode, struct file *file)
421 {
422         struct seq_file *m = file->private_data;
423         kfree(m->private);
424         return seq_release(inode, file);
425 }
426
427 static struct file_operations proc_slabstats_operations = {
428         .open           = slabstats_open,
429         .read           = seq_read,
430         .llseek         = seq_lseek,
431         .release        = slabstats_release,
432 };
433 #endif
434 #endif
435
436 static int show_stat(struct seq_file *p, void *v)
437 {
438         int i;
439         unsigned long jif;
440         cputime64_t user, nice, system, idle, iowait, irq, softirq, steal;
441         u64 sum = 0;
442
443         user = nice = system = idle = iowait =
444                 irq = softirq = steal = cputime64_zero;
445         jif = - wall_to_monotonic.tv_sec;
446         if (wall_to_monotonic.tv_nsec)
447                 --jif;
448
449         for_each_possible_cpu(i) {
450                 int j;
451
452                 user = cputime64_add(user, kstat_cpu(i).cpustat.user);
453                 nice = cputime64_add(nice, kstat_cpu(i).cpustat.nice);
454                 system = cputime64_add(system, kstat_cpu(i).cpustat.system);
455                 idle = cputime64_add(idle, kstat_cpu(i).cpustat.idle);
456                 iowait = cputime64_add(iowait, kstat_cpu(i).cpustat.iowait);
457                 irq = cputime64_add(irq, kstat_cpu(i).cpustat.irq);
458                 softirq = cputime64_add(softirq, kstat_cpu(i).cpustat.softirq);
459                 steal = cputime64_add(steal, kstat_cpu(i).cpustat.steal);
460                 for (j = 0 ; j < NR_IRQS ; j++)
461                         sum += kstat_cpu(i).irqs[j];
462         }
463
464         seq_printf(p, "cpu  %llu %llu %llu %llu %llu %llu %llu %llu\n",
465                 (unsigned long long)cputime64_to_clock_t(user),
466                 (unsigned long long)cputime64_to_clock_t(nice),
467                 (unsigned long long)cputime64_to_clock_t(system),
468                 (unsigned long long)cputime64_to_clock_t(idle),
469                 (unsigned long long)cputime64_to_clock_t(iowait),
470                 (unsigned long long)cputime64_to_clock_t(irq),
471                 (unsigned long long)cputime64_to_clock_t(softirq),
472                 (unsigned long long)cputime64_to_clock_t(steal));
473         for_each_online_cpu(i) {
474
475                 /* Copy values here to work around gcc-2.95.3, gcc-2.96 */
476                 user = kstat_cpu(i).cpustat.user;
477                 nice = kstat_cpu(i).cpustat.nice;
478                 system = kstat_cpu(i).cpustat.system;
479                 idle = kstat_cpu(i).cpustat.idle;
480                 iowait = kstat_cpu(i).cpustat.iowait;
481                 irq = kstat_cpu(i).cpustat.irq;
482                 softirq = kstat_cpu(i).cpustat.softirq;
483                 steal = kstat_cpu(i).cpustat.steal;
484                 seq_printf(p, "cpu%d %llu %llu %llu %llu %llu %llu %llu %llu\n",
485                         i,
486                         (unsigned long long)cputime64_to_clock_t(user),
487                         (unsigned long long)cputime64_to_clock_t(nice),
488                         (unsigned long long)cputime64_to_clock_t(system),
489                         (unsigned long long)cputime64_to_clock_t(idle),
490                         (unsigned long long)cputime64_to_clock_t(iowait),
491                         (unsigned long long)cputime64_to_clock_t(irq),
492                         (unsigned long long)cputime64_to_clock_t(softirq),
493                         (unsigned long long)cputime64_to_clock_t(steal));
494         }
495         seq_printf(p, "intr %llu", (unsigned long long)sum);
496
497 #if !defined(CONFIG_PPC64) && !defined(CONFIG_ALPHA) && !defined(CONFIG_IA64)
498         for (i = 0; i < NR_IRQS; i++)
499                 seq_printf(p, " %u", kstat_irqs(i));
500 #endif
501
502         seq_printf(p,
503                 "\nctxt %llu\n"
504                 "btime %lu\n"
505                 "processes %lu\n"
506                 "procs_running %lu\n"
507                 "procs_blocked %lu\n",
508                 nr_context_switches(),
509                 (unsigned long)jif,
510                 total_forks,
511                 nr_running(),
512                 nr_iowait());
513
514         return 0;
515 }
516
517 static int stat_open(struct inode *inode, struct file *file)
518 {
519         unsigned size = 4096 * (1 + num_possible_cpus() / 32);
520         char *buf;
521         struct seq_file *m;
522         int res;
523
524         /* don't ask for more than the kmalloc() max size, currently 128 KB */
525         if (size > 128 * 1024)
526                 size = 128 * 1024;
527         buf = kmalloc(size, GFP_KERNEL);
528         if (!buf)
529                 return -ENOMEM;
530
531         res = single_open(file, show_stat, NULL);
532         if (!res) {
533                 m = file->private_data;
534                 m->buf = buf;
535                 m->size = size;
536         } else
537                 kfree(buf);
538         return res;
539 }
540 static struct file_operations proc_stat_operations = {
541         .open           = stat_open,
542         .read           = seq_read,
543         .llseek         = seq_lseek,
544         .release        = single_release,
545 };
546
547 /*
548  * /proc/interrupts
549  */
550 static void *int_seq_start(struct seq_file *f, loff_t *pos)
551 {
552         return (*pos <= NR_IRQS) ? pos : NULL;
553 }
554
555 static void *int_seq_next(struct seq_file *f, void *v, loff_t *pos)
556 {
557         (*pos)++;
558         if (*pos > NR_IRQS)
559                 return NULL;
560         return pos;
561 }
562
563 static void int_seq_stop(struct seq_file *f, void *v)
564 {
565         /* Nothing to do */
566 }
567
568
569 extern int show_interrupts(struct seq_file *f, void *v); /* In arch code */
570 static struct seq_operations int_seq_ops = {
571         .start = int_seq_start,
572         .next  = int_seq_next,
573         .stop  = int_seq_stop,
574         .show  = show_interrupts
575 };
576
577 static int interrupts_open(struct inode *inode, struct file *filp)
578 {
579         return seq_open(filp, &int_seq_ops);
580 }
581
582 static struct file_operations proc_interrupts_operations = {
583         .open           = interrupts_open,
584         .read           = seq_read,
585         .llseek         = seq_lseek,
586         .release        = seq_release,
587 };
588
589 static int filesystems_read_proc(char *page, char **start, off_t off,
590                                  int count, int *eof, void *data)
591 {
592         int len = get_filesystem_list(page);
593         return proc_calc_metrics(page, start, off, count, eof, len);
594 }
595
596 static int cmdline_read_proc(char *page, char **start, off_t off,
597                                  int count, int *eof, void *data)
598 {
599         int len;
600
601         len = sprintf(page, "%s\n", saved_command_line);
602         return proc_calc_metrics(page, start, off, count, eof, len);
603 }
604
605 static int locks_read_proc(char *page, char **start, off_t off,
606                                  int count, int *eof, void *data)
607 {
608         int len = get_locks_status(page, start, off, count);
609
610         if (len < count)
611                 *eof = 1;
612         return len;
613 }
614
615 static int execdomains_read_proc(char *page, char **start, off_t off,
616                                  int count, int *eof, void *data)
617 {
618         int len = get_exec_domain_list(page);
619         return proc_calc_metrics(page, start, off, count, eof, len);
620 }
621
622 #ifdef CONFIG_MAGIC_SYSRQ
623 /*
624  * writing 'C' to /proc/sysrq-trigger is like sysrq-C
625  */
626 static ssize_t write_sysrq_trigger(struct file *file, const char __user *buf,
627                                    size_t count, loff_t *ppos)
628 {
629         if (count) {
630                 char c;
631
632                 if (get_user(c, buf))
633                         return -EFAULT;
634                 __handle_sysrq(c, NULL, NULL, 0);
635         }
636         return count;
637 }
638
639 static struct file_operations proc_sysrq_trigger_operations = {
640         .write          = write_sysrq_trigger,
641 };
642 #endif
643
644 struct proc_dir_entry *proc_root_kcore;
645
646 void create_seq_entry(char *name, mode_t mode, const struct file_operations *f)
647 {
648         struct proc_dir_entry *entry;
649         entry = create_proc_entry(name, mode, NULL);
650         if (entry)
651                 entry->proc_fops = f;
652 }
653
654 void __init proc_misc_init(void)
655 {
656         struct proc_dir_entry *entry;
657         static struct {
658                 char *name;
659                 int (*read_proc)(char*,char**,off_t,int,int*,void*);
660         } *p, simple_ones[] = {
661                 {"loadavg",     loadavg_read_proc},
662                 {"uptime",      uptime_read_proc},
663                 {"meminfo",     meminfo_read_proc},
664                 {"version",     version_read_proc},
665 #ifdef CONFIG_PROC_HARDWARE
666                 {"hardware",    hardware_read_proc},
667 #endif
668 #ifdef CONFIG_STRAM_PROC
669                 {"stram",       stram_read_proc},
670 #endif
671                 {"filesystems", filesystems_read_proc},
672                 {"cmdline",     cmdline_read_proc},
673                 {"locks",       locks_read_proc},
674                 {"execdomains", execdomains_read_proc},
675                 {NULL,}
676         };
677         for (p = simple_ones; p->name; p++)
678                 create_proc_read_entry(p->name, 0, NULL, p->read_proc, NULL);
679
680         proc_symlink("mounts", NULL, "self/mounts");
681
682         /* And now for trickier ones */
683         entry = create_proc_entry("kmsg", S_IRUSR, &proc_root);
684         if (entry)
685                 entry->proc_fops = &proc_kmsg_operations;
686         create_seq_entry("devices", 0, &proc_devinfo_operations);
687         create_seq_entry("cpuinfo", 0, &proc_cpuinfo_operations);
688         create_seq_entry("partitions", 0, &proc_partitions_operations);
689         create_seq_entry("stat", 0, &proc_stat_operations);
690         create_seq_entry("interrupts", 0, &proc_interrupts_operations);
691 #ifdef CONFIG_SLAB
692         create_seq_entry("slabinfo",S_IWUSR|S_IRUGO,&proc_slabinfo_operations);
693 #ifdef CONFIG_DEBUG_SLAB_LEAK
694         create_seq_entry("slab_allocators", 0 ,&proc_slabstats_operations);
695 #endif
696 #endif
697         create_seq_entry("buddyinfo",S_IRUGO, &fragmentation_file_operations);
698         create_seq_entry("vmstat",S_IRUGO, &proc_vmstat_file_operations);
699         create_seq_entry("zoneinfo",S_IRUGO, &proc_zoneinfo_file_operations);
700         create_seq_entry("diskstats", 0, &proc_diskstats_operations);
701 #ifdef CONFIG_MODULES
702         create_seq_entry("modules", 0, &proc_modules_operations);
703 #endif
704 #ifdef CONFIG_SCHEDSTATS
705         create_seq_entry("schedstat", 0, &proc_schedstat_operations);
706 #endif
707 #ifdef CONFIG_PROC_KCORE
708         proc_root_kcore = create_proc_entry("kcore", S_IRUSR, NULL);
709         if (proc_root_kcore) {
710                 proc_root_kcore->proc_fops = &proc_kcore_operations;
711                 proc_root_kcore->size =
712                                 (size_t)high_memory - PAGE_OFFSET + PAGE_SIZE;
713         }
714 #endif
715 #ifdef CONFIG_PROC_VMCORE
716         proc_vmcore = create_proc_entry("vmcore", S_IRUSR, NULL);
717         if (proc_vmcore)
718                 proc_vmcore->proc_fops = &proc_vmcore_operations;
719 #endif
720 #ifdef CONFIG_MAGIC_SYSRQ
721         entry = create_proc_entry("sysrq-trigger", S_IWUSR, NULL);
722         if (entry)
723                 entry->proc_fops = &proc_sysrq_trigger_operations;
724 #endif
725 }