vm_util.h

  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 <stdarg.h>
  7#include <strings.h> /* ffsl() */
  8#include <unistd.h> /* _SC_PAGESIZE */
  9#include "kselftest.h"
 10#include <linux/fs.h>
 11
 12#define BIT_ULL(nr)                   (1ULL << (nr))
 13#define PM_SOFT_DIRTY                 BIT_ULL(55)
 14#define PM_MMAP_EXCLUSIVE             BIT_ULL(56)
 15#define PM_UFFD_WP                    BIT_ULL(57)
 16#define PM_GUARD_REGION               BIT_ULL(58)
 17#define PM_FILE                       BIT_ULL(61)
 18#define PM_SWAP                       BIT_ULL(62)
 19#define PM_PRESENT                    BIT_ULL(63)
 20
 21#define KPF_COMPOUND_HEAD             BIT_ULL(15)
 22#define KPF_COMPOUND_TAIL             BIT_ULL(16)
 23#define KPF_THP                       BIT_ULL(22)
 24/*
 25 * Ignore the checkpatch warning, we must read from x but don't want to do
 26 * anything with it in order to trigger a read page fault. We therefore must use
 27 * volatile to stop the compiler from optimising this away.
 28 */
 29#define FORCE_READ(x) (*(const volatile typeof(x) *)&(x))
 30
 31extern unsigned int __page_size;
 32extern unsigned int __page_shift;
 33
 34/*
 35 * Represents an open fd and PROCMAP_QUERY state for binary (via ioctl)
 36 * /proc/$pid/[s]maps lookup.
 37 */
 38struct procmap_fd {
 39	int fd;
 40	struct procmap_query query;
 41};
 42
 43static inline unsigned int psize(void)
 44{
 45	if (!__page_size)
 46		__page_size = sysconf(_SC_PAGESIZE);
 47	return __page_size;
 48}
 49
 50static inline unsigned int pshift(void)
 51{
 52	if (!__page_shift)
 53		__page_shift = (ffsl(psize()) - 1);
 54	return __page_shift;
 55}
 56
 57bool detect_huge_zeropage(void);
 58
 59/*
 60 * Plan 9 FS has bugs (at least on QEMU) where certain operations fail with
 61 * ENOENT on unlinked files. See
 62 * https://gitlab.com/qemu-project/qemu/-/issues/103 for some info about such
 63 * bugs. There are rumours of NFS implementations with similar bugs.
 64 *
 65 * Ideally, tests should just detect filesystems known to have such issues and
 66 * bail early. But 9pfs has the additional "feature" that it causes fstatfs to
 67 * pass through the f_type field from the host filesystem. To avoid having to
 68 * scrape /proc/mounts or some other hackery, tests can call this function when
 69 * it seems such a bug might have been encountered.
 70 */
 71static inline void skip_test_dodgy_fs(const char *op_name)
 72{
 73	ksft_test_result_skip("%s failed with ENOENT. Filesystem might be buggy (9pfs?)\n", op_name);
 74}
 75
 76uint64_t pagemap_get_entry(int fd, char *start);
 77bool pagemap_is_softdirty(int fd, char *start);
 78bool pagemap_is_swapped(int fd, char *start);
 79bool pagemap_is_populated(int fd, char *start);
 80unsigned long pagemap_get_pfn(int fd, char *start);
 81void clear_softdirty(void);
 82bool check_for_pattern(FILE *fp, const char *pattern, char *buf, size_t len);
 83uint64_t read_pmd_pagesize(void);
 84unsigned long rss_anon(void);
 85bool check_huge_anon(void *addr, int nr_hpages, uint64_t hpage_size);
 86bool check_huge_file(void *addr, int nr_hpages, uint64_t hpage_size);
 87bool check_huge_shmem(void *addr, int nr_hpages, uint64_t hpage_size);
 88int64_t allocate_transhuge(void *ptr, int pagemap_fd);
 89unsigned long default_huge_page_size(void);
 90int detect_hugetlb_page_sizes(size_t sizes[], int max);
 91int pageflags_get(unsigned long pfn, int kpageflags_fd, uint64_t *flags);
 92
 93int uffd_register(int uffd, void *addr, uint64_t len,
 94		  bool miss, bool wp, bool minor);
 95int uffd_unregister(int uffd, void *addr, uint64_t len);
 96int uffd_register_with_ioctls(int uffd, void *addr, uint64_t len,
 97			      bool miss, bool wp, bool minor, uint64_t *ioctls);
 98unsigned long get_free_hugepages(void);
 99bool check_vmflag_io(void *addr);
100bool check_vmflag_pfnmap(void *addr);
101bool check_vmflag_guard(void *addr);
102int open_procmap(pid_t pid, struct procmap_fd *procmap_out);
103int query_procmap(struct procmap_fd *procmap);
104bool find_vma_procmap(struct procmap_fd *procmap, void *address);
105int close_procmap(struct procmap_fd *procmap);
106int write_sysfs(const char *file_path, unsigned long val);
107int read_sysfs(const char *file_path, unsigned long *val);
108bool softdirty_supported(void);
109
110static inline int open_self_procmap(struct procmap_fd *procmap_out)
111{
112	pid_t pid = getpid();
113
114	return open_procmap(pid, procmap_out);
115}
116
117/* These helpers need to be inline to match the kselftest.h idiom. */
118static char test_name[1024];
119
120static inline void log_test_start(const char *name, ...)
121{
122	va_list args;
123	va_start(args, name);
124
125	vsnprintf(test_name, sizeof(test_name), name, args);
126	ksft_print_msg("[RUN] %s\n", test_name);
127
128	va_end(args);
129}
130
131static inline void log_test_result(int result)
132{
133	ksft_test_result_report(result, "%s\n", test_name);
134}
135
136static inline int sz2ord(size_t size, size_t pagesize)
137{
138	return __builtin_ctzll(size / pagesize);
139}
140
141void *sys_mremap(void *old_address, unsigned long old_size,
142		 unsigned long new_size, int flags, void *new_address);
143
144long ksm_get_self_zero_pages(void);
145long ksm_get_self_merging_pages(void);
146long ksm_get_full_scans(void);
147int ksm_use_zero_pages(void);
148int ksm_start(void);
149int ksm_stop(void);
150
151/*
152 * On ppc64 this will only work with radix 2M hugepage size
153 */
154#define HPAGE_SHIFT 21
155#define HPAGE_SIZE (1 << HPAGE_SHIFT)
156
157#define PAGEMAP_PRESENT(ent)	(((ent) & (1ull << 63)) != 0)
158#define PAGEMAP_PFN(ent)	((ent) & ((1ull << 55) - 1))