proc_misc.c 16.3 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
/*
 *  linux/fs/proc/proc_misc.c
 *
 *  linux/fs/proc/array.c
 *  Copyright (C) 1992  by Linus Torvalds
 *  based on ideas by Darren Senn
 *
 *  This used to be the part of array.c. See the rest of history and credits
 *  there. I took this into a separate file and switched the thing to generic
 *  proc_file_inode_operations, leaving in array.c only per-process stuff.
 *  Inumbers allocation made dynamic (via create_proc_entry()).  AV, May 1999.
 *
 * Changes:
 * Fulton Green      :  Encapsulated position metric calculations.
 *			<kernel@FultonGreen.com>
 */

#include <linux/types.h>
#include <linux/errno.h>
20
#include <linux/time.h>
Linus Torvalds's avatar
Linus Torvalds committed
21 22 23 24 25 26 27 28 29
#include <linux/kernel.h>
#include <linux/kernel_stat.h>
#include <linux/tty.h>
#include <linux/string.h>
#include <linux/mman.h>
#include <linux/proc_fs.h>
#include <linux/ioport.h>
#include <linux/config.h>
#include <linux/mm.h>
Andrew Morton's avatar
Andrew Morton committed
30
#include <linux/mmzone.h>
Linus Torvalds's avatar
Linus Torvalds committed
31 32 33 34 35 36 37 38
#include <linux/pagemap.h>
#include <linux/swap.h>
#include <linux/slab.h>
#include <linux/smp.h>
#include <linux/signal.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/smp_lock.h>
Linus Torvalds's avatar
Linus Torvalds committed
39
#include <linux/seq_file.h>
40
#include <linux/times.h>
John Levon's avatar
John Levon committed
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>
Linus Torvalds's avatar
Linus Torvalds committed
47 48 49
#include <asm/uaccess.h>
#include <asm/pgtable.h>
#include <asm/io.h>
50
#include <asm/tlb.h>
51
#include <asm/div64.h>
52
#include "internal.h"
Linus Torvalds's avatar
Linus Torvalds committed
53 54 55 56 57 58 59 60 61

#define LOAD_INT(x) ((x) >> FSHIFT)
#define LOAD_FRAC(x) LOAD_INT(((x) & (FIXED_1-1)) * 100)
/*
 * Warning: stuff below (imported functions) assumes that its output will fit
 * into one page. For some of those functions it may be wrong. Moreover, we
 * have a way to deal with that gracefully. Right now I used straightforward
 * wrappers, but this needs further analysis wrt potential overflows.
 */
62 63
extern int get_hardware_list(char *);
extern int get_stram_list(char *);
Brian Gerst's avatar
Brian Gerst committed
64
extern int get_chrdev_list(char *);
Linus Torvalds's avatar
Linus Torvalds committed
65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89
extern int get_filesystem_list(char *);
extern int get_exec_domain_list(char *);
extern int get_dma_list(char *);
extern int get_locks_status (char *, char **, off_t, int);

static int proc_calc_metrics(char *page, char **start, off_t off,
				 int count, int *eof, int len)
{
	if (len <= off+count) *eof = 1;
	*start = page + off;
	len -= off;
	if (len>count) len = count;
	if (len<0) len = 0;
	return len;
}

static int loadavg_read_proc(char *page, char **start, off_t off,
				 int count, int *eof, void *data)
{
	int a, b, c;
	int len;

	a = avenrun[0] + (FIXED_1/200);
	b = avenrun[1] + (FIXED_1/200);
	c = avenrun[2] + (FIXED_1/200);
Linus Torvalds's avatar
Linus Torvalds committed
90
	len = sprintf(page,"%d.%02d %d.%02d %d.%02d %ld/%d %d\n",
Linus Torvalds's avatar
Linus Torvalds committed
91 92 93
		LOAD_INT(a), LOAD_FRAC(a),
		LOAD_INT(b), LOAD_FRAC(b),
		LOAD_INT(c), LOAD_FRAC(c),
Linus Torvalds's avatar
Linus Torvalds committed
94
		nr_running(), nr_threads, last_pid);
Linus Torvalds's avatar
Linus Torvalds committed
95 96 97 98 99 100
	return proc_calc_metrics(page, start, off, count, eof, len);
}

