hsr: avoid to create proc file after unregister
[platform/kernel/linux-starfive.git] / mm / mincore.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  *      linux/mm/mincore.c
4  *
5  * Copyright (C) 1994-2006  Linus Torvalds
6  */
7
8 /*
9  * The mincore() system call.
10  */
11 #include <linux/pagemap.h>
12 #include <linux/gfp.h>
13 #include <linux/pagewalk.h>
14 #include <linux/mman.h>
15 #include <linux/syscalls.h>
16 #include <linux/swap.h>
17 #include <linux/swapops.h>
18 #include <linux/shmem_fs.h>
19 #include <linux/hugetlb.h>
20 #include <linux/pgtable.h>
21
22 #include <linux/uaccess.h>
23
24 static int mincore_hugetlb(pte_t *pte, unsigned long hmask, unsigned long addr,
25                         unsigned long end, struct mm_walk *walk)
26 {
27 #ifdef CONFIG_HUGETLB_PAGE
28         unsigned char present;
29         unsigned char *vec = walk->private;
30
31         /*
32          * Hugepages under user process are always in RAM and never
33          * swapped out, but theoretically it needs to be checked.
34          */
35         present = pte && !huge_pte_none(huge_ptep_get(pte));
36         for (; addr != end; vec++, addr += PAGE_SIZE)
37                 *vec = present;
38         walk->private = vec;
39 #else
40         BUG();
41 #endif
42         return 0;
43 }
44
45 /*
46  * Later we can get more picky about what "in core" means precisely.
47  * For now, simply check to see if the page is in the page cache,
48  * and is up to date; i.e. that no page-in operation would be required
49  * at this time if an application were to map and access this page.
50  */
51 static unsigned char mincore_page(struct address_space *mapping, pgoff_t pgoff)
52 {
53         unsigned char present = 0;
54         struct page *page;
55
56         /*
57          * When tmpfs swaps out a page from a file, any process mapping that
58          * file will not get a swp_entry_t in its pte, but rather it is like
59          * any other file mapping (ie. marked !present and faulted in with
60          * tmpfs's .fault). So swapped out tmpfs mappings are tested here.
61          */
62 #ifdef CONFIG_SWAP
63         if (shmem_mapping(mapping)) {
64                 page = find_get_entry(mapping, pgoff);
65                 /*
66                  * shmem/tmpfs may return swap: account for swapcache
67                  * page too.
68                  */
69                 if (xa_is_value(page)) {
70                         swp_entry_t swp = radix_to_swp_entry(page);
71                         struct swap_info_struct *si;
72
73                         /* Prevent swap device to being swapoff under us */
74                         si = get_swap_device(swp);
75                         if (si) {
76                                 page = find_get_page(swap_address_space(swp),
77                                                      swp_offset(swp));
78                                 put_swap_device(si);
79                         } else
80                                 page = NULL;
81                 }
82         } else
83                 page = find_get_page(mapping, pgoff);
84 #else
85         page = find_get_page(mapping, pgoff);
86 #endif
87         if (page) {
88                 present = PageUptodate(page);
89                 put_page(page);
90         }
91
92         return present;
93 }
94
95 static int __mincore_unmapped_range(unsigned long addr, unsigned long end,
96                                 struct vm_area_struct *vma, unsigned char *vec)
97 {
98         unsigned long nr = (end - addr) >> PAGE_SHIFT;
99         int i;
100
101         if (vma->vm_file) {
102                 pgoff_t pgoff;
103
104                 pgoff = linear_page_index(vma, addr);
105                 for (i = 0; i < nr; i++, pgoff++)
106                         vec[i] = mincore_page(vma->vm_file->f_mapping, pgoff);
107         } else {
108                 for (i = 0; i < nr; i++)
109                         vec[i] = 0;
110         }
111         return nr;
112 }
113
114 static int mincore_unmapped_range(unsigned long addr, unsigned long end,
115                                    __always_unused int depth,
116                                    struct mm_walk *walk)
117 {
118         walk->private += __mincore_unmapped_range(addr, end,
119                                                   walk->vma, walk->private);
120         return 0;
121 }
122
123 static int mincore_pte_range(pmd_t *pmd, unsigned long addr, unsigned long end,
124                         struct mm_walk *walk)
125 {
126         spinlock_t *ptl;
127         struct vm_area_struct *vma = walk->vma;
128         pte_t *ptep;
129         unsigned char *vec = walk->private;
130         int nr = (end - addr) >> PAGE_SHIFT;
131
132         ptl = pmd_trans_huge_lock(pmd, vma);
133         if (ptl) {
134                 memset(vec, 1, nr);
135                 spin_unlock(ptl);
136                 goto out;
137         }
138
139         if (pmd_trans_unstable(pmd)) {
140                 __mincore_unmapped_range(addr, end, vma, vec);
141                 goto out;
142         }
143
144         ptep = pte_offset_map_lock(walk->mm, pmd, addr, &ptl);
145         for (; addr != end; ptep++, addr += PAGE_SIZE) {
146                 pte_t pte = *ptep;
147
148                 if (pte_none(pte))
149                         __mincore_unmapped_range(addr, addr + PAGE_SIZE,
150                                                  vma, vec);
151                 else if (pte_present(pte))
152                         *vec = 1;
153                 else { /* pte is a swap entry */
154                         swp_entry_t entry = pte_to_swp_entry(pte);
155
156                         if (non_swap_entry(entry)) {
157                                 /*
158                                  * migration or hwpoison entries are always
159                                  * uptodate
160                                  */
161                                 *vec = 1;
162                         } else {
163 #ifdef CONFIG_SWAP
164                                 *vec = mincore_page(swap_address_space(entry),
165                                                     swp_offset(entry));
166 #else
167                                 WARN_ON(1);
168                                 *vec = 1;
169 #endif
170                         }
171                 }
172                 vec++;
173         }
174         pte_unmap_unlock(ptep - 1, ptl);
175 out:
176         walk->private += nr;
177         cond_resched();
178         return 0;
179 }
180
181 static inline bool can_do_mincore(struct vm_area_struct *vma)
182 {
183         if (vma_is_anonymous(vma))
184                 return true;
185         if (!vma->vm_file)
186                 return false;
187         /*
188          * Reveal pagecache information only for non-anonymous mappings that
189          * correspond to the files the calling process could (if tried) open
190          * for writing; otherwise we'd be including shared non-exclusive
191          * mappings, which opens a side channel.
192          */
193         return inode_owner_or_capable(file_inode(vma->vm_file)) ||
194                 inode_permission(file_inode(vma->vm_file), MAY_WRITE) == 0;
195 }
196
197 static const struct mm_walk_ops mincore_walk_ops = {
198         .pmd_entry              = mincore_pte_range,
199         .pte_hole               = mincore_unmapped_range,
200         .hugetlb_entry          = mincore_hugetlb,
201 };
202
203 /*
204  * Do a chunk of "sys_mincore()". We've already checked
205  * all the arguments, we hold the mmap semaphore: we should
206  * just return the amount of info we're asked for.
207  */
208 static long do_mincore(unsigned long addr, unsigned long pages, unsigned char *vec)
209 {
210         struct vm_area_struct *vma;
211         unsigned long end;
212         int err;
213
214         vma = find_vma(current->mm, addr);
215         if (!vma || addr < vma->vm_start)
216                 return -ENOMEM;
217         end = min(vma->vm_end, addr + (pages << PAGE_SHIFT));
218         if (!can_do_mincore(vma)) {
219                 unsigned long pages = DIV_ROUND_UP(end - addr, PAGE_SIZE);
220                 memset(vec, 1, pages);
221                 return pages;
222         }
223         err = walk_page_range(vma->vm_mm, addr, end, &mincore_walk_ops, vec);
224         if (err < 0)
225                 return err;
226         return (end - addr) >> PAGE_SHIFT;
227 }
228
229 /*
230  * The mincore(2) system call.
231  *
232  * mincore() returns the memory residency status of the pages in the
233  * current process's address space specified by [addr, addr + len).
234  * The status is returned in a vector of bytes.  The least significant
235  * bit of each byte is 1 if the referenced page is in memory, otherwise
236  * it is zero.
237  *
238  * Because the status of a page can change after mincore() checks it
239  * but before it returns to the application, the returned vector may
240  * contain stale information.  Only locked pages are guaranteed to
241  * remain in memory.
242  *
243  * return values:
244  *  zero    - success
245  *  -EFAULT - vec points to an illegal address
246  *  -EINVAL - addr is not a multiple of PAGE_SIZE
247  *  -ENOMEM - Addresses in the range [addr, addr + len] are
248  *              invalid for the address space of this process, or
249  *              specify one or more pages which are not currently
250  *              mapped
251  *  -EAGAIN - A kernel resource was temporarily unavailable.
252  */
253 SYSCALL_DEFINE3(mincore, unsigned long, start, size_t, len,
254                 unsigned char __user *, vec)
255 {
256         long retval;
257         unsigned long pages;
258         unsigned char *tmp;
259
260         start = untagged_addr(start);
261
262         /* Check the start address: needs to be page-aligned.. */
263         if (start & ~PAGE_MASK)
264                 return -EINVAL;
265
266         /* ..and we need to be passed a valid user-space range */
267         if (!access_ok((void __user *) start, len))
268                 return -ENOMEM;
269
270         /* This also avoids any overflows on PAGE_ALIGN */
271         pages = len >> PAGE_SHIFT;
272         pages += (offset_in_page(len)) != 0;
273
274         if (!access_ok(vec, pages))
275                 return -EFAULT;
276
277         tmp = (void *) __get_free_page(GFP_USER);
278         if (!tmp)
279                 return -EAGAIN;
280
281         retval = 0;
282         while (pages) {
283                 /*
284                  * Do at most PAGE_SIZE entries per iteration, due to
285                  * the temporary buffer size.
286                  */
287                 mmap_read_lock(current->mm);
288                 retval = do_mincore(start, min(pages, PAGE_SIZE), tmp);
289                 mmap_read_unlock(current->mm);
290
291                 if (retval <= 0)
292                         break;
293                 if (copy_to_user(vec, tmp, retval)) {
294                         retval = -EFAULT;
295                         break;
296                 }
297                 pages -= retval;
298                 vec += retval;
299                 start += retval << PAGE_SHIFT;
300                 retval = 0;
301         }
302         free_page((unsigned long) tmp);
303         return retval;
304 }