[deliverable/linux.git] / fs / proc / page.c

#include <linux/bootmem.h>
#include <linux/compiler.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/mm.h>
#include <linux/mmzone.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <asm/uaccess.h>
#include "internal.h"

#define KPMSIZE sizeof(u64)
#define KPMMASK (KPMSIZE - 1)
/* /proc/kpagecount - an array exposing page counts
 *
 * Each entry is a u64 representing the corresponding
 * physical page count.
 */
static ssize_t kpagecount_read(struct file *file, char __user *buf,
			     size_t count, loff_t *ppos)
{
	u64 __user *out = (u64 __user *)buf;
	struct page *ppage;
	unsigned long src = *ppos;
	unsigned long pfn;
	ssize_t ret = 0;
	u64 pcount;

	pfn = src / KPMSIZE;
	count = min_t(size_t, count, (max_pfn * KPMSIZE) - src);
	if (src & KPMMASK || count & KPMMASK)
		return -EINVAL;

	while (count > 0) {
		ppage = NULL;
		if (pfn_valid(pfn))
			ppage = pfn_to_page(pfn);
		pfn++;
		if (!ppage)
			pcount = 0;
		else
			pcount = page_mapcount(ppage);

		if (put_user(pcount, out++)) {
			ret = -EFAULT;
			break;
		}

		count -= KPMSIZE;
	}

	*ppos += (char __user *)out - buf;
	if (!ret)
		ret = (char __user *)out - buf;
	return ret;
}

static const struct file_operations proc_kpagecount_operations = {
	.llseek = mem_lseek,
	.read = kpagecount_read,
};

/* /proc/kpageflags - an array exposing page flags
 *
 * Each entry is a u64 representing the corresponding
 * physical page flags.
 */

/* These macros are used to decouple internal flags from exported ones */

#define KPF_LOCKED     0
#define KPF_ERROR      1
#define KPF_REFERENCED 2
#define KPF_UPTODATE   3
#define KPF_DIRTY      4
#define KPF_LRU        5
#define KPF_ACTIVE     6
#define KPF_SLAB       7
#define KPF_WRITEBACK  8
#define KPF_RECLAIM    9
#define KPF_BUDDY     10

#define kpf_copy_bit(flags, srcpos, dstpos) (((flags >> srcpos) & 1) << dstpos)

static ssize_t kpageflags_read(struct file *file, char __user *buf,
			     size_t count, loff_t *ppos)
{
	u64 __user *out = (u64 __user *)buf;
	struct page *ppage;
	unsigned long src = *ppos;
	unsigned long pfn;
	ssize_t ret = 0;
	u64 kflags, uflags;

	pfn = src / KPMSIZE;
	count = min_t(unsigned long, count, (max_pfn * KPMSIZE) - src);
	if (src & KPMMASK || count & KPMMASK)
		return -EINVAL;

	while (count > 0) {
		ppage = NULL;
		if (pfn_valid(pfn))
			ppage = pfn_to_page(pfn);
		pfn++;
		if (!ppage)
			kflags = 0;
		else
			kflags = ppage->flags;

		uflags = kpf_copy_bit(kflags, KPF_LOCKED, PG_locked) |
			kpf_copy_bit(kflags, KPF_ERROR, PG_error) |
			kpf_copy_bit(kflags, KPF_REFERENCED, PG_referenced) |
			kpf_copy_bit(kflags, KPF_UPTODATE, PG_uptodate) |
			kpf_copy_bit(kflags, KPF_DIRTY, PG_dirty) |
			kpf_copy_bit(kflags, KPF_LRU, PG_lru) |
			kpf_copy_bit(kflags, KPF_ACTIVE, PG_active) |
			kpf_copy_bit(kflags, KPF_SLAB, PG_slab) |
			kpf_copy_bit(kflags, KPF_WRITEBACK, PG_writeback) |
			kpf_copy_bit(kflags, KPF_RECLAIM, PG_reclaim) |
			kpf_copy_bit(kflags, KPF_BUDDY, PG_buddy);

		if (put_user(uflags, out++)) {
			ret = -EFAULT;
			break;
		}

		count -= KPMSIZE;
	}

	*ppos += (char __user *)out - buf;
	if (!ret)
		ret = (char __user *)out - buf;
	return ret;
}

static const struct file_operations proc_kpageflags_operations = {
	.llseek = mem_lseek,
	.read = kpageflags_read,
};