static int uptime_read_proc(char *page, char **start, off_t off,
				 int count, int *eof, void *data)
{
101 102
	struct timespec uptime;
	struct timespec idle;
Linus Torvalds's avatar
Linus Torvalds committed
103
	int len;
104
	cputime_t idletime = cputime_add(init_task.utime, init_task.stime);
Linus Torvalds's avatar
Linus Torvalds committed
105

106
	do_posix_clock_monotonic_gettime(&uptime);
107
	cputime_to_timespec(idletime, &idle);
108 109 110 111 112
	len = sprintf(page,"%lu.%02lu %lu.%02lu\n",
			(unsigned long) uptime.tv_sec,
			(uptime.tv_nsec / (NSEC_PER_SEC / 100)),
			(unsigned long) idle.tv_sec,
			(idle.tv_nsec / (NSEC_PER_SEC / 100)));
113

Linus Torvalds's avatar
Linus Torvalds committed
114 115 116 117 118 119 120
	return proc_calc_metrics(page, start, off, count, eof, len);
}

static int meminfo_read_proc(char *page, char **start, off_t off,
				 int count, int *eof, void *data)
{
	struct sysinfo i;
121
	int len;
Andrew Morton's avatar
Andrew Morton committed
122
	struct page_state ps;
Andrew Morton's avatar
Andrew Morton committed
123 124
	unsigned long inactive;
	unsigned long active;
125
	unsigned long free;
126 127
	unsigned long committed;
	unsigned long allowed;
128
	struct vmalloc_info vmi;
Linus Torvalds's avatar
Linus Torvalds committed
129

Andrew Morton's avatar
Andrew Morton committed
130
	get_page_state(&ps);
131
	get_zone_counts(&active, &inactive, &free);
Andrew Morton's avatar
Andrew Morton committed
132

Linus Torvalds's avatar
Linus Torvalds committed
133 134 135 136
/*
 * display in kilobytes.
 */
#define K(x) ((x) << (PAGE_SHIFT - 10))
Linus Torvalds's avatar
Linus Torvalds committed
137 138
	si_meminfo(&i);
	si_swapinfo(&i);
Andrew Morton's avatar
Andrew Morton committed
139
	committed = atomic_read(&vm_committed_space);
140 141
	allowed = ((totalram_pages - hugetlb_total_pages())
		* sysctl_overcommit_ratio / 100) + total_swap_pages;
Linus Torvalds's avatar
Linus Torvalds committed
142

143
	get_vmalloc_info(&vmi);
144

Linus Torvalds's avatar
Linus Torvalds committed
145 146 147
	/*
	 * Tagged format, for easy grepping and expansion.
	 */
Linus Torvalds's avatar
Linus Torvalds committed
148
	len = sprintf(page,
Linus Torvalds's avatar
Linus Torvalds committed
149 150
		"MemTotal:     %8lu kB\n"
		"MemFree:      %8lu kB\n"
151
		"Buffers:      %8lu kB\n"
Linus Torvalds's avatar
Linus Torvalds committed
152 153
		"Cached:       %8lu kB\n"
		"SwapCached:   %8lu kB\n"
154 155
		"Active:       %8lu kB\n"
		"Inactive:     %8lu kB\n"
Linus Torvalds's avatar
Linus Torvalds committed
156 157 158 159 160
		"HighTotal:    %8lu kB\n"
		"HighFree:     %8lu kB\n"
		"LowTotal:     %8lu kB\n"
		"LowFree:      %8lu kB\n"
		"SwapTotal:    %8lu kB\n"
Andrew Morton's avatar
Andrew Morton committed
161 162
		"SwapFree:     %8lu kB\n"
		"Dirty:        %8lu kB\n"
Andrew Morton's avatar
Andrew Morton committed
163
		"Writeback:    %8lu kB\n"
164
		"Mapped:       %8lu kB\n"
165
		"Slab:         %8lu kB\n"
166 167
		"CommitLimit:  %8lu kB\n"
		"Committed_AS: %8lu kB\n"
168 169 170 171
		"PageTables:   %8lu kB\n"
		"VmallocTotal: %8lu kB\n"
		"VmallocUsed:  %8lu kB\n"
		"VmallocChunk: %8lu kB\n",
Linus Torvalds's avatar
Linus Torvalds committed
172 173
		K(i.totalram),
		K(i.freeram),
174
		K(i.bufferram),
175
		K(get_page_cache_size()-total_swapcache_pages-i.bufferram),
176
		K(total_swapcache_pages),
Andrew Morton's avatar
Andrew Morton committed
177 178
		K(active),
		K(inactive),
Linus Torvalds's avatar
Linus Torvalds committed
179 180 181 182 183
		K(i.totalhigh),
		K(i.freehigh),
		K(i.totalram-i.totalhigh),
		K(i.freeram-i.freehigh),
		K(i.totalswap),
Andrew Morton's avatar
Andrew Morton committed
184 185
		K(i.freeswap),
		K(ps.nr_dirty),
Andrew Morton's avatar
Andrew Morton committed
186
		K(ps.nr_writeback),
187
		K(ps.nr_mapped),
188
		K(ps.nr_slab),
189
		K(allowed),
Andrew Morton's avatar
Andrew Morton committed
190
		K(committed),
191
		K(ps.nr_page_table_pages),
192 193 194
		VMALLOC_TOTAL >> 10,
		vmi.used >> 10,
		vmi.largest_chunk >> 10
Andrew Morton's avatar
Andrew Morton committed
195
		);
Linus Torvalds's avatar
Linus Torvalds committed
196

197
		len += hugetlb_report_meminfo(page + len);
Andrew Morton's avatar
Andrew Morton committed
198

Linus Torvalds's avatar
Linus Torvalds committed
199 200 201 202
	return proc_calc_metrics(page, start, off, count, eof, len);
#undef K
}

