Alexey Dobriyan | 6d80e53 | 2008-10-06 14:26:12 +0400 | [diff] [blame] | 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 | |
| 110 | uflags = kpf_copy_bit(KPF_LOCKED, PG_locked, kflags) | |
| 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); |