mm/mincore.c

   1 /*
   2  *      linux/mm/mincore.c
   3  *
   4  * Copyright (C) 1994-2006  Linus Torvalds
   5  */
   6
   7 /*
   8  * The mincore() system call.
   9  */
  10 #include <linux/pagemap.h>
  11 #include <linux/gfp.h>
  12 #include <linux/mm.h>
  13 #include <linux/mman.h>
  14 #include <linux/syscalls.h>
  15 #include <linux/swap.h>
  16 #include <linux/swapops.h>
  17 #include <linux/hugetlb.h>
  18
  19 #include <asm/uaccess.h>
  20 #include <asm/pgtable.h>
  21
  22 static void mincore_hugetlb_page_range(struct vm_area_struct *vma,
  23                                 unsigned long addr, unsigned long nr,
  24                                 unsigned char *vec)
  25 {
  26 #ifdef CONFIG_HUGETLB_PAGE
  27         struct hstate *h;
  28         int i;
  29
  30         i = 0;
  31         h = hstate_vma(vma);
  32         while (1) {
  33                 unsigned char present;
  34                 pte_t *ptep;
  35                 /*
  36                  * Huge pages are always in RAM for now, but
  37                  * theoretically it needs to be checked.
  38                  */
  39                 ptep = huge_pte_offset(current->mm,
  40                                        addr & huge_page_mask(h));
  41                 present = ptep && !huge_pte_none(huge_ptep_get(ptep));
  42                 while (1) {
  43                         vec[i++] = present;
  44                         addr += PAGE_SIZE;
  45                         /* reach buffer limit */
  46                         if (i == nr)
  47                                 return;
  48                         /* check hugepage border */
  49                         if (!(addr & ~huge_page_mask(h)))
  50                                 break;
  51                 }
  52         }
  53 #else
  54         BUG();
  55 #endif
  56 }
  57
  58 /*
  59  * Later we can get more picky about what "in core" means precisely.
  60  * For now, simply check to see if the page is in the page cache,
  61  * and is up to date; i.e. that no page-in operation would be required
  62  * at this time if an application were to map and access this page.
  63  */
  64 static unsigned char mincore_page(struct address_space *mapping, pgoff_t pgoff)
  65 {
  66         unsigned char present = 0;
  67         struct page *page;
  68
  69         /*
  70          * When tmpfs swaps out a page from a file, any process mapping that
  71          * file will not get a swp_entry_t in its pte, but rather it is like
  72          * any other file mapping (ie. marked !present and faulted in with
  73          * tmpfs's .fault). So swapped out tmpfs mappings are tested here.
  74          *
  75          * However when tmpfs moves the page from pagecache and into swapcache,
  76          * it is still in core, but the find_get_page below won't find it.
  77          * No big deal, but make a note of it.
  78          */
  79         page = find_get_page(mapping, pgoff);
  80         if (page) {
  81                 present = PageUptodate(page);
  82                 page_cache_release(page);
  83         }
  84
  85         return present;
  86 }
  87
  88 static void mincore_unmapped_range(struct vm_area_struct *vma,
  89                                 unsigned long addr, unsigned long nr,
  90                                 unsigned char *vec)
  91 {
  92         int i;
  93
  94         if (vma->vm_file) {
  95                 pgoff_t pgoff;
  96
  97                 pgoff = linear_page_index(vma, addr);
  98                 for (i = 0; i < nr; i++, pgoff++)
  99                         vec[i] = mincore_page(vma->vm_file->f_mapping, pgoff);
 100         } else {
 101                 for (i = 0; i < nr; i++)
 102                         vec[i] = 0;
 103         }
 104 }
 105
 106 static void mincore_pte_range(struct vm_area_struct *vma, pmd_t *pmd,
 107                         unsigned long addr, unsigned long nr,
 108                         unsigned char *vec)
 109 {
 110         spinlock_t *ptl;
 111         pte_t *ptep;
 112         int i;
 113
 114         ptep = pte_offset_map_lock(vma->vm_mm, pmd, addr, &ptl);
 115         for (i = 0; i < nr; i++, ptep++, addr += PAGE_SIZE) {
 116                 pte_t pte = *ptep;
 117                 pgoff_t pgoff;
 118
 119                 if (pte_none(pte))
 120                         mincore_unmapped_range(vma, addr, 1, vec);
 121                 else if (pte_present(pte))
 122                         vec[i] = 1;
 123                 else if (pte_file(pte)) {
 124                         pgoff = pte_to_pgoff(pte);
 125                         vec[i] = mincore_page(vma->vm_file->f_mapping, pgoff);
 126                 } else { /* pte is a swap entry */
 127                         swp_entry_t entry = pte_to_swp_entry(pte);
 128
 129                         if (is_migration_entry(entry)) {
 130                                 /* migration entries are always uptodate */
 131                                 vec[i] = 1;
 132                         } else {
 133 #ifdef CONFIG_SWAP
 134                                 pgoff = entry.val;
 135                                 vec[i] = mincore_page(&swapper_space, pgoff);
 136 #else
 137                                 WARN_ON(1);
 138                                 vec[i] = 1;
 139 #endif
 140                         }
 141                 }
 142         }
 143         pte_unmap_unlock(ptep - 1, ptl);
 144 }
 145
 146 /*
 147  * Do a chunk of "sys_mincore()". We've already checked
 148  * all the arguments, we hold the mmap semaphore: we should
 149  * just return the amount of info we're asked for.
 150  */
 151 static long do_mincore(unsigned long addr, unsigned long pages, unsigned char *vec)
 152 {
 153         pgd_t *pgd;
 154         pud_t *pud;
 155         pmd_t *pmd;
 156         unsigned long nr;
 157         struct vm_area_struct *vma;
 158
 159         vma = find_vma(current->mm, addr);
 160         if (!vma || addr < vma->vm_start)
 161                 return -ENOMEM;
 162
 163         nr = min(pages, (vma->vm_end - addr) >> PAGE_SHIFT);
 164
 165         if (is_vm_hugetlb_page(vma)) {
 166                 mincore_hugetlb_page_range(vma, addr, nr, vec);
 167                 return nr;
 168         }
 169
 170         /*
 171          * Calculate how many pages there are left in the last level of the
 172          * PTE array for our address.
 173          */
 174         nr = min(nr, PTRS_PER_PTE - ((addr >> PAGE_SHIFT) & (PTRS_PER_PTE-1)));
 175
 176         pgd = pgd_offset(vma->vm_mm, addr);
 177         if (pgd_none_or_clear_bad(pgd))
 178                 goto none_mapped;
 179         pud = pud_offset(pgd, addr);
 180         if (pud_none_or_clear_bad(pud))
 181                 goto none_mapped;
 182         pmd = pmd_offset(pud, addr);
 183         if (pmd_none_or_clear_bad(pmd))
 184                 goto none_mapped;
 185
 186         mincore_pte_range(vma, pmd, addr, nr, vec);
 187         return nr;
 188
 189 none_mapped:
 190         mincore_unmapped_range(vma, addr, nr, vec);
 191         return nr;
 192 }
 193
 194 /*
 195  * The mincore(2) system call.
 196  *
 197  * mincore() returns the memory residency status of the pages in the
 198  * current process's address space specified by [addr, addr + len).
 199  * The status is returned in a vector of bytes.  The least significant
 200  * bit of each byte is 1 if the referenced page is in memory, otherwise
 201  * it is zero.
 202  *
 203  * Because the status of a page can change after mincore() checks it
 204  * but before it returns to the application, the returned vector may
 205  * contain stale information.  Only locked pages are guaranteed to
 206  * remain in memory.
 207  *
 208  * return values:
 209  *  zero    - success
 210  *  -EFAULT - vec points to an illegal address
 211  *  -EINVAL - addr is not a multiple of PAGE_CACHE_SIZE
 212  *  -ENOMEM - Addresses in the range [addr, addr + len] are
 213  *              invalid for the address space of this process, or
 214  *              specify one or more pages which are not currently
 215  *              mapped
 216  *  -EAGAIN - A kernel resource was temporarily unavailable.
 217  */
 218 SYSCALL_DEFINE3(mincore, unsigned long, start, size_t, len,
 219                 unsigned char __user *, vec)
 220 {
 221         long retval;
 222         unsigned long pages;
 223         unsigned char *tmp;
 224
 225         /* Check the start address: needs to be page-aligned.. */
 226         if (start & ~PAGE_CACHE_MASK)
 227                 return -EINVAL;
 228
 229         /* ..and we need to be passed a valid user-space range */
 230         if (!access_ok(VERIFY_READ, (void __user *) start, len))
 231                 return -ENOMEM;
 232
 233         /* This also avoids any overflows on PAGE_CACHE_ALIGN */
 234         pages = len >> PAGE_SHIFT;
 235         pages += (len & ~PAGE_MASK) != 0;
 236
 237         if (!access_ok(VERIFY_WRITE, vec, pages))
 238                 return -EFAULT;
 239
 240         tmp = (void *) __get_free_page(GFP_USER);
 241         if (!tmp)
 242                 return -EAGAIN;
 243
 244         retval = 0;
 245         while (pages) {
 246                 /*
 247                  * Do at most PAGE_SIZE entries per iteration, due to
 248                  * the temporary buffer size.
 249                  */
 250                 down_read(&current->mm->mmap_sem);
 251                 retval = do_mincore(start, min(pages, PAGE_SIZE), tmp);
 252                 up_read(&current->mm->mmap_sem);
 253
 254                 if (retval <= 0)
 255                         break;
 256                 if (copy_to_user(vec, tmp, retval)) {
 257                         retval = -EFAULT;
 258                         break;
 259                 }
 260                 pages -= retval;
 261                 vec += retval;
 262                 start += retval << PAGE_SHIFT;
 263                 retval = 0;
 264         }
 265         free_page((unsigned long) tmp);
 266         return retval;
 267 }