Andrew Morton's avatar
Andrew Morton committed
203 204 205 206 207 208 209 210
extern struct seq_operations fragmentation_op;
static int fragmentation_open(struct inode *inode, struct file *file)
{
	(void)inode;
	return seq_open(file, &fragmentation_op);
}

static struct file_operations fragmentation_file_operations = {
211 212 213 214
	.open		= fragmentation_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= seq_release,
Andrew Morton's avatar
Andrew Morton committed
215 216
};

Linus Torvalds's avatar
Linus Torvalds committed
217 218 219 220 221 222 223 224 225 226
static int version_read_proc(char *page, char **start, off_t off,
				 int count, int *eof, void *data)
{
	int len;

	strcpy(page, linux_banner);
	len = strlen(page);
	return proc_calc_metrics(page, start, off, count, eof, len);
}

Linus Torvalds's avatar
Linus Torvalds committed
227 228
extern struct seq_operations cpuinfo_op;
static int cpuinfo_open(struct inode *inode, struct file *file)
Linus Torvalds's avatar
Linus Torvalds committed
229
{
Linus Torvalds's avatar
Linus Torvalds committed
230
	return seq_open(file, &cpuinfo_op);
Linus Torvalds's avatar
Linus Torvalds committed
231
}
Linus Torvalds's avatar
Linus Torvalds committed
232
static struct file_operations proc_cpuinfo_operations = {
233 234 235 236
	.open		= cpuinfo_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= seq_release,
Linus Torvalds's avatar
Linus Torvalds committed
237
};
Linus Torvalds's avatar
Linus Torvalds committed
238

239 240 241 242 243 244
extern struct seq_operations vmstat_op;
static int vmstat_open(struct inode *inode, struct file *file)
{
	return seq_open(file, &vmstat_op);
}
static struct file_operations proc_vmstat_file_operations = {
245 246 247 248
	.open		= vmstat_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= seq_release,
249 250
};

251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268
#ifdef CONFIG_PROC_HARDWARE
static int hardware_read_proc(char *page, char **start, off_t off,
				 int count, int *eof, void *data)
{
	int len = get_hardware_list(page);
	return proc_calc_metrics(page, start, off, count, eof, len);
}
#endif

