Branch data Line data Source code
1 : : /*
2 : : * hugetlbpage-backed filesystem. Based on ramfs.
3 : : *
4 : : * Nadia Yvette Chambers, 2002
5 : : *
6 : : * Copyright (C) 2002 Linus Torvalds.
7 : : * License: GPL
8 : : */
9 : :
10 : : #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
11 : :
12 : : #include <linux/thread_info.h>
13 : : #include <asm/current.h>
14 : : #include <linux/sched/signal.h> /* remove ASAP */
15 : : #include <linux/falloc.h>
16 : : #include <linux/fs.h>
17 : : #include <linux/mount.h>
18 : : #include <linux/file.h>
19 : : #include <linux/kernel.h>
20 : : #include <linux/writeback.h>
21 : : #include <linux/pagemap.h>
22 : : #include <linux/highmem.h>
23 : : #include <linux/init.h>
24 : : #include <linux/string.h>
25 : : #include <linux/capability.h>
26 : : #include <linux/ctype.h>
27 : : #include <linux/backing-dev.h>
28 : : #include <linux/hugetlb.h>
29 : : #include <linux/pagevec.h>
30 : : #include <linux/fs_parser.h>
31 : : #include <linux/mman.h>
32 : : #include <linux/slab.h>
33 : : #include <linux/dnotify.h>
34 : : #include <linux/statfs.h>
35 : : #include <linux/security.h>
36 : : #include <linux/magic.h>
37 : : #include <linux/migrate.h>
38 : : #include <linux/uio.h>
39 : :
40 : : #include <linux/uaccess.h>
41 : :
42 : : static const struct super_operations hugetlbfs_ops;
43 : : static const struct address_space_operations hugetlbfs_aops;
44 : : const struct file_operations hugetlbfs_file_operations;
45 : : static const struct inode_operations hugetlbfs_dir_inode_operations;
46 : : static const struct inode_operations hugetlbfs_inode_operations;
47 : :
48 : : enum hugetlbfs_size_type { NO_SIZE, SIZE_STD, SIZE_PERCENT };
49 : :
50 : : struct hugetlbfs_fs_context {
51 : : struct hstate *hstate;
52 : : unsigned long long max_size_opt;
53 : : unsigned long long min_size_opt;
54 : : long max_hpages;
55 : : long nr_inodes;
56 : : long min_hpages;
57 : : enum hugetlbfs_size_type max_val_type;
58 : : enum hugetlbfs_size_type min_val_type;
59 : : kuid_t uid;
60 : : kgid_t gid;
61 : : umode_t mode;
62 : : };
63 : :
64 : : int sysctl_hugetlb_shm_group;
65 : :
66 : : enum hugetlb_param {
67 : : Opt_gid,
68 : : Opt_min_size,
69 : : Opt_mode,
70 : : Opt_nr_inodes,
71 : : Opt_pagesize,
72 : : Opt_size,
73 : : Opt_uid,
74 : : };
75 : :
76 : : static const struct fs_parameter_spec hugetlb_fs_parameters[] = {
77 : : fsparam_u32 ("gid", Opt_gid),
78 : : fsparam_string("min_size", Opt_min_size),
79 : : fsparam_u32 ("mode", Opt_mode),
80 : : fsparam_string("nr_inodes", Opt_nr_inodes),
81 : : fsparam_string("pagesize", Opt_pagesize),
82 : : fsparam_string("size", Opt_size),
83 : : fsparam_u32 ("uid", Opt_uid),
84 : : {}
85 : : };
86 : :
87 : : #ifdef CONFIG_NUMA
88 : 0 : static inline void hugetlb_set_vma_policy(struct vm_area_struct *vma,
89 : : struct inode *inode, pgoff_t index)
90 : : {
91 : 0 : vma->vm_policy = mpol_shared_policy_lookup(&HUGETLBFS_I(inode)->policy,
92 : : index);
93 : : }
94 : :
95 : 0 : static inline void hugetlb_drop_vma_policy(struct vm_area_struct *vma)
96 : : {
97 : 0 : mpol_cond_put(vma->vm_policy);
98 : : }
99 : : #else
100 : : static inline void hugetlb_set_vma_policy(struct vm_area_struct *vma,
101 : : struct inode *inode, pgoff_t index)
102 : : {
103 : : }
104 : :
105 : : static inline void hugetlb_drop_vma_policy(struct vm_area_struct *vma)
106 : : {
107 : : }
108 : : #endif
109 : :
110 : : static void huge_pagevec_release(struct pagevec *pvec)
111 : : {
112 : : int i;
113 : :
114 [ # # ]: 0 : for (i = 0; i < pagevec_count(pvec); ++i)
115 : 0 : put_page(pvec->pages[i]);
116 : :
117 : 0 : pagevec_reinit(pvec);
118 : : }
119 : :
120 : : /*
121 : : * Mask used when checking the page offset value passed in via system
122 : : * calls. This value will be converted to a loff_t which is signed.
123 : : * Therefore, we want to check the upper PAGE_SHIFT + 1 bits of the
124 : : * value. The extra bit (- 1 in the shift value) is to take the sign
125 : : * bit into account.
126 : : */
127 : : #define PGOFF_LOFFT_MAX \
128 : : (((1UL << (PAGE_SHIFT + 1)) - 1) << (BITS_PER_LONG - (PAGE_SHIFT + 1)))
129 : :
130 : 0 : static int hugetlbfs_file_mmap(struct file *file, struct vm_area_struct *vma)
131 : : {
132 [ # # ]: 0 : struct inode *inode = file_inode(file);
133 : 0 : loff_t len, vma_len;
134 : 0 : int ret;
135 [ # # ]: 0 : struct hstate *h = hstate_file(file);
136 : :
137 : : /*
138 : : * vma address alignment (but not the pgoff alignment) has
139 : : * already been checked by prepare_hugepage_range. If you add
140 : : * any error returns here, do so after setting VM_HUGETLB, so
141 : : * is_vm_hugetlb_page tests below unmap_region go the right
142 : : * way when do_mmap_pgoff unwinds (may be important on powerpc
143 : : * and ia64).
144 : : */
145 : 0 : vma->vm_flags |= VM_HUGETLB | VM_DONTEXPAND;
146 : 0 : vma->vm_ops = &hugetlb_vm_ops;
147 : :
148 : : /*
149 : : * page based offset in vm_pgoff could be sufficiently large to
150 : : * overflow a loff_t when converted to byte offset. This can
151 : : * only happen on architectures where sizeof(loff_t) ==
152 : : * sizeof(unsigned long). So, only check in those instances.
153 : : */
154 : 0 : if (sizeof(unsigned long) == sizeof(loff_t)) {
155 [ # # ]: 0 : if (vma->vm_pgoff & PGOFF_LOFFT_MAX)
156 : : return -EINVAL;
157 : : }
158 : :
159 : : /* must be huge page aligned */
160 [ # # ]: 0 : if (vma->vm_pgoff & (~huge_page_mask(h) >> PAGE_SHIFT))
161 : : return -EINVAL;
162 : :
163 : 0 : vma_len = (loff_t)(vma->vm_end - vma->vm_start);
164 : 0 : len = vma_len + ((loff_t)vma->vm_pgoff << PAGE_SHIFT);
165 : : /* check for overflow */
166 [ # # ]: 0 : if (len < vma_len)
167 : : return -EINVAL;
168 : :
169 : 0 : inode_lock(inode);
170 [ # # ]: 0 : file_accessed(file);
171 : :
172 : 0 : ret = -ENOMEM;
173 [ # # ]: 0 : if (hugetlb_reserve_pages(inode,
174 : 0 : vma->vm_pgoff >> huge_page_order(h),
175 : 0 : len >> huge_page_shift(h), vma,
176 : : vma->vm_flags))
177 : 0 : goto out;
178 : :
179 : 0 : ret = 0;
180 [ # # # # ]: 0 : if (vma->vm_flags & VM_WRITE && inode->i_size < len)
181 : 0 : i_size_write(inode, len);
182 : 0 : out:
183 : 0 : inode_unlock(inode);
184 : :
185 : 0 : return ret;
186 : : }
187 : :
188 : : /*
189 : : * Called under down_write(mmap_sem).
190 : : */
191 : :
192 : : #ifndef HAVE_ARCH_HUGETLB_UNMAPPED_AREA
193 : : static unsigned long
194 : : hugetlb_get_unmapped_area(struct file *file, unsigned long addr,
195 : : unsigned long len, unsigned long pgoff, unsigned long flags)
196 : : {
197 : : struct mm_struct *mm = current->mm;
198 : : struct vm_area_struct *vma;
199 : : struct hstate *h = hstate_file(file);
200 : : struct vm_unmapped_area_info info;
201 : :
202 : : if (len & ~huge_page_mask(h))
203 : : return -EINVAL;
204 : : if (len > TASK_SIZE)
205 : : return -ENOMEM;
206 : :
207 : : if (flags & MAP_FIXED) {
208 : : if (prepare_hugepage_range(file, addr, len))
209 : : return -EINVAL;
210 : : return addr;
211 : : }
212 : :
213 : : if (addr) {
214 : : addr = ALIGN(addr, huge_page_size(h));
215 : : vma = find_vma(mm, addr);
216 : : if (TASK_SIZE - len >= addr &&
217 : : (!vma || addr + len <= vm_start_gap(vma)))
218 : : return addr;
219 : : }
220 : :
221 : : info.flags = 0;
222 : : info.length = len;
223 : : info.low_limit = TASK_UNMAPPED_BASE;
224 : : info.high_limit = TASK_SIZE;
225 : : info.align_mask = PAGE_MASK & ~huge_page_mask(h);
226 : : info.align_offset = 0;
227 : : return vm_unmapped_area(&info);
228 : : }
229 : : #endif
230 : :
231 : : static size_t
232 : 0 : hugetlbfs_read_actor(struct page *page, unsigned long offset,
233 : : struct iov_iter *to, unsigned long size)
234 : : {
235 : 0 : size_t copied = 0;
236 : 0 : int i, chunksize;
237 : :
238 : : /* Find which 4k chunk and offset with in that chunk */
239 : 0 : i = offset >> PAGE_SHIFT;
240 : 0 : offset = offset & ~PAGE_MASK;
241 : :
242 [ # # ]: 0 : while (size) {
243 : 0 : size_t n;
244 : 0 : chunksize = PAGE_SIZE;
245 [ # # ]: 0 : if (offset)
246 : 0 : chunksize -= offset;
247 [ # # ]: 0 : if (chunksize > size)
248 : 0 : chunksize = size;
249 : 0 : n = copy_page_to_iter(&page[i], offset, chunksize, to);
250 : 0 : copied += n;
251 [ # # ]: 0 : if (n != chunksize)
252 : 0 : return copied;
253 : 0 : offset = 0;
254 : 0 : size -= chunksize;
255 : 0 : i++;
256 : : }
257 : : return copied;
258 : : }
259 : :
260 : : /*
261 : : * Support for read() - Find the page attached to f_mapping and copy out the
262 : : * data. Its *very* similar to do_generic_mapping_read(), we can't use that
263 : : * since it has PAGE_SIZE assumptions.
264 : : */
265 : 0 : static ssize_t hugetlbfs_read_iter(struct kiocb *iocb, struct iov_iter *to)
266 : : {
267 : 0 : struct file *file = iocb->ki_filp;
268 : 0 : struct hstate *h = hstate_file(file);
269 : 0 : struct address_space *mapping = file->f_mapping;
270 : 0 : struct inode *inode = mapping->host;
271 : 0 : unsigned long index = iocb->ki_pos >> huge_page_shift(h);
272 : 0 : unsigned long offset = iocb->ki_pos & ~huge_page_mask(h);
273 : 0 : unsigned long end_index;
274 : 0 : loff_t isize;
275 : 0 : ssize_t retval = 0;
276 : :
277 [ # # ]: 0 : while (iov_iter_count(to)) {
278 : 0 : struct page *page;
279 : 0 : size_t nr, copied;
280 : :
281 : : /* nr is the maximum number of bytes to copy from this page */
282 [ # # ]: 0 : nr = huge_page_size(h);
283 [ # # ]: 0 : isize = i_size_read(inode);
284 [ # # ]: 0 : if (!isize)
285 : : break;
286 [ # # ]: 0 : end_index = (isize - 1) >> huge_page_shift(h);
287 [ # # ]: 0 : if (index > end_index)
288 : : break;
289 [ # # ]: 0 : if (index == end_index) {
290 [ # # ]: 0 : nr = ((isize - 1) & ~huge_page_mask(h)) + 1;
291 [ # # ]: 0 : if (nr <= offset)
292 : : break;
293 : : }
294 : 0 : nr = nr - offset;
295 : :
296 : : /* Find the page */
297 : 0 : page = find_lock_page(mapping, index);
298 [ # # ]: 0 : if (unlikely(page == NULL)) {
299 : : /*
300 : : * We have a HOLE, zero out the user-buffer for the
301 : : * length of the hole or request.
302 : : */
303 : 0 : copied = iov_iter_zero(nr, to);
304 : : } else {
305 : 0 : unlock_page(page);
306 : :
307 : : /*
308 : : * We have the page, copy it to user space buffer.
309 : : */
310 : 0 : copied = hugetlbfs_read_actor(page, offset, to, nr);
311 : 0 : put_page(page);
312 : : }
313 : 0 : offset += copied;
314 : 0 : retval += copied;
315 [ # # # # ]: 0 : if (copied != nr && iov_iter_count(to)) {
316 [ # # ]: 0 : if (!retval)
317 : 0 : retval = -EFAULT;
318 : : break;
319 : : }
320 : 0 : index += offset >> huge_page_shift(h);
321 : 0 : offset &= ~huge_page_mask(h);
322 : : }
323 : 0 : iocb->ki_pos = ((loff_t)index << huge_page_shift(h)) + offset;
324 : 0 : return retval;
325 : : }
326 : :
327 : 0 : static int hugetlbfs_write_begin(struct file *file,
328 : : struct address_space *mapping,
329 : : loff_t pos, unsigned len, unsigned flags,
330 : : struct page **pagep, void **fsdata)
331 : : {
332 : 0 : return -EINVAL;
333 : : }
334 : :
335 : 0 : static int hugetlbfs_write_end(struct file *file, struct address_space *mapping,
336 : : loff_t pos, unsigned len, unsigned copied,
337 : : struct page *page, void *fsdata)
338 : : {
339 : 0 : BUG();
340 : : return -EINVAL;
341 : : }
342 : :
343 : 0 : static void remove_huge_page(struct page *page)
344 : : {
345 [ # # ]: 0 : ClearPageDirty(page);
346 [ # # ]: 0 : ClearPageUptodate(page);
347 : 0 : delete_from_page_cache(page);
348 : 0 : }
349 : :
350 : : static void
351 : 0 : hugetlb_vmdelete_list(struct rb_root_cached *root, pgoff_t start, pgoff_t end)
352 : : {
353 : 0 : struct vm_area_struct *vma;
354 : :
355 : : /*
356 : : * end == 0 indicates that the entire range after
357 : : * start should be unmapped.
358 : : */
359 [ # # # # ]: 0 : vma_interval_tree_foreach(vma, root, start, end ? end : ULONG_MAX) {
360 : 0 : unsigned long v_offset;
361 : 0 : unsigned long v_end;
362 : :
363 : : /*
364 : : * Can the expression below overflow on 32-bit arches?
365 : : * No, because the interval tree returns us only those vmas
366 : : * which overlap the truncated area starting at pgoff,
367 : : * and no vma on a 32-bit arch can span beyond the 4GB.
368 : : */
369 [ # # ]: 0 : if (vma->vm_pgoff < start)
370 : 0 : v_offset = (start - vma->vm_pgoff) << PAGE_SHIFT;
371 : : else
372 : : v_offset = 0;
373 : :
374 [ # # ]: 0 : if (!end)
375 : 0 : v_end = vma->vm_end;
376 : : else {
377 : 0 : v_end = ((end - vma->vm_pgoff) << PAGE_SHIFT)
378 : 0 : + vma->vm_start;
379 : 0 : if (v_end > vma->vm_end)
380 : : v_end = vma->vm_end;
381 : : }
382 : :
383 : 0 : unmap_hugepage_range(vma, vma->vm_start + v_offset, v_end,
384 : : NULL);
385 : : }
386 : 0 : }
387 : :
388 : : /*
389 : : * remove_inode_hugepages handles two distinct cases: truncation and hole
390 : : * punch. There are subtle differences in operation for each case.
391 : : *
392 : : * truncation is indicated by end of range being LLONG_MAX
393 : : * In this case, we first scan the range and release found pages.
394 : : * After releasing pages, hugetlb_unreserve_pages cleans up region/reserv
395 : : * maps and global counts. Page faults can not race with truncation
396 : : * in this routine. hugetlb_no_page() prevents page faults in the
397 : : * truncated range. It checks i_size before allocation, and again after
398 : : * with the page table lock for the page held. The same lock must be
399 : : * acquired to unmap a page.
400 : : * hole punch is indicated if end is not LLONG_MAX
401 : : * In the hole punch case we scan the range and release found pages.
402 : : * Only when releasing a page is the associated region/reserv map
403 : : * deleted. The region/reserv map for ranges without associated
404 : : * pages are not modified. Page faults can race with hole punch.
405 : : * This is indicated if we find a mapped page.
406 : : * Note: If the passed end of range value is beyond the end of file, but
407 : : * not LLONG_MAX this routine still performs a hole punch operation.
408 : : */
409 : 0 : static void remove_inode_hugepages(struct inode *inode, loff_t lstart,
410 : : loff_t lend)
411 : : {
412 : 0 : struct hstate *h = hstate_inode(inode);
413 : 0 : struct address_space *mapping = &inode->i_data;
414 : 0 : const pgoff_t start = lstart >> huge_page_shift(h);
415 : 0 : const pgoff_t end = lend >> huge_page_shift(h);
416 : 0 : struct vm_area_struct pseudo_vma;
417 : 0 : struct pagevec pvec;
418 : 0 : pgoff_t next, index;
419 : 0 : int i, freed = 0;
420 : 0 : bool truncate_op = (lend == LLONG_MAX);
421 : :
422 : 0 : vma_init(&pseudo_vma, current->mm);
423 : 0 : pseudo_vma.vm_flags = (VM_HUGETLB | VM_MAYSHARE | VM_SHARED);
424 : 0 : pagevec_init(&pvec);
425 : 0 : next = start;
426 [ # # ]: 0 : while (next < end) {
427 : : /*
428 : : * When no more pages are found, we are done.
429 : : */
430 [ # # ]: 0 : if (!pagevec_lookup_range(&pvec, mapping, &next, end - 1))
431 : : break;
432 : :
433 [ # # ]: 0 : for (i = 0; i < pagevec_count(&pvec); ++i) {
434 : 0 : struct page *page = pvec.pages[i];
435 : 0 : u32 hash;
436 : :
437 : 0 : index = page->index;
438 : 0 : hash = hugetlb_fault_mutex_hash(mapping, index);
439 : 0 : mutex_lock(&hugetlb_fault_mutex_table[hash]);
440 : :
441 : : /*
442 : : * If page is mapped, it was faulted in after being
443 : : * unmapped in caller. Unmap (again) now after taking
444 : : * the fault mutex. The mutex will prevent faults
445 : : * until we finish removing the page.
446 : : *
447 : : * This race can only happen in the hole punch case.
448 : : * Getting here in a truncate operation is a bug.
449 : : */
450 [ # # ]: 0 : if (unlikely(page_mapped(page))) {
451 [ # # ]: 0 : BUG_ON(truncate_op);
452 : :
453 : 0 : i_mmap_lock_write(mapping);
454 : 0 : hugetlb_vmdelete_list(&mapping->i_mmap,
455 : : index * pages_per_huge_page(h),
456 : 0 : (index + 1) * pages_per_huge_page(h));
457 : 0 : i_mmap_unlock_write(mapping);
458 : : }
459 : :
460 : 0 : lock_page(page);
461 : : /*
462 : : * We must free the huge page and remove from page
463 : : * cache (remove_huge_page) BEFORE removing the
464 : : * region/reserve map (hugetlb_unreserve_pages). In
465 : : * rare out of memory conditions, removal of the
466 : : * region/reserve map could fail. Correspondingly,
467 : : * the subpool and global reserve usage count can need
468 : : * to be adjusted.
469 : : */
470 : 0 : VM_BUG_ON(PagePrivate(page));
471 : 0 : remove_huge_page(page);
472 : 0 : freed++;
473 [ # # ]: 0 : if (!truncate_op) {
474 [ # # ]: 0 : if (unlikely(hugetlb_unreserve_pages(inode,
475 : : index, index + 1, 1)))
476 : 0 : hugetlb_fix_reserve_counts(inode);
477 : : }
478 : :
479 : 0 : unlock_page(page);
480 : 0 : mutex_unlock(&hugetlb_fault_mutex_table[hash]);
481 : : }
482 : : huge_pagevec_release(&pvec);
483 : 0 : cond_resched();
484 : : }
485 : :
486 [ # # ]: 0 : if (truncate_op)
487 : 0 : (void)hugetlb_unreserve_pages(inode, start, LONG_MAX, freed);
488 : 0 : }
489 : :
490 : 0 : static void hugetlbfs_evict_inode(struct inode *inode)
491 : : {
492 : 0 : struct resv_map *resv_map;
493 : :
494 : 0 : remove_inode_hugepages(inode, 0, LLONG_MAX);
495 : :
496 : : /*
497 : : * Get the resv_map from the address space embedded in the inode.
498 : : * This is the address space which points to any resv_map allocated
499 : : * at inode creation time. If this is a device special inode,
500 : : * i_mapping may not point to the original address space.
501 : : */
502 : 0 : resv_map = (struct resv_map *)(&inode->i_data)->private_data;
503 : : /* Only regular and link inodes have associated reserve maps */
504 [ # # ]: 0 : if (resv_map)
505 : 0 : resv_map_release(&resv_map->refs);
506 : 0 : clear_inode(inode);
507 : 0 : }
508 : :
509 : 0 : static int hugetlb_vmtruncate(struct inode *inode, loff_t offset)
510 : : {
511 : 0 : pgoff_t pgoff;
512 : 0 : struct address_space *mapping = inode->i_mapping;
513 [ # # ]: 0 : struct hstate *h = hstate_inode(inode);
514 : :
515 [ # # ]: 0 : BUG_ON(offset & ~huge_page_mask(h));
516 : 0 : pgoff = offset >> PAGE_SHIFT;
517 : :
518 : 0 : i_size_write(inode, offset);
519 : 0 : i_mmap_lock_write(mapping);
520 [ # # ]: 0 : if (!RB_EMPTY_ROOT(&mapping->i_mmap.rb_root))
521 : 0 : hugetlb_vmdelete_list(&mapping->i_mmap, pgoff, 0);
522 : 0 : i_mmap_unlock_write(mapping);
523 : 0 : remove_inode_hugepages(inode, offset, LLONG_MAX);
524 : 0 : return 0;
525 : : }
526 : :
527 : 0 : static long hugetlbfs_punch_hole(struct inode *inode, loff_t offset, loff_t len)
528 : : {
529 [ # # ]: 0 : struct hstate *h = hstate_inode(inode);
530 [ # # ]: 0 : loff_t hpage_size = huge_page_size(h);
531 : 0 : loff_t hole_start, hole_end;
532 : :
533 : : /*
534 : : * For hole punch round up the beginning offset of the hole and
535 : : * round down the end.
536 : : */
537 : 0 : hole_start = round_up(offset, hpage_size);
538 : 0 : hole_end = round_down(offset + len, hpage_size);
539 : :
540 [ # # ]: 0 : if (hole_end > hole_start) {
541 : 0 : struct address_space *mapping = inode->i_mapping;
542 : 0 : struct hugetlbfs_inode_info *info = HUGETLBFS_I(inode);
543 : :
544 : 0 : inode_lock(inode);
545 : :
546 : : /* protected by i_mutex */
547 [ # # ]: 0 : if (info->seals & (F_SEAL_WRITE | F_SEAL_FUTURE_WRITE)) {
548 : 0 : inode_unlock(inode);
549 : 0 : return -EPERM;
550 : : }
551 : :
552 : 0 : i_mmap_lock_write(mapping);
553 [ # # ]: 0 : if (!RB_EMPTY_ROOT(&mapping->i_mmap.rb_root))
554 : 0 : hugetlb_vmdelete_list(&mapping->i_mmap,
555 : 0 : hole_start >> PAGE_SHIFT,
556 : 0 : hole_end >> PAGE_SHIFT);
557 : 0 : i_mmap_unlock_write(mapping);
558 : 0 : remove_inode_hugepages(inode, hole_start, hole_end);
559 : 0 : inode_unlock(inode);
560 : : }
561 : :
562 : : return 0;
563 : : }
564 : :
565 : 0 : static long hugetlbfs_fallocate(struct file *file, int mode, loff_t offset,
566 : : loff_t len)
567 : : {
568 [ # # ]: 0 : struct inode *inode = file_inode(file);
569 [ # # ]: 0 : struct hugetlbfs_inode_info *info = HUGETLBFS_I(inode);
570 : 0 : struct address_space *mapping = inode->i_mapping;
571 [ # # ]: 0 : struct hstate *h = hstate_inode(inode);
572 : 0 : struct vm_area_struct pseudo_vma;
573 [ # # ]: 0 : struct mm_struct *mm = current->mm;
574 [ # # ]: 0 : loff_t hpage_size = huge_page_size(h);
575 [ # # ]: 0 : unsigned long hpage_shift = huge_page_shift(h);
576 : 0 : pgoff_t start, index, end;
577 : 0 : int error;
578 : 0 : u32 hash;
579 : :
580 [ # # ]: 0 : if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE))
581 : : return -EOPNOTSUPP;
582 : :
583 [ # # ]: 0 : if (mode & FALLOC_FL_PUNCH_HOLE)
584 : 0 : return hugetlbfs_punch_hole(inode, offset, len);
585 : :
586 : : /*
587 : : * Default preallocate case.
588 : : * For this range, start is rounded down and end is rounded up
589 : : * as well as being converted to page offsets.
590 : : */
591 : 0 : start = offset >> hpage_shift;
592 : 0 : end = (offset + len + hpage_size - 1) >> hpage_shift;
593 : :
594 : 0 : inode_lock(inode);
595 : :
596 : : /* We need to check rlimit even when FALLOC_FL_KEEP_SIZE */
597 : 0 : error = inode_newsize_ok(inode, offset + len);
598 [ # # ]: 0 : if (error)
599 : 0 : goto out;
600 : :
601 [ # # # # ]: 0 : if ((info->seals & F_SEAL_GROW) && offset + len > inode->i_size) {
602 : 0 : error = -EPERM;
603 : 0 : goto out;
604 : : }
605 : :
606 : : /*
607 : : * Initialize a pseudo vma as this is required by the huge page
608 : : * allocation routines. If NUMA is configured, use page index
609 : : * as input to create an allocation policy.
610 : : */
611 : 0 : vma_init(&pseudo_vma, mm);
612 : 0 : pseudo_vma.vm_flags = (VM_HUGETLB | VM_MAYSHARE | VM_SHARED);
613 : 0 : pseudo_vma.vm_file = file;
614 : :
615 [ # # ]: 0 : for (index = start; index < end; index++) {
616 : : /*
617 : : * This is supposed to be the vaddr where the page is being
618 : : * faulted in, but we have no vaddr here.
619 : : */
620 : 0 : struct page *page;
621 : 0 : unsigned long addr;
622 : 0 : int avoid_reserve = 0;
623 : :
624 : 0 : cond_resched();
625 : :
626 : : /*
627 : : * fallocate(2) manpage permits EINTR; we may have been
628 : : * interrupted because we are using up too much memory.
629 : : */
630 [ # # ]: 0 : if (signal_pending(current)) {
631 : : error = -EINTR;
632 : : break;
633 : : }
634 : :
635 : : /* Set numa allocation policy based on index */
636 : 0 : hugetlb_set_vma_policy(&pseudo_vma, inode, index);
637 : :
638 : : /* addr is the offset within the file (zero based) */
639 : 0 : addr = index * hpage_size;
640 : :
641 : : /* mutex taken here, fault path and hole punch */
642 : 0 : hash = hugetlb_fault_mutex_hash(mapping, index);
643 : 0 : mutex_lock(&hugetlb_fault_mutex_table[hash]);
644 : :
645 : : /* See if already present in mapping to avoid alloc/free */
646 : 0 : page = find_get_page(mapping, index);
647 [ # # ]: 0 : if (page) {
648 : 0 : put_page(page);
649 : 0 : mutex_unlock(&hugetlb_fault_mutex_table[hash]);
650 [ # # ]: 0 : hugetlb_drop_vma_policy(&pseudo_vma);
651 : 0 : continue;
652 : : }
653 : :
654 : : /* Allocate page and add to page cache */
655 : 0 : page = alloc_huge_page(&pseudo_vma, addr, avoid_reserve);
656 [ # # ]: 0 : hugetlb_drop_vma_policy(&pseudo_vma);
657 [ # # ]: 0 : if (IS_ERR(page)) {
658 : 0 : mutex_unlock(&hugetlb_fault_mutex_table[hash]);
659 : 0 : error = PTR_ERR(page);
660 : 0 : goto out;
661 : : }
662 : 0 : clear_huge_page(page, addr, pages_per_huge_page(h));
663 : 0 : __SetPageUptodate(page);
664 : 0 : error = huge_add_to_page_cache(page, mapping, index);
665 [ # # ]: 0 : if (unlikely(error)) {
666 : 0 : put_page(page);
667 : 0 : mutex_unlock(&hugetlb_fault_mutex_table[hash]);
668 : 0 : goto out;
669 : : }
670 : :
671 : 0 : mutex_unlock(&hugetlb_fault_mutex_table[hash]);
672 : :
673 : : /*
674 : : * unlock_page because locked by add_to_page_cache()
675 : : * page_put due to reference from alloc_huge_page()
676 : : */
677 : 0 : unlock_page(page);
678 : 0 : put_page(page);
679 : : }
680 : :
681 [ # # # # ]: 0 : if (!(mode & FALLOC_FL_KEEP_SIZE) && offset + len > inode->i_size)
682 : 0 : i_size_write(inode, offset + len);
683 : 0 : inode->i_ctime = current_time(inode);
684 : 0 : out:
685 : 0 : inode_unlock(inode);
686 : 0 : return error;
687 : : }
688 : :
689 : 0 : static int hugetlbfs_setattr(struct dentry *dentry, struct iattr *attr)
690 : : {
691 [ # # ]: 0 : struct inode *inode = d_inode(dentry);
692 [ # # ]: 0 : struct hstate *h = hstate_inode(inode);
693 : 0 : int error;
694 : 0 : unsigned int ia_valid = attr->ia_valid;
695 [ # # ]: 0 : struct hugetlbfs_inode_info *info = HUGETLBFS_I(inode);
696 : :
697 [ # # ]: 0 : BUG_ON(!inode);
698 : :
699 : 0 : error = setattr_prepare(dentry, attr);
700 [ # # ]: 0 : if (error)
701 : : return error;
702 : :
703 [ # # ]: 0 : if (ia_valid & ATTR_SIZE) {
704 : 0 : loff_t oldsize = inode->i_size;
705 : 0 : loff_t newsize = attr->ia_size;
706 : :
707 [ # # ]: 0 : if (newsize & ~huge_page_mask(h))
708 : : return -EINVAL;
709 : : /* protected by i_mutex */
710 [ # # # # : 0 : if ((newsize < oldsize && (info->seals & F_SEAL_SHRINK)) ||
# # ]
711 [ # # ]: 0 : (newsize > oldsize && (info->seals & F_SEAL_GROW)))
712 : : return -EPERM;
713 : 0 : error = hugetlb_vmtruncate(inode, newsize);
714 [ # # ]: 0 : if (error)
715 : : return error;
716 : : }
717 : :
718 : 0 : setattr_copy(inode, attr);
719 : 0 : mark_inode_dirty(inode);
720 : 0 : return 0;
721 : : }
722 : :
723 : 26 : static struct inode *hugetlbfs_get_root(struct super_block *sb,
724 : : struct hugetlbfs_fs_context *ctx)
725 : : {
726 : 26 : struct inode *inode;
727 : :
728 : 26 : inode = new_inode(sb);
729 [ + - ]: 26 : if (inode) {
730 : 26 : inode->i_ino = get_next_ino();
731 : 26 : inode->i_mode = S_IFDIR | ctx->mode;
732 : 26 : inode->i_uid = ctx->uid;
733 : 26 : inode->i_gid = ctx->gid;
734 : 26 : inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
735 : 26 : inode->i_op = &hugetlbfs_dir_inode_operations;
736 : 26 : inode->i_fop = &simple_dir_operations;
737 : : /* directory inodes start off with i_nlink == 2 (for "." entry) */
738 : 26 : inc_nlink(inode);
739 : 26 : lockdep_annotate_inode_mutex_key(inode);
740 : : }
741 : 26 : return inode;
742 : : }
743 : :
744 : : /*
745 : : * Hugetlbfs is not reclaimable; therefore its i_mmap_rwsem will never
746 : : * be taken from reclaim -- unlike regular filesystems. This needs an
747 : : * annotation because huge_pmd_share() does an allocation under hugetlb's
748 : : * i_mmap_rwsem.
749 : : */
750 : : static struct lock_class_key hugetlbfs_i_mmap_rwsem_key;
751 : :
752 : 0 : static struct inode *hugetlbfs_get_inode(struct super_block *sb,
753 : : struct inode *dir,
754 : : umode_t mode, dev_t dev)
755 : : {
756 : 0 : struct inode *inode;
757 : 0 : struct resv_map *resv_map = NULL;
758 : :
759 : : /*
760 : : * Reserve maps are only needed for inodes that can have associated
761 : : * page allocations.
762 : : */
763 [ # # ]: 0 : if (S_ISREG(mode) || S_ISLNK(mode)) {
764 : 0 : resv_map = resv_map_alloc();
765 [ # # ]: 0 : if (!resv_map)
766 : : return NULL;
767 : : }
768 : :
769 : 0 : inode = new_inode(sb);
770 [ # # ]: 0 : if (inode) {
771 : 0 : struct hugetlbfs_inode_info *info = HUGETLBFS_I(inode);
772 : :
773 : 0 : inode->i_ino = get_next_ino();
774 : 0 : inode_init_owner(inode, dir, mode);
775 : 0 : lockdep_set_class(&inode->i_mapping->i_mmap_rwsem,
776 : : &hugetlbfs_i_mmap_rwsem_key);
777 : 0 : inode->i_mapping->a_ops = &hugetlbfs_aops;
778 : 0 : inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
779 : 0 : inode->i_mapping->private_data = resv_map;
780 : 0 : info->seals = F_SEAL_SEAL;
781 [ # # # # ]: 0 : switch (mode & S_IFMT) {
782 : 0 : default:
783 : 0 : init_special_inode(inode, mode, dev);
784 : 0 : break;
785 : 0 : case S_IFREG:
786 : 0 : inode->i_op = &hugetlbfs_inode_operations;
787 : 0 : inode->i_fop = &hugetlbfs_file_operations;
788 : 0 : break;
789 : 0 : case S_IFDIR:
790 : 0 : inode->i_op = &hugetlbfs_dir_inode_operations;
791 : 0 : inode->i_fop = &simple_dir_operations;
792 : :
793 : : /* directory inodes start off with i_nlink == 2 (for "." entry) */
794 : 0 : inc_nlink(inode);
795 : 0 : break;
796 : 0 : case S_IFLNK:
797 : 0 : inode->i_op = &page_symlink_inode_operations;
798 : 0 : inode_nohighmem(inode);
799 : 0 : break;
800 : : }
801 : : lockdep_annotate_inode_mutex_key(inode);
802 : : } else {
803 [ # # ]: 0 : if (resv_map)
804 : 0 : kref_put(&resv_map->refs, resv_map_release);
805 : : }
806 : :
807 : : return inode;
808 : : }
809 : :
810 : : /*
811 : : * File creation. Allocate an inode, and we're done..
812 : : */
813 : 0 : static int do_hugetlbfs_mknod(struct inode *dir,
814 : : struct dentry *dentry,
815 : : umode_t mode,
816 : : dev_t dev,
817 : : bool tmpfile)
818 : : {
819 : 0 : struct inode *inode;
820 : 0 : int error = -ENOSPC;
821 : :
822 : 0 : inode = hugetlbfs_get_inode(dir->i_sb, dir, mode, dev);
823 [ # # ]: 0 : if (inode) {
824 : 0 : dir->i_ctime = dir->i_mtime = current_time(dir);
825 [ # # ]: 0 : if (tmpfile) {
826 : 0 : d_tmpfile(dentry, inode);
827 : : } else {
828 : 0 : d_instantiate(dentry, inode);
829 [ # # ]: 0 : dget(dentry);/* Extra count - pin the dentry in core */
830 : : }
831 : : error = 0;
832 : : }
833 : 0 : return error;
834 : : }
835 : :
836 : 0 : static int hugetlbfs_mknod(struct inode *dir,
837 : : struct dentry *dentry, umode_t mode, dev_t dev)
838 : : {
839 : 0 : return do_hugetlbfs_mknod(dir, dentry, mode, dev, false);
840 : : }
841 : :
842 : 0 : static int hugetlbfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
843 : : {
844 : 0 : int retval = hugetlbfs_mknod(dir, dentry, mode | S_IFDIR, 0);
845 [ # # ]: 0 : if (!retval)
846 : 0 : inc_nlink(dir);
847 : 0 : return retval;
848 : : }
849 : :
850 : 0 : static int hugetlbfs_create(struct inode *dir, struct dentry *dentry, umode_t mode, bool excl)
851 : : {
852 : 0 : return hugetlbfs_mknod(dir, dentry, mode | S_IFREG, 0);
853 : : }
854 : :
855 : 0 : static int hugetlbfs_tmpfile(struct inode *dir,
856 : : struct dentry *dentry, umode_t mode)
857 : : {
858 : 0 : return do_hugetlbfs_mknod(dir, dentry, mode | S_IFREG, 0, true);
859 : : }
860 : :
861 : 0 : static int hugetlbfs_symlink(struct inode *dir,
862 : : struct dentry *dentry, const char *symname)
863 : : {
864 : 0 : struct inode *inode;
865 : 0 : int error = -ENOSPC;
866 : :
867 : 0 : inode = hugetlbfs_get_inode(dir->i_sb, dir, S_IFLNK|S_IRWXUGO, 0);
868 [ # # ]: 0 : if (inode) {
869 : 0 : int l = strlen(symname)+1;
870 : 0 : error = page_symlink(inode, symname, l);
871 [ # # ]: 0 : if (!error) {
872 : 0 : d_instantiate(dentry, inode);
873 [ # # ]: 0 : dget(dentry);
874 : : } else
875 : 0 : iput(inode);
876 : : }
877 : 0 : dir->i_ctime = dir->i_mtime = current_time(dir);
878 : :
879 : 0 : return error;
880 : : }
881 : :
882 : : /*
883 : : * mark the head page dirty
884 : : */
885 : 0 : static int hugetlbfs_set_page_dirty(struct page *page)
886 : : {
887 [ # # ]: 0 : struct page *head = compound_head(page);
888 : :
889 [ # # ]: 0 : SetPageDirty(head);
890 : 0 : return 0;
891 : : }
892 : :
893 : 0 : static int hugetlbfs_migrate_page(struct address_space *mapping,
894 : : struct page *newpage, struct page *page,
895 : : enum migrate_mode mode)
896 : : {
897 : 0 : int rc;
898 : :
899 : 0 : rc = migrate_huge_page_move_mapping(mapping, newpage, page);
900 [ # # ]: 0 : if (rc != MIGRATEPAGE_SUCCESS)
901 : : return rc;
902 : :
903 : : /*
904 : : * page_private is subpool pointer in hugetlb pages. Transfer to
905 : : * new page. PagePrivate is not associated with page_private for
906 : : * hugetlb pages and can not be set here as only page_huge_active
907 : : * pages can be migrated.
908 : : */
909 [ # # ]: 0 : if (page_private(page)) {
910 : 0 : set_page_private(newpage, page_private(page));
911 : 0 : set_page_private(page, 0);
912 : : }
913 : :
914 [ # # ]: 0 : if (mode != MIGRATE_SYNC_NO_COPY)
915 : 0 : migrate_page_copy(newpage, page);
916 : : else
917 : 0 : migrate_page_states(newpage, page);
918 : :
919 : : return MIGRATEPAGE_SUCCESS;
920 : : }
921 : :
922 : 0 : static int hugetlbfs_error_remove_page(struct address_space *mapping,
923 : : struct page *page)
924 : : {
925 : 0 : struct inode *inode = mapping->host;
926 : 0 : pgoff_t index = page->index;
927 : :
928 : 0 : remove_huge_page(page);
929 [ # # ]: 0 : if (unlikely(hugetlb_unreserve_pages(inode, index, index + 1, 1)))
930 : 0 : hugetlb_fix_reserve_counts(inode);
931 : :
932 : 0 : return 0;
933 : : }
934 : :
935 : : /*
936 : : * Display the mount options in /proc/mounts.
937 : : */
938 : 1456 : static int hugetlbfs_show_options(struct seq_file *m, struct dentry *root)
939 : : {
940 [ - + ]: 1456 : struct hugetlbfs_sb_info *sbinfo = HUGETLBFS_SB(root->d_sb);
941 : 1456 : struct hugepage_subpool *spool = sbinfo->spool;
942 [ - + ]: 1456 : unsigned long hpage_size = huge_page_size(sbinfo->hstate);
943 [ - + ]: 1456 : unsigned hpage_shift = huge_page_shift(sbinfo->hstate);
944 : 1456 : char mod;
945 : :
946 [ - + ]: 1456 : if (!uid_eq(sbinfo->uid, GLOBAL_ROOT_UID))
947 [ # # ]: 0 : seq_printf(m, ",uid=%u",
948 : : from_kuid_munged(&init_user_ns, sbinfo->uid));
949 [ - + ]: 1456 : if (!gid_eq(sbinfo->gid, GLOBAL_ROOT_GID))
950 [ # # ]: 0 : seq_printf(m, ",gid=%u",
951 : : from_kgid_munged(&init_user_ns, sbinfo->gid));
952 [ - + ]: 1456 : if (sbinfo->mode != 0755)
953 : 0 : seq_printf(m, ",mode=%o", sbinfo->mode);
954 [ - + ]: 1456 : if (sbinfo->max_inodes != -1)
955 : 0 : seq_printf(m, ",nr_inodes=%lu", sbinfo->max_inodes);
956 : :
957 : 1456 : hpage_size /= 1024;
958 : 1456 : mod = 'K';
959 [ + - ]: 1456 : if (hpage_size >= 1024) {
960 : 1456 : hpage_size /= 1024;
961 : 1456 : mod = 'M';
962 : : }
963 : 1456 : seq_printf(m, ",pagesize=%lu%c", hpage_size, mod);
964 [ - + ]: 1456 : if (spool) {
965 [ # # ]: 0 : if (spool->max_hpages != -1)
966 : 0 : seq_printf(m, ",size=%llu",
967 : 0 : (unsigned long long)spool->max_hpages << hpage_shift);
968 [ # # ]: 0 : if (spool->min_hpages != -1)
969 : 0 : seq_printf(m, ",min_size=%llu",
970 : 0 : (unsigned long long)spool->min_hpages << hpage_shift);
971 : : }
972 : 1456 : return 0;
973 : : }
974 : :
975 : 0 : static int hugetlbfs_statfs(struct dentry *dentry, struct kstatfs *buf)
976 : : {
977 [ # # ]: 0 : struct hugetlbfs_sb_info *sbinfo = HUGETLBFS_SB(dentry->d_sb);
978 [ # # ]: 0 : struct hstate *h = hstate_inode(d_inode(dentry));
979 : :
980 : 0 : buf->f_type = HUGETLBFS_MAGIC;
981 [ # # ]: 0 : buf->f_bsize = huge_page_size(h);
982 [ # # ]: 0 : if (sbinfo) {
983 : 0 : spin_lock(&sbinfo->stat_lock);
984 : : /* If no limits set, just report 0 for max/free/used
985 : : * blocks, like simple_statfs() */
986 [ # # ]: 0 : if (sbinfo->spool) {
987 : 0 : long free_pages;
988 : :
989 : 0 : spin_lock(&sbinfo->spool->lock);
990 : 0 : buf->f_blocks = sbinfo->spool->max_hpages;
991 : 0 : free_pages = sbinfo->spool->max_hpages
992 : 0 : - sbinfo->spool->used_hpages;
993 : 0 : buf->f_bavail = buf->f_bfree = free_pages;
994 : 0 : spin_unlock(&sbinfo->spool->lock);
995 : 0 : buf->f_files = sbinfo->max_inodes;
996 : 0 : buf->f_ffree = sbinfo->free_inodes;
997 : : }
998 : 0 : spin_unlock(&sbinfo->stat_lock);
999 : : }
1000 : 0 : buf->f_namelen = NAME_MAX;
1001 : 0 : return 0;
1002 : : }
1003 : :
1004 : 0 : static void hugetlbfs_put_super(struct super_block *sb)
1005 : : {
1006 [ # # ]: 0 : struct hugetlbfs_sb_info *sbi = HUGETLBFS_SB(sb);
1007 : :
1008 [ # # ]: 0 : if (sbi) {
1009 : 0 : sb->s_fs_info = NULL;
1010 : :
1011 [ # # ]: 0 : if (sbi->spool)
1012 : 0 : hugepage_put_subpool(sbi->spool);
1013 : :
1014 : 0 : kfree(sbi);
1015 : : }
1016 : 0 : }
1017 : :
1018 : 26 : static inline int hugetlbfs_dec_free_inodes(struct hugetlbfs_sb_info *sbinfo)
1019 : : {
1020 [ - + ]: 26 : if (sbinfo->free_inodes >= 0) {
1021 : 0 : spin_lock(&sbinfo->stat_lock);
1022 [ # # ]: 0 : if (unlikely(!sbinfo->free_inodes)) {
1023 : 0 : spin_unlock(&sbinfo->stat_lock);
1024 : 0 : return 0;
1025 : : }
1026 : 0 : sbinfo->free_inodes--;
1027 : 0 : spin_unlock(&sbinfo->stat_lock);
1028 : : }
1029 : :
1030 : : return 1;
1031 : : }
1032 : :
1033 : 0 : static void hugetlbfs_inc_free_inodes(struct hugetlbfs_sb_info *sbinfo)
1034 : : {
1035 [ # # ]: 0 : if (sbinfo->free_inodes >= 0) {
1036 : 0 : spin_lock(&sbinfo->stat_lock);
1037 : 0 : sbinfo->free_inodes++;
1038 : 0 : spin_unlock(&sbinfo->stat_lock);
1039 : : }
1040 : : }
1041 : :
1042 : :
1043 : : static struct kmem_cache *hugetlbfs_inode_cachep;
1044 : :
1045 : 26 : static struct inode *hugetlbfs_alloc_inode(struct super_block *sb)
1046 : : {
1047 : 26 : struct hugetlbfs_sb_info *sbinfo = HUGETLBFS_SB(sb);
1048 : 26 : struct hugetlbfs_inode_info *p;
1049 : :
1050 [ + - ]: 26 : if (unlikely(!hugetlbfs_dec_free_inodes(sbinfo)))
1051 : : return NULL;
1052 : 26 : p = kmem_cache_alloc(hugetlbfs_inode_cachep, GFP_KERNEL);
1053 [ - + ]: 26 : if (unlikely(!p)) {
1054 [ # # ]: 0 : hugetlbfs_inc_free_inodes(sbinfo);
1055 : 0 : return NULL;
1056 : : }
1057 : :
1058 : : /*
1059 : : * Any time after allocation, hugetlbfs_destroy_inode can be called
1060 : : * for the inode. mpol_free_shared_policy is unconditionally called
1061 : : * as part of hugetlbfs_destroy_inode. So, initialize policy here
1062 : : * in case of a quick call to destroy.
1063 : : *
1064 : : * Note that the policy is initialized even if we are creating a
1065 : : * private inode. This simplifies hugetlbfs_destroy_inode.
1066 : : */
1067 : 26 : mpol_shared_policy_init(&p->policy, NULL);
1068 : :
1069 : 26 : return &p->vfs_inode;
1070 : : }
1071 : :
1072 : 0 : static void hugetlbfs_free_inode(struct inode *inode)
1073 : : {
1074 : 0 : kmem_cache_free(hugetlbfs_inode_cachep, HUGETLBFS_I(inode));
1075 : 0 : }
1076 : :
1077 : 0 : static void hugetlbfs_destroy_inode(struct inode *inode)
1078 : : {
1079 [ # # ]: 0 : hugetlbfs_inc_free_inodes(HUGETLBFS_SB(inode->i_sb));
1080 : 0 : mpol_free_shared_policy(&HUGETLBFS_I(inode)->policy);
1081 : 0 : }
1082 : :
1083 : : static const struct address_space_operations hugetlbfs_aops = {
1084 : : .write_begin = hugetlbfs_write_begin,
1085 : : .write_end = hugetlbfs_write_end,
1086 : : .set_page_dirty = hugetlbfs_set_page_dirty,
1087 : : .migratepage = hugetlbfs_migrate_page,
1088 : : .error_remove_page = hugetlbfs_error_remove_page,
1089 : : };
1090 : :
1091 : :
1092 : 143 : static void init_once(void *foo)
1093 : : {
1094 : 143 : struct hugetlbfs_inode_info *ei = (struct hugetlbfs_inode_info *)foo;
1095 : :
1096 : 143 : inode_init_once(&ei->vfs_inode);
1097 : 143 : }
1098 : :
1099 : : const struct file_operations hugetlbfs_file_operations = {
1100 : : .read_iter = hugetlbfs_read_iter,
1101 : : .mmap = hugetlbfs_file_mmap,
1102 : : .fsync = noop_fsync,
1103 : : .get_unmapped_area = hugetlb_get_unmapped_area,
1104 : : .llseek = default_llseek,
1105 : : .fallocate = hugetlbfs_fallocate,
1106 : : };
1107 : :
1108 : : static const struct inode_operations hugetlbfs_dir_inode_operations = {
1109 : : .create = hugetlbfs_create,
1110 : : .lookup = simple_lookup,
1111 : : .link = simple_link,
1112 : : .unlink = simple_unlink,
1113 : : .symlink = hugetlbfs_symlink,
1114 : : .mkdir = hugetlbfs_mkdir,
1115 : : .rmdir = simple_rmdir,
1116 : : .mknod = hugetlbfs_mknod,
1117 : : .rename = simple_rename,
1118 : : .setattr = hugetlbfs_setattr,
1119 : : .tmpfile = hugetlbfs_tmpfile,
1120 : : };
1121 : :
1122 : : static const struct inode_operations hugetlbfs_inode_operations = {
1123 : : .setattr = hugetlbfs_setattr,
1124 : : };
1125 : :
1126 : : static const struct super_operations hugetlbfs_ops = {
1127 : : .alloc_inode = hugetlbfs_alloc_inode,
1128 : : .free_inode = hugetlbfs_free_inode,
1129 : : .destroy_inode = hugetlbfs_destroy_inode,
1130 : : .evict_inode = hugetlbfs_evict_inode,
1131 : : .statfs = hugetlbfs_statfs,
1132 : : .put_super = hugetlbfs_put_super,
1133 : : .show_options = hugetlbfs_show_options,
1134 : : };
1135 : :
1136 : : /*
1137 : : * Convert size option passed from command line to number of huge pages
1138 : : * in the pool specified by hstate. Size option could be in bytes
1139 : : * (val_type == SIZE_STD) or percentage of the pool (val_type == SIZE_PERCENT).
1140 : : */
1141 : : static long
1142 : : hugetlbfs_size_to_hpages(struct hstate *h, unsigned long long size_opt,
1143 : : enum hugetlbfs_size_type val_type)
1144 : : {
1145 : : if (val_type == NO_SIZE)
1146 : : return -1;
1147 : :
1148 : : if (val_type == SIZE_PERCENT) {
1149 : : size_opt <<= huge_page_shift(h);
1150 : : size_opt *= h->max_huge_pages;
1151 : : do_div(size_opt, 100);
1152 : : }
1153 : :
1154 : : size_opt >>= huge_page_shift(h);
1155 : : return size_opt;
1156 : : }
1157 : :
1158 : : /*
1159 : : * Parse one mount parameter.
1160 : : */
1161 : 13 : static int hugetlbfs_parse_param(struct fs_context *fc, struct fs_parameter *param)
1162 : : {
1163 : 13 : struct hugetlbfs_fs_context *ctx = fc->fs_private;
1164 : 13 : struct fs_parse_result result;
1165 : 13 : char *rest;
1166 : 13 : unsigned long ps;
1167 : 13 : int opt;
1168 : :
1169 : 13 : opt = fs_parse(fc, hugetlb_fs_parameters, param, &result);
1170 [ - + ]: 13 : if (opt < 0)
1171 : : return opt;
1172 : :
1173 [ # # # # : 0 : switch (opt) {
# # # # ]
1174 : 0 : case Opt_uid:
1175 [ # # ]: 0 : ctx->uid = make_kuid(current_user_ns(), result.uint_32);
1176 [ # # ]: 0 : if (!uid_valid(ctx->uid))
1177 : 0 : goto bad_val;
1178 : : return 0;
1179 : :
1180 : 0 : case Opt_gid:
1181 [ # # ]: 0 : ctx->gid = make_kgid(current_user_ns(), result.uint_32);
1182 [ # # ]: 0 : if (!gid_valid(ctx->gid))
1183 : 0 : goto bad_val;
1184 : : return 0;
1185 : :
1186 : 0 : case Opt_mode:
1187 : 0 : ctx->mode = result.uint_32 & 01777U;
1188 : 0 : return 0;
1189 : :
1190 : 0 : case Opt_size:
1191 : : /* memparse() will accept a K/M/G without a digit */
1192 [ # # ]: 0 : if (!isdigit(param->string[0]))
1193 : 0 : goto bad_val;
1194 : 0 : ctx->max_size_opt = memparse(param->string, &rest);
1195 : 0 : ctx->max_val_type = SIZE_STD;
1196 [ # # ]: 0 : if (*rest == '%')
1197 : 0 : ctx->max_val_type = SIZE_PERCENT;
1198 : : return 0;
1199 : :
1200 : 0 : case Opt_nr_inodes:
1201 : : /* memparse() will accept a K/M/G without a digit */
1202 [ # # ]: 0 : if (!isdigit(param->string[0]))
1203 : 0 : goto bad_val;
1204 : 0 : ctx->nr_inodes = memparse(param->string, &rest);
1205 : 0 : return 0;
1206 : :
1207 : 0 : case Opt_pagesize:
1208 : 0 : ps = memparse(param->string, &rest);
1209 : 0 : ctx->hstate = size_to_hstate(ps);
1210 [ # # ]: 0 : if (!ctx->hstate) {
1211 : 0 : pr_err("Unsupported page size %lu MB\n", ps >> 20);
1212 : 0 : return -EINVAL;
1213 : : }
1214 : : return 0;
1215 : :
1216 : 0 : case Opt_min_size:
1217 : : /* memparse() will accept a K/M/G without a digit */
1218 [ # # ]: 0 : if (!isdigit(param->string[0]))
1219 : 0 : goto bad_val;
1220 : 0 : ctx->min_size_opt = memparse(param->string, &rest);
1221 : 0 : ctx->min_val_type = SIZE_STD;
1222 [ # # ]: 0 : if (*rest == '%')
1223 : 0 : ctx->min_val_type = SIZE_PERCENT;
1224 : : return 0;
1225 : :
1226 : : default:
1227 : : return -EINVAL;
1228 : : }
1229 : :
1230 : 0 : bad_val:
1231 : 0 : return invalfc(fc, "Bad value '%s' for mount option '%s'\n",
1232 : : param->string, param->key);
1233 : : }
1234 : :
1235 : : /*
1236 : : * Validate the parsed options.
1237 : : */
1238 : : static int hugetlbfs_validate(struct fs_context *fc)
1239 : : {
1240 : : struct hugetlbfs_fs_context *ctx = fc->fs_private;
1241 : :
1242 : : /*
1243 : : * Use huge page pool size (in hstate) to convert the size
1244 : : * options to number of huge pages. If NO_SIZE, -1 is returned.
1245 : : */
1246 : : ctx->max_hpages = hugetlbfs_size_to_hpages(ctx->hstate,
1247 : : ctx->max_size_opt,
1248 : : ctx->max_val_type);
1249 : : ctx->min_hpages = hugetlbfs_size_to_hpages(ctx->hstate,
1250 : : ctx->min_size_opt,
1251 : : ctx->min_val_type);
1252 : :
1253 : : /*
1254 : : * If max_size was specified, then min_size must be smaller
1255 : : */
1256 : : if (ctx->max_val_type > NO_SIZE &&
1257 : : ctx->min_hpages > ctx->max_hpages) {
1258 : : pr_err("Minimum size can not be greater than maximum size\n");
1259 : : return -EINVAL;
1260 : : }
1261 : :
1262 : : return 0;
1263 : : }
1264 : :
1265 : : static int
1266 : 26 : hugetlbfs_fill_super(struct super_block *sb, struct fs_context *fc)
1267 : : {
1268 : 26 : struct hugetlbfs_fs_context *ctx = fc->fs_private;
1269 : 26 : struct hugetlbfs_sb_info *sbinfo;
1270 : :
1271 : 26 : sbinfo = kmalloc(sizeof(struct hugetlbfs_sb_info), GFP_KERNEL);
1272 [ + - ]: 26 : if (!sbinfo)
1273 : : return -ENOMEM;
1274 : 26 : sb->s_fs_info = sbinfo;
1275 [ + - ]: 26 : spin_lock_init(&sbinfo->stat_lock);
1276 : 26 : sbinfo->hstate = ctx->hstate;
1277 : 26 : sbinfo->max_inodes = ctx->nr_inodes;
1278 : 26 : sbinfo->free_inodes = ctx->nr_inodes;
1279 : 26 : sbinfo->spool = NULL;
1280 : 26 : sbinfo->uid = ctx->uid;
1281 : 26 : sbinfo->gid = ctx->gid;
1282 : 26 : sbinfo->mode = ctx->mode;
1283 : :
1284 : : /*
1285 : : * Allocate and initialize subpool if maximum or minimum size is
1286 : : * specified. Any needed reservations (for minimim size) are taken
1287 : : * taken when the subpool is created.
1288 : : */
1289 [ + - - + ]: 26 : if (ctx->max_hpages != -1 || ctx->min_hpages != -1) {
1290 : 0 : sbinfo->spool = hugepage_new_subpool(ctx->hstate,
1291 : : ctx->max_hpages,
1292 : : ctx->min_hpages);
1293 [ # # ]: 0 : if (!sbinfo->spool)
1294 : 0 : goto out_free;
1295 : : }
1296 : 26 : sb->s_maxbytes = MAX_LFS_FILESIZE;
1297 : 26 : sb->s_blocksize = huge_page_size(ctx->hstate);
1298 : 26 : sb->s_blocksize_bits = huge_page_shift(ctx->hstate);
1299 : 26 : sb->s_magic = HUGETLBFS_MAGIC;
1300 : 26 : sb->s_op = &hugetlbfs_ops;
1301 : 26 : sb->s_time_gran = 1;
1302 : 26 : sb->s_root = d_make_root(hugetlbfs_get_root(sb, ctx));
1303 [ - + ]: 26 : if (!sb->s_root)
1304 : 0 : goto out_free;
1305 : : return 0;
1306 : 0 : out_free:
1307 : 0 : kfree(sbinfo->spool);
1308 : 0 : kfree(sbinfo);
1309 : 0 : return -ENOMEM;
1310 : : }
1311 : :
1312 : 26 : static int hugetlbfs_get_tree(struct fs_context *fc)
1313 : : {
1314 : 26 : int err = hugetlbfs_validate(fc);
1315 [ + - ]: 26 : if (err)
1316 : : return err;
1317 : 26 : return get_tree_nodev(fc, hugetlbfs_fill_super);
1318 : : }
1319 : :
1320 : 26 : static void hugetlbfs_fs_context_free(struct fs_context *fc)
1321 : : {
1322 : 26 : kfree(fc->fs_private);
1323 : 26 : }
1324 : :
1325 : : static const struct fs_context_operations hugetlbfs_fs_context_ops = {
1326 : : .free = hugetlbfs_fs_context_free,
1327 : : .parse_param = hugetlbfs_parse_param,
1328 : : .get_tree = hugetlbfs_get_tree,
1329 : : };
1330 : :
1331 : 26 : static int hugetlbfs_init_fs_context(struct fs_context *fc)
1332 : : {
1333 : 26 : struct hugetlbfs_fs_context *ctx;
1334 : :
1335 : 26 : ctx = kzalloc(sizeof(struct hugetlbfs_fs_context), GFP_KERNEL);
1336 [ + - ]: 26 : if (!ctx)
1337 : : return -ENOMEM;
1338 : :
1339 : 26 : ctx->max_hpages = -1; /* No limit on size by default */
1340 : 26 : ctx->nr_inodes = -1; /* No limit on number of inodes by default */
1341 : 26 : ctx->uid = current_fsuid();
1342 : 26 : ctx->gid = current_fsgid();
1343 : 26 : ctx->mode = 0755;
1344 : 26 : ctx->hstate = &default_hstate;
1345 : 26 : ctx->min_hpages = -1; /* No default minimum size */
1346 : 26 : ctx->max_val_type = NO_SIZE;
1347 : 26 : ctx->min_val_type = NO_SIZE;
1348 : 26 : fc->fs_private = ctx;
1349 : 26 : fc->ops = &hugetlbfs_fs_context_ops;
1350 : 26 : return 0;
1351 : : }
1352 : :
1353 : : static struct file_system_type hugetlbfs_fs_type = {
1354 : : .name = "hugetlbfs",
1355 : : .init_fs_context = hugetlbfs_init_fs_context,
1356 : : .parameters = hugetlb_fs_parameters,
1357 : : .kill_sb = kill_litter_super,
1358 : : };
1359 : :
1360 : : static struct vfsmount *hugetlbfs_vfsmount[HUGE_MAX_HSTATE];
1361 : :
1362 : 0 : static int can_do_hugetlb_shm(void)
1363 : : {
1364 : 0 : kgid_t shm_group;
1365 : 0 : shm_group = make_kgid(&init_user_ns, sysctl_hugetlb_shm_group);
1366 [ # # # # ]: 0 : return capable(CAP_IPC_LOCK) || in_group_p(shm_group);
1367 : : }
1368 : :
1369 : 0 : static int get_hstate_idx(int page_size_log)
1370 : : {
1371 [ # # ]: 0 : struct hstate *h = hstate_sizelog(page_size_log);
1372 : :
1373 [ # # ]: 0 : if (!h)
1374 : : return -1;
1375 : 0 : return h - hstates;
1376 : : }
1377 : :
1378 : : /*
1379 : : * Note that size should be aligned to proper hugepage size in caller side,
1380 : : * otherwise hugetlb_reserve_pages reserves one less hugepages than intended.
1381 : : */
1382 : 0 : struct file *hugetlb_file_setup(const char *name, size_t size,
1383 : : vm_flags_t acctflag, struct user_struct **user,
1384 : : int creat_flags, int page_size_log)
1385 : : {
1386 : 0 : struct inode *inode;
1387 : 0 : struct vfsmount *mnt;
1388 : 0 : int hstate_idx;
1389 : 0 : struct file *file;
1390 : :
1391 : 0 : hstate_idx = get_hstate_idx(page_size_log);
1392 [ # # ]: 0 : if (hstate_idx < 0)
1393 : : return ERR_PTR(-ENODEV);
1394 : :
1395 : 0 : *user = NULL;
1396 : 0 : mnt = hugetlbfs_vfsmount[hstate_idx];
1397 [ # # ]: 0 : if (!mnt)
1398 : : return ERR_PTR(-ENOENT);
1399 : :
1400 [ # # # # ]: 0 : if (creat_flags == HUGETLB_SHMFS_INODE && !can_do_hugetlb_shm()) {
1401 : 0 : *user = current_user();
1402 [ # # ]: 0 : if (user_shm_lock(size, *user)) {
1403 : 0 : task_lock(current);
1404 [ # # ]: 0 : pr_warn_once("%s (%d): Using mlock ulimits for SHM_HUGETLB is deprecated\n",
1405 : : current->comm, current->pid);
1406 : 0 : task_unlock(current);
1407 : : } else {
1408 : 0 : *user = NULL;
1409 : 0 : return ERR_PTR(-EPERM);
1410 : : }
1411 : : }
1412 : :
1413 : 0 : file = ERR_PTR(-ENOSPC);
1414 : 0 : inode = hugetlbfs_get_inode(mnt->mnt_sb, NULL, S_IFREG | S_IRWXUGO, 0);
1415 [ # # ]: 0 : if (!inode)
1416 : 0 : goto out;
1417 [ # # ]: 0 : if (creat_flags == HUGETLB_SHMFS_INODE)
1418 : 0 : inode->i_flags |= S_PRIVATE;
1419 : :
1420 : 0 : inode->i_size = size;
1421 : 0 : clear_nlink(inode);
1422 : :
1423 [ # # ]: 0 : if (hugetlb_reserve_pages(inode, 0,
1424 : 0 : size >> huge_page_shift(hstate_inode(inode)), NULL,
1425 : : acctflag))
1426 : : file = ERR_PTR(-ENOMEM);
1427 : : else
1428 : 0 : file = alloc_file_pseudo(inode, mnt, name, O_RDWR,
1429 : : &hugetlbfs_file_operations);
1430 [ # # ]: 0 : if (!IS_ERR(file))
1431 : : return file;
1432 : :
1433 : 0 : iput(inode);
1434 : 0 : out:
1435 [ # # ]: 0 : if (*user) {
1436 : 0 : user_shm_unlock(size, *user);
1437 : 0 : *user = NULL;
1438 : : }
1439 : : return file;
1440 : : }
1441 : :
1442 : 13 : static struct vfsmount *__init mount_one_hugetlbfs(struct hstate *h)
1443 : : {
1444 : 13 : struct fs_context *fc;
1445 : 13 : struct vfsmount *mnt;
1446 : :
1447 : 13 : fc = fs_context_for_mount(&hugetlbfs_fs_type, SB_KERNMOUNT);
1448 [ + - ]: 13 : if (IS_ERR(fc)) {
1449 : : mnt = ERR_CAST(fc);
1450 : : } else {
1451 : 13 : struct hugetlbfs_fs_context *ctx = fc->fs_private;
1452 : 13 : ctx->hstate = h;
1453 : 13 : mnt = fc_mount(fc);
1454 : 13 : put_fs_context(fc);
1455 : : }
1456 [ - + ]: 13 : if (IS_ERR(mnt))
1457 : 0 : pr_err("Cannot mount internal hugetlbfs for page size %uK",
1458 : : 1U << (h->order + PAGE_SHIFT - 10));
1459 : 13 : return mnt;
1460 : : }
1461 : :
1462 : 13 : static int __init init_hugetlbfs_fs(void)
1463 : : {
1464 : 13 : struct vfsmount *mnt;
1465 : 13 : struct hstate *h;
1466 : 13 : int error;
1467 : 13 : int i;
1468 : :
1469 [ - + ]: 13 : if (!hugepages_supported()) {
1470 : 0 : pr_info("disabling because there are no supported hugepage sizes\n");
1471 : 0 : return -ENOTSUPP;
1472 : : }
1473 : :
1474 : 13 : error = -ENOMEM;
1475 : 13 : hugetlbfs_inode_cachep = kmem_cache_create("hugetlbfs_inode_cache",
1476 : : sizeof(struct hugetlbfs_inode_info),
1477 : : 0, SLAB_ACCOUNT, init_once);
1478 [ - + ]: 13 : if (hugetlbfs_inode_cachep == NULL)
1479 : 0 : goto out;
1480 : :
1481 : 13 : error = register_filesystem(&hugetlbfs_fs_type);
1482 [ - + ]: 13 : if (error)
1483 : 0 : goto out_free;
1484 : :
1485 : : /* default hstate mount is required */
1486 : 13 : mnt = mount_one_hugetlbfs(&hstates[default_hstate_idx]);
1487 [ - + ]: 13 : if (IS_ERR(mnt)) {
1488 : 0 : error = PTR_ERR(mnt);
1489 : 0 : goto out_unreg;
1490 : : }
1491 : 13 : hugetlbfs_vfsmount[default_hstate_idx] = mnt;
1492 : :
1493 : : /* other hstates are optional */
1494 : 13 : i = 0;
1495 [ + + ]: 26 : for_each_hstate(h) {
1496 [ + - ]: 13 : if (i == default_hstate_idx) {
1497 : 13 : i++;
1498 : 13 : continue;
1499 : : }
1500 : :
1501 : 0 : mnt = mount_one_hugetlbfs(h);
1502 [ # # ]: 0 : if (IS_ERR(mnt))
1503 : 0 : hugetlbfs_vfsmount[i] = NULL;
1504 : : else
1505 : 0 : hugetlbfs_vfsmount[i] = mnt;
1506 : 0 : i++;
1507 : : }
1508 : :
1509 : : return 0;
1510 : :
1511 : : out_unreg:
1512 : 0 : (void)unregister_filesystem(&hugetlbfs_fs_type);
1513 : 0 : out_free:
1514 : 0 : kmem_cache_destroy(hugetlbfs_inode_cachep);
1515 : : out:
1516 : : return error;
1517 : : }
1518 : : fs_initcall(init_hugetlbfs_fs)
|
