Pileus Git - ~andy/linux/blob - fs/proc/page.c

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