#ifdef CONFIG_STRAM_PROC
static int stram_read_proc(char *page, char **start, off_t off,
				 int count, int *eof, void *data)
{
	int len = get_stram_list(page);
	return proc_calc_metrics(page, start, off, count, eof, len);
}
#endif

269 270 271 272 273 274
extern struct seq_operations partitions_op;
static int partitions_open(struct inode *inode, struct file *file)
{
	return seq_open(file, &partitions_op);
}
static struct file_operations proc_partitions_operations = {
275 276 277 278
	.open		= partitions_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= seq_release,
279 280
};

281 282 283 284 285 286
extern struct seq_operations diskstats_op;
static int diskstats_open(struct inode *inode, struct file *file)
{
	return seq_open(file, &diskstats_op);
}
static struct file_operations proc_diskstats_operations = {
287 288 289 290
	.open		= diskstats_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= seq_release,
291 292
};

Linus Torvalds's avatar
Linus Torvalds committed
293
#ifdef CONFIG_MODULES
294 295
extern struct seq_operations modules_op;
static int modules_open(struct inode *inode, struct file *file)
Linus Torvalds's avatar
Linus Torvalds committed
296
{
297
	return seq_open(file, &modules_op);
Linus Torvalds's avatar
Linus Torvalds committed
298
}
299
static struct file_operations proc_modules_operations = {
300 301 302 303
	.open		= modules_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= seq_release,
304
};
Linus Torvalds's avatar
Linus Torvalds committed
305 306
#endif

307
extern struct seq_operations slabinfo_op;
308
extern ssize_t slabinfo_write(struct file *, const char __user *, size_t, loff_t *);
309 310 311 312 313
static int slabinfo_open(struct inode *inode, struct file *file)
{
	return seq_open(file, &slabinfo_op);
}
static struct file_operations proc_slabinfo_operations = {
314 315 316 317 318
	.open		= slabinfo_open,
	.read		= seq_read,
	.write		= slabinfo_write,
	.llseek		= seq_lseek,
	.release	= seq_release,
319 320
};