static int __init proc_page_init(void)
{
	proc_create("kpagecount", S_IRUSR, NULL, &proc_kpagecount_operations);
	proc_create("kpageflags", S_IRUSR, NULL, &proc_kpageflags_operations);
	return 0;
}
module_init(proc_page_init);
Commit	Line	Data
6d80e53f AD	1	#include <linux/bootmem.h>
	2	#include <linux/compiler.h>
	3	#include <linux/fs.h>
	4	#include <linux/init.h>
	5	#include <linux/mm.h>
	6	#include <linux/mmzone.h>
	7	#include <linux/proc_fs.h>
	8	#include <linux/seq_file.h>
	9	#include <asm/uaccess.h>
	10	#include "internal.h"
	11
	12	#define KPMSIZE sizeof(u64)
	13	#define KPMMASK (KPMSIZE - 1)
	14	/* /proc/kpagecount - an array exposing page counts
	15	*
	16	* Each entry is a u64 representing the corresponding
	17	* physical page count.
	18	*/
	19	static ssize_t kpagecount_read(struct file file, char __user buf,
	20	size_t count, loff_t *ppos)
	21	{
	22	u64 __user out = (u64 __user )buf;
	23	struct page *ppage;
	24	unsigned long src = *ppos;
	25	unsigned long pfn;
	26	ssize_t ret = 0;
	27	u64 pcount;
	28
	29	pfn = src / KPMSIZE;
	30	count = min_t(size_t, count, (max_pfn * KPMSIZE) - src);
	31	if (src & KPMMASK \|\| count & KPMMASK)
	32	return -EINVAL;
	33
	34	while (count > 0) {
	35	ppage = NULL;
	36	if (pfn_valid(pfn))
	37	ppage = pfn_to_page(pfn);
	38	pfn++;
	39	if (!ppage)
	40	pcount = 0;
	41	else
	42	pcount = page_mapcount(ppage);
	43
	44	if (put_user(pcount, out++)) {
	45	ret = -EFAULT;
	46	break;
	47	}
	48
	49	count -= KPMSIZE;
	50	}
	51
	52	ppos += (char __user )out - buf;
	53	if (!ret)
	54	ret = (char __user *)out - buf;
	55	return ret;
	56	}
	57
	58	static const struct file_operations proc_kpagecount_operations = {
	59	.llseek = mem_lseek,
	60	.read = kpagecount_read,
	61	};
	62
	63	/* /proc/kpageflags - an array exposing page flags
	64	*
65	* Each entry is a u64 representing the corresponding
66	* physical page flags.
67	*/
68
69	/* These macros are used to decouple internal flags from exported ones */
70
71	#define KPF_LOCKED 0
72	#define KPF_ERROR 1
73	#define KPF_REFERENCED 2
74	#define KPF_UPTODATE 3
75	#define KPF_DIRTY 4
76	#define KPF_LRU 5
77	#define KPF_ACTIVE 6
78	#define KPF_SLAB 7
79	#define KPF_WRITEBACK 8
80	#define KPF_RECLAIM 9
81	#define KPF_BUDDY 10
82
83	#define kpf_copy_bit(flags, srcpos, dstpos) (((flags >> srcpos) & 1) << dstpos)
84
85	static ssize_t kpageflags_read(struct file file, char __user buf,
86	size_t count, loff_t *ppos)
87	{
88	u64 __user out = (u64 __user )buf;
89	struct page *ppage;
90	unsigned long src = *ppos;
91	unsigned long pfn;
92	ssize_t ret = 0;
93	u64 kflags, uflags;
94
95	pfn = src / KPMSIZE;
96	count = min_t(unsigned long, count, (max_pfn * KPMSIZE) - src);
97	if (src & KPMMASK \|\| count & KPMMASK)
98	return -EINVAL;
99
100	while (count > 0) {
101	ppage = NULL;
102	if (pfn_valid(pfn))
103	ppage = pfn_to_page(pfn);
104	pfn++;
105	if (!ppage)
106	kflags = 0;
107	else
108	kflags = ppage->flags;
109
e07a4b92	110	uflags = kpf_copy_bit(kflags, KPF_LOCKED, PG_locked) \|
6d80e53f AD	111	kpf_copy_bit(kflags, KPF_ERROR, PG_error) \|
	112	kpf_copy_bit(kflags, KPF_REFERENCED, PG_referenced) \|
	113	kpf_copy_bit(kflags, KPF_UPTODATE, PG_uptodate) \|
	114	kpf_copy_bit(kflags, KPF_DIRTY, PG_dirty) \|
	115	kpf_copy_bit(kflags, KPF_LRU, PG_lru) \|
	116	kpf_copy_bit(kflags, KPF_ACTIVE, PG_active) \|
	117	kpf_copy_bit(kflags, KPF_SLAB, PG_slab) \|
	118	kpf_copy_bit(kflags, KPF_WRITEBACK, PG_writeback) \|
	119	kpf_copy_bit(kflags, KPF_RECLAIM, PG_reclaim) \|
	120	kpf_copy_bit(kflags, KPF_BUDDY, PG_buddy);
	121
	122	if (put_user(uflags, out++)) {
	123	ret = -EFAULT;
	124	break;
	125	}
	126
	127	count -= KPMSIZE;
	128	}
	129
	130	ppos += (char __user )out - buf;
	131	if (!ret)
	132	ret = (char __user *)out - buf;
	133	return ret;
	134	}
	135
	136	static const struct file_operations proc_kpageflags_operations = {
	137	.llseek = mem_lseek,
	138	.read = kpageflags_read,
	139	};
	140
	141	static int __init proc_page_init(void)
	142	{
	143	proc_create("kpagecount", S_IRUSR, NULL, &proc_kpagecount_operations);
	144	proc_create("kpageflags", S_IRUSR, NULL, &proc_kpageflags_operations);
	145	return 0;
	146	}
	147	module_init(proc_page_init);