1 /* SPDX-License-Identifier: GPL-2.0 */ 2 #include <stdint.h> 3 #include <stdbool.h> 4 #include <sys/mman.h> 5 #include <err.h> 6 #include <strings.h> /* ffsl() */ 7 #include <unistd.h> /* _SC_PAGESIZE */ 8 #include "../kselftest.h" 9 #include <linux/fs.h> 10 11 #define BIT_ULL(nr) (1ULL << (nr)) 12 #define PM_SOFT_DIRTY BIT_ULL(55) 13 #define PM_MMAP_EXCLUSIVE BIT_ULL(56) 14 #define PM_UFFD_WP BIT_ULL(57) 15 #define PM_GUARD_REGION BIT_ULL(58) 16 #define PM_FILE BIT_ULL(61) 17 #define PM_SWAP BIT_ULL(62) 18 #define PM_PRESENT BIT_ULL(63) 19 20 extern unsigned int __page_size; 21 extern unsigned int __page_shift; 22 23 /* 24 * Represents an open fd and PROCMAP_QUERY state for binary (via ioctl) 25 * /proc/$pid/[s]maps lookup. 26 */ 27 struct procmap_fd { 28 int fd; 29 struct procmap_query query; 30 }; 31 32 static inline unsigned int psize(void) 33 { 34 if (!__page_size) 35 __page_size = sysconf(_SC_PAGESIZE); 36 return __page_size; 37 } 38 39 static inline unsigned int pshift(void) 40 { 41 if (!__page_shift) 42 __page_shift = (ffsl(psize()) - 1); 43 return __page_shift; 44 } 45 46 /* 47 * Plan 9 FS has bugs (at least on QEMU) where certain operations fail with 48 * ENOENT on unlinked files. See 49 * https://gitlab.com/qemu-project/qemu/-/issues/103 for some info about such 50 * bugs. There are rumours of NFS implementations with similar bugs. 51 * 52 * Ideally, tests should just detect filesystems known to have such issues and 53 * bail early. But 9pfs has the additional "feature" that it causes fstatfs to 54 * pass through the f_type field from the host filesystem. To avoid having to 55 * scrape /proc/mounts or some other hackery, tests can call this function when 56 * it seems such a bug might have been encountered. 57 */ 58 static inline void skip_test_dodgy_fs(const char *op_name) 59 { 60 ksft_test_result_skip("%s failed with ENOENT. Filesystem might be buggy (9pfs?)\n", op_name); 61 } 62 63 uint64_t pagemap_get_entry(int fd, char *start); 64 bool pagemap_is_softdirty(int fd, char *start); 65 bool pagemap_is_swapped(int fd, char *start); 66 bool pagemap_is_populated(int fd, char *start); 67 unsigned long pagemap_get_pfn(int fd, char *start); 68 void clear_softdirty(void); 69 bool check_for_pattern(FILE *fp, const char *pattern, char *buf, size_t len); 70 uint64_t read_pmd_pagesize(void); 71 unsigned long rss_anon(void); 72 bool check_huge_anon(void *addr, int nr_hpages, uint64_t hpage_size); 73 bool check_huge_file(void *addr, int nr_hpages, uint64_t hpage_size); 74 bool check_huge_shmem(void *addr, int nr_hpages, uint64_t hpage_size); 75 int64_t allocate_transhuge(void *ptr, int pagemap_fd); 76 unsigned long default_huge_page_size(void); 77 int detect_hugetlb_page_sizes(size_t sizes[], int max); 78 79 int uffd_register(int uffd, void *addr, uint64_t len, 80 bool miss, bool wp, bool minor); 81 int uffd_unregister(int uffd, void *addr, uint64_t len); 82 int uffd_register_with_ioctls(int uffd, void *addr, uint64_t len, 83 bool miss, bool wp, bool minor, uint64_t *ioctls); 84 unsigned long get_free_hugepages(void); 85 bool check_vmflag_io(void *addr); 86 int open_procmap(pid_t pid, struct procmap_fd *procmap_out); 87 int query_procmap(struct procmap_fd *procmap); 88 bool find_vma_procmap(struct procmap_fd *procmap, void *address); 89 int close_procmap(struct procmap_fd *procmap); 90 91 static inline int open_self_procmap(struct procmap_fd *procmap_out) 92 { 93 pid_t pid = getpid(); 94 95 return open_procmap(pid, procmap_out); 96 } 97 98 /* 99 * On ppc64 this will only work with radix 2M hugepage size 100 */ 101 #define HPAGE_SHIFT 21 102 #define HPAGE_SIZE (1 << HPAGE_SHIFT) 103 104 #define PAGEMAP_PRESENT(ent) (((ent) & (1ull << 63)) != 0) 105 #define PAGEMAP_PFN(ent) ((ent) & ((1ull << 55) - 1)) 106