Adrian Bunk's avatar
Adrian Bunk committed
321
static int show_stat(struct seq_file *p, void *v)
Linus Torvalds's avatar
Linus Torvalds committed
322
{
323
	int i;
Andrew Morton's avatar
Andrew Morton committed
324
	unsigned long jif;
325 326
	cputime64_t user, nice, system, idle, iowait, irq, softirq, steal;
	u64 sum = 0;
327

328 329
	user = nice = system = idle = iowait =
		irq = softirq = steal = cputime64_zero;
Andrew Morton's avatar
Andrew Morton committed
330 331 332
	jif = - wall_to_monotonic.tv_sec;
	if (wall_to_monotonic.tv_nsec)
		--jif;
Linus Torvalds's avatar
Linus Torvalds committed
333

334
	for_each_cpu(i) {
335
		int j;
Linus Torvalds's avatar
Linus Torvalds committed
336

337 338 339 340 341 342 343 344
		user = cputime64_add(user, kstat_cpu(i).cpustat.user);
		nice = cputime64_add(nice, kstat_cpu(i).cpustat.nice);
		system = cputime64_add(system, kstat_cpu(i).cpustat.system);
		idle = cputime64_add(idle, kstat_cpu(i).cpustat.idle);
		iowait = cputime64_add(iowait, kstat_cpu(i).cpustat.iowait);
		irq = cputime64_add(irq, kstat_cpu(i).cpustat.irq);
		softirq = cputime64_add(softirq, kstat_cpu(i).cpustat.softirq);
		steal = cputime64_add(steal, kstat_cpu(i).cpustat.steal);
Linus Torvalds's avatar
Linus Torvalds committed
345
		for (j = 0 ; j < NR_IRQS ; j++)
346
			sum += kstat_cpu(i).irqs[j];
Linus Torvalds's avatar
Linus Torvalds committed
347 348
	}

349 350 351 352 353 354 355 356 357
	seq_printf(p, "cpu  %llu %llu %llu %llu %llu %llu %llu %llu\n",
		(unsigned long long)cputime64_to_clock_t(user),
		(unsigned long long)cputime64_to_clock_t(nice),
		(unsigned long long)cputime64_to_clock_t(system),
		(unsigned long long)cputime64_to_clock_t(idle),
		(unsigned long long)cputime64_to_clock_t(iowait),
		(unsigned long long)cputime64_to_clock_t(irq),
		(unsigned long long)cputime64_to_clock_t(softirq),
		(unsigned long long)cputime64_to_clock_t(steal));
358
	for_each_online_cpu(i) {
359 360 361 362 363 364 365 366 367

		/* Copy values here to work around gcc-2.95.3, gcc-2.96 */
		user = kstat_cpu(i).cpustat.user;
		nice = kstat_cpu(i).cpustat.nice;
		system = kstat_cpu(i).cpustat.system;
		idle = kstat_cpu(i).cpustat.idle;
		iowait = kstat_cpu(i).cpustat.iowait;
		irq = kstat_cpu(i).cpustat.irq;
		softirq = kstat_cpu(i).cpustat.softirq;
368 369
		steal = kstat_cpu(i).cpustat.steal;
		seq_printf(p, "cpu%d %llu %llu %llu %llu %llu %llu %llu %llu\n",
Linus Torvalds's avatar
Linus Torvalds committed
370
			i,
371 372 373 374 375 376 377 378
			(unsigned long long)cputime64_to_clock_t(user),
			(unsigned long long)cputime64_to_clock_t(nice),
			(unsigned long long)cputime64_to_clock_t(system),
			(unsigned long long)cputime64_to_clock_t(idle),
			(unsigned long long)cputime64_to_clock_t(iowait),
			(unsigned long long)cputime64_to_clock_t(irq),
			(unsigned long long)cputime64_to_clock_t(softirq),
			(unsigned long long)cputime64_to_clock_t(steal));
379
	}
380
	seq_printf(p, "intr %llu", (unsigned long long)sum);
381

382
#if !defined(CONFIG_PPC64) && !defined(CONFIG_ALPHA)
383
	for (i = 0; i < NR_IRQS; i++)
384
		seq_printf(p, " %u", kstat_irqs(i));
Linus Torvalds's avatar
Linus Torvalds committed
385
#endif
Linus Torvalds's avatar
Linus Torvalds committed
386

387
	seq_printf(p,
388
		"\nctxt %llu\n"
Linus Torvalds's avatar
Linus Torvalds committed
389
		"btime %lu\n"
390 391
		"processes %lu\n"
		"procs_running %lu\n"
Andrew Morton's avatar
Andrew Morton committed
392
		"procs_blocked %lu\n",
Linus Torvalds's avatar
Linus Torvalds committed
393
		nr_context_switches(),
394
		(unsigned long)jif,
395 396
		total_forks,
		nr_running(),
Andrew Morton's avatar
Andrew Morton committed
397
		nr_iowait());
Linus Torvalds's avatar
Linus Torvalds committed
398

399 400 401 402 403
	return 0;
}

static int stat_open(struct inode *inode, struct file *file)
{
404
	unsigned size = 4096 * (1 + num_possible_cpus() / 32);
405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423
	char *buf;
	struct seq_file *m;
	int res;

	/* don't ask for more than the kmalloc() max size, currently 128 KB */
	if (size > 128 * 1024)
		size = 128 * 1024;
	buf = kmalloc(size, GFP_KERNEL);
	if (!buf)
		return -ENOMEM;

	res = single_open(file, show_stat, NULL);
	if (!res) {
		m = file->private_data;
		m->buf = buf;
		m->size = size;
	} else
		kfree(buf);
	return res;
Linus Torvalds's avatar
Linus Torvalds committed
424
}
425 426 427 428 429 430
static struct file_operations proc_stat_operations = {
	.open		= stat_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
};
Linus Torvalds's avatar
Linus Torvalds committed
431 432 433 434

