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