static int devices_read_proc(char *page, char **start, off_t off,
				 int count, int *eof, void *data)
{
Brian Gerst's avatar
Brian Gerst committed
435 436
	int len = get_chrdev_list(page);
	len += get_blkdev_list(page+len);
Linus Torvalds's avatar
Linus Torvalds committed
437 438 439
	return proc_calc_metrics(page, start, off, count, eof, len);
}

440 441 442 443
/*
 * /proc/interrupts
 */
static void *int_seq_start(struct seq_file *f, loff_t *pos)
Linus Torvalds's avatar
Linus Torvalds committed
444
{
445 446
	return (*pos <= NR_IRQS) ? pos : NULL;
}
Linus Torvalds's avatar
Linus Torvalds committed
447

448 449 450 451 452 453 454 455 456 457 458
static void *int_seq_next(struct seq_file *f, void *v, loff_t *pos)
{
	(*pos)++;
	if (*pos > NR_IRQS)
		return NULL;
	return pos;
}

static void int_seq_stop(struct seq_file *f, void *v)
{
	/* Nothing to do */
Linus Torvalds's avatar
Linus Torvalds committed
459
}
460 461 462 463 464 465 466 467 468 469


extern int show_interrupts(struct seq_file *f, void *v); /* In arch code */
static struct seq_operations int_seq_ops = {
	.start = int_seq_start,
	.next  = int_seq_next,
	.stop  = int_seq_stop,
	.show  = show_interrupts
};

Adrian Bunk's avatar
Adrian Bunk committed
470
static int interrupts_open(struct inode *inode, struct file *filp)
471 472 473 474
{
	return seq_open(filp, &int_seq_ops);
}

Linus Torvalds's avatar
Linus Torvalds committed
475
static struct file_operations proc_interrupts_operations = {
476 477 478
	.open		= interrupts_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
479
	.release	= seq_release,
Linus Torvalds's avatar
Linus Torvalds committed
480
};
Linus Torvalds's avatar
Linus Torvalds committed
481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500

static int filesystems_read_proc(char *page, char **start, off_t off,
				 int count, int *eof, void *data)
{
	int len = get_filesystem_list(page);
	return proc_calc_metrics(page, start, off, count, eof, len);
}

static int cmdline_read_proc(char *page, char **start, off_t off,
				 int count, int *eof, void *data)
{
	int len;

	len = sprintf(page, "%s\n", saved_command_line);
	return proc_calc_metrics(page, start, off, count, eof, len);
}

static int locks_read_proc(char *page, char **start, off_t off,
				 int count, int *eof, void *data)
{
501 502 503 504
	int len = get_locks_status(page, start, off, count);

	if (len < count)
		*eof = 1;
Linus Torvalds's avatar
Linus Torvalds committed
505 506 507 508 509 510 511 512 513 514
	return len;
}

static int execdomains_read_proc(char *page, char **start, off_t off,
				 int count, int *eof, void *data)
{
	int len = get_exec_domain_list(page);
	return proc_calc_metrics(page, start, off, count, eof, len);
}

515 516 517 518
#ifdef CONFIG_MAGIC_SYSRQ
/*
 * writing 'C' to /proc/sysrq-trigger is like sysrq-C
 */
519 520
static ssize_t write_sysrq_trigger(struct file *file, const char __user *buf,
				   size_t count, loff_t *ppos)
521 522 523 524 525 526
{
	if (count) {
		char c;

		if (get_user(c, buf))
			return -EFAULT;
527
		__handle_sysrq(c, NULL, NULL);
528 529 530 531 532 533 534 535 536
	}
	return count;
}

static struct file_operations proc_sysrq_trigger_operations = {
	.write		= write_sysrq_trigger,
};
#endif

Linus Torvalds's avatar
Linus Torvalds committed
537 538
struct proc_dir_entry *proc_root_kcore;

539
void create_seq_entry(char *name, mode_t mode, struct file_operations *f)
Linus Torvalds's avatar
Linus Torvalds committed
540 541 542 543 544 545 546
{
	struct proc_dir_entry *entry;
	entry = create_proc_entry(name, mode, NULL);
	if (entry)
		entry->proc_fops = f;
}

Linus Torvalds's avatar
Linus Torvalds committed
547 548 549 550 551 552 553 554 555 556 557
void __init proc_misc_init(void)
{
	struct proc_dir_entry *entry;
	static struct {
		char *name;
		int (*read_proc)(char*,char**,off_t,int,int*,void*);
	} *p, simple_ones[] = {
		{"loadavg",     loadavg_read_proc},
		{"uptime",	uptime_read_proc},
		{"meminfo",	meminfo_read_proc},
		{"version",	version_read_proc},
558 559 560 561 562 563
#ifdef CONFIG_PROC_HARDWARE
		{"hardware",	hardware_read_proc},
#endif
#ifdef CONFIG_STRAM_PROC
		{"stram",	stram_read_proc},
#endif
Linus Torvalds's avatar
Linus Torvalds committed
564 565 566 567 568 569 570 571 572 573
		{"devices",	devices_read_proc},
		{"filesystems",	filesystems_read_proc},
		{"cmdline",	cmdline_read_proc},
		{"locks",	locks_read_proc},
		{"execdomains",	execdomains_read_proc},
		{NULL,}
	};
	for (p = simple_ones; p->name; p++)
		create_proc_read_entry(p->name, 0, NULL, p->read_proc, NULL);

Linus Torvalds's avatar
Linus Torvalds committed
574 575
	proc_symlink("mounts", NULL, "self/mounts");

Linus Torvalds's avatar
Linus Torvalds committed
576 577 578 579
	/* And now for trickier ones */
	entry = create_proc_entry("kmsg", S_IRUSR, &proc_root);
	if (entry)
		entry->proc_fops = &proc_kmsg_operations;
Linus Torvalds's avatar
Linus Torvalds committed
580
	create_seq_entry("cpuinfo", 0, &proc_cpuinfo_operations);
581
	create_seq_entry("partitions", 0, &proc_partitions_operations);
582
	create_seq_entry("stat", 0, &proc_stat_operations);
Linus Torvalds's avatar
Linus Torvalds committed
583
	create_seq_entry("interrupts", 0, &proc_interrupts_operations);
584
	create_seq_entry("slabinfo",S_IWUSR|S_IRUGO,&proc_slabinfo_operations);
Andrew Morton's avatar
Andrew Morton committed
585
	create_seq_entry("buddyinfo",S_IRUGO, &fragmentation_file_operations);
586
	create_seq_entry("vmstat",S_IRUGO, &proc_vmstat_file_operations);
587
	create_seq_entry("diskstats", 0, &proc_diskstats_operations);
Linus Torvalds's avatar
Linus Torvalds committed
588
#ifdef CONFIG_MODULES
589
	create_seq_entry("modules", 0, &proc_modules_operations);
Linus Torvalds's avatar
Linus Torvalds committed
590
#endif
Rick Lindsley's avatar
Rick Lindsley committed
591 592 593
#ifdef CONFIG_SCHEDSTATS
	create_seq_entry("schedstat", 0, &proc_schedstat_operations);
#endif
594
#ifdef CONFIG_PROC_KCORE
Linus Torvalds's avatar
Linus Torvalds committed
595 596 597 598 599 600
	proc_root_kcore = create_proc_entry("kcore", S_IRUSR, NULL);
	if (proc_root_kcore) {
		proc_root_kcore->proc_fops = &proc_kcore_operations;
		proc_root_kcore->size =
				(size_t)high_memory - PAGE_OFFSET + PAGE_SIZE;
	}
601
#endif
602 603 604 605 606
#ifdef CONFIG_MAGIC_SYSRQ
	entry = create_proc_entry("sysrq-trigger", S_IWUSR, NULL);
	if (entry)
		entry->proc_fops = &proc_sysrq_trigger_operations;
#endif
Linus Torvalds's avatar
Linus Torvalds committed
607
#ifdef CONFIG_PPC32
Linus Torvalds's avatar
Linus Torvalds committed
608 609 610 611 612 613 614 615
	{
		extern struct file_operations ppc_htab_operations;
		entry = create_proc_entry("ppc_htab", S_IRUGO|S_IWUSR, NULL);
		if (entry)
			entry->proc_fops = &ppc_htab_operations;
	}
#endif
}