Commit | Line | Data |
---|---|---|
7a338472 | 1 | /* SPDX-License-Identifier: GPL-2.0-only */ |
783e9e51 PB |
2 | /* |
3 | * tools/testing/selftests/kvm/include/test_util.h | |
4 | * | |
5 | * Copyright (C) 2018, Google LLC. | |
783e9e51 PB |
6 | */ |
7 | ||
cc68765d AJ |
8 | #ifndef SELFTEST_KVM_TEST_UTIL_H |
9 | #define SELFTEST_KVM_TEST_UTIL_H | |
783e9e51 PB |
10 | |
11 | #include <stdlib.h> | |
12 | #include <stdarg.h> | |
13 | #include <stdbool.h> | |
14 | #include <stdio.h> | |
15 | #include <string.h> | |
16 | #include <inttypes.h> | |
17 | #include <errno.h> | |
18 | #include <unistd.h> | |
19 | #include <fcntl.h> | |
33090a88 | 20 | #include <sys/mman.h> |
bcb2b94a | 21 | #include "kselftest.h" |
783e9e51 | 22 | |
c20dd9e0 HX |
23 | #define msecs_to_usecs(msec) ((msec) * 1000ULL) |
24 | ||
3439d886 AJ |
25 | static inline int _no_printf(const char *format, ...) { return 0; } |
26 | ||
27 | #ifdef DEBUG | |
28 | #define pr_debug(...) printf(__VA_ARGS__) | |
29 | #else | |
30 | #define pr_debug(...) _no_printf(__VA_ARGS__) | |
31 | #endif | |
32 | #ifndef QUIET | |
33 | #define pr_info(...) printf(__VA_ARGS__) | |
34 | #else | |
35 | #define pr_info(...) _no_printf(__VA_ARGS__) | |
36 | #endif | |
37 | ||
07bd3c38 | 38 | void __printf(1, 2) print_skip(const char *fmt, ...); |
5321270b SC |
39 | #define __TEST_REQUIRE(f, fmt, ...) \ |
40 | do { \ | |
41 | if (!(f)) \ | |
42 | ksft_exit_skip("- " fmt "\n", ##__VA_ARGS__); \ | |
7ed397d1 SC |
43 | } while (0) |
44 | ||
45 | #define TEST_REQUIRE(f) __TEST_REQUIRE(f, "Requirement not met: %s", #f) | |
d0aac332 | 46 | |
783e9e51 PB |
47 | ssize_t test_write(int fd, const void *buf, size_t count); |
48 | ssize_t test_read(int fd, void *buf, size_t count); | |
49 | int test_seq_read(const char *path, char **bufp, size_t *sizep); | |
50 | ||
07bd3c38 MWR |
51 | void __printf(5, 6) test_assert(bool exp, const char *exp_str, |
52 | const char *file, unsigned int line, | |
53 | const char *fmt, ...); | |
783e9e51 | 54 | |
783e9e51 PB |
55 | #define TEST_ASSERT(e, fmt, ...) \ |
56 | test_assert((e), #e, __FILE__, __LINE__, fmt, ##__VA_ARGS__) | |
57 | ||
b145c58d SC |
58 | #define TEST_ASSERT_EQ(a, b) \ |
59 | do { \ | |
60 | typeof(a) __a = (a); \ | |
61 | typeof(b) __b = (b); \ | |
62 | test_assert(__a == __b, #a " == " #b, __FILE__, __LINE__, \ | |
63 | "%#lx != %#lx (%s != %s)", \ | |
64 | (unsigned long)(__a), (unsigned long)(__b), #a, #b);\ | |
783e9e51 PB |
65 | } while (0) |
66 | ||
c96f57b0 VS |
67 | #define TEST_ASSERT_KVM_EXIT_REASON(vcpu, expected) do { \ |
68 | __u32 exit_reason = (vcpu)->run->exit_reason; \ | |
69 | \ | |
70 | TEST_ASSERT(exit_reason == (expected), \ | |
6f974494 VS |
71 | "Wanted KVM exit reason: %u (%s), got: %u (%s)", \ |
72 | (expected), exit_reason_str((expected)), \ | |
c96f57b0 VS |
73 | exit_reason, exit_reason_str(exit_reason)); \ |
74 | } while (0) | |
75 | ||
62ece2c5 DM |
76 | #define TEST_FAIL(fmt, ...) do { \ |
77 | TEST_ASSERT(false, fmt, ##__VA_ARGS__); \ | |
78 | __builtin_unreachable(); \ | |
79 | } while (0) | |
a46f8a63 | 80 | |
af99e1ad BG |
81 | size_t parse_size(const char *size); |
82 | ||
f09205b9 | 83 | int64_t timespec_to_ns(struct timespec ts); |
94c4b76b | 84 | struct timespec timespec_add_ns(struct timespec ts, int64_t ns); |
bfcaa849 AJ |
85 | struct timespec timespec_add(struct timespec ts1, struct timespec ts2); |
86 | struct timespec timespec_sub(struct timespec ts1, struct timespec ts2); | |
f9224a52 | 87 | struct timespec timespec_elapsed(struct timespec start); |
4fd94ec7 | 88 | struct timespec timespec_div(struct timespec ts, int divisor); |
f09205b9 | 89 | |
b31f21a7 CL |
90 | struct guest_random_state { |
91 | uint32_t seed; | |
92 | }; | |
93 | ||
cb6c6914 SC |
94 | extern uint32_t guest_random_seed; |
95 | extern struct guest_random_state guest_rng; | |
96 | ||
b31f21a7 CL |
97 | struct guest_random_state new_guest_random_state(uint32_t seed); |
98 | uint32_t guest_random_u32(struct guest_random_state *state); | |
99 | ||
cb6c6914 SC |
100 | static inline uint64_t guest_random_u64(struct guest_random_state *state) |
101 | { | |
102 | return ((uint64_t)guest_random_u32(state) << 32) | guest_random_u32(state); | |
103 | } | |
104 | ||
9e965bb7 BG |
105 | enum vm_mem_backing_src_type { |
106 | VM_MEM_SRC_ANONYMOUS, | |
107 | VM_MEM_SRC_ANONYMOUS_THP, | |
108 | VM_MEM_SRC_ANONYMOUS_HUGETLB, | |
623653b7 YW |
109 | VM_MEM_SRC_ANONYMOUS_HUGETLB_16KB, |
110 | VM_MEM_SRC_ANONYMOUS_HUGETLB_64KB, | |
111 | VM_MEM_SRC_ANONYMOUS_HUGETLB_512KB, | |
112 | VM_MEM_SRC_ANONYMOUS_HUGETLB_1MB, | |
113 | VM_MEM_SRC_ANONYMOUS_HUGETLB_2MB, | |
114 | VM_MEM_SRC_ANONYMOUS_HUGETLB_8MB, | |
115 | VM_MEM_SRC_ANONYMOUS_HUGETLB_16MB, | |
116 | VM_MEM_SRC_ANONYMOUS_HUGETLB_32MB, | |
117 | VM_MEM_SRC_ANONYMOUS_HUGETLB_256MB, | |
118 | VM_MEM_SRC_ANONYMOUS_HUGETLB_512MB, | |
119 | VM_MEM_SRC_ANONYMOUS_HUGETLB_1GB, | |
120 | VM_MEM_SRC_ANONYMOUS_HUGETLB_2GB, | |
121 | VM_MEM_SRC_ANONYMOUS_HUGETLB_16GB, | |
c9befd59 | 122 | VM_MEM_SRC_SHMEM, |
33090a88 | 123 | VM_MEM_SRC_SHARED_HUGETLB, |
623653b7 | 124 | NUM_SRC_TYPES, |
9e965bb7 BG |
125 | }; |
126 | ||
9f2fc555 DM |
127 | #define DEFAULT_VM_MEM_SRC VM_MEM_SRC_ANONYMOUS |
128 | ||
9e965bb7 BG |
129 | struct vm_mem_backing_src_alias { |
130 | const char *name; | |
623653b7 | 131 | uint32_t flag; |
9e965bb7 BG |
132 | }; |
133 | ||
f5013d41 SK |
134 | #define MIN_RUN_DELAY_NS 200000UL |
135 | ||
3b70c4d1 YW |
136 | bool thp_configured(void); |
137 | size_t get_trans_hugepagesz(void); | |
5579fa68 | 138 | size_t get_def_hugetlb_pagesz(void); |
623653b7 YW |
139 | const struct vm_mem_backing_src_alias *vm_mem_backing_src_alias(uint32_t i); |
140 | size_t get_backing_src_pagesz(uint32_t i); | |
f4870ef3 | 141 | bool is_backing_src_hugetlb(uint32_t i); |
9f2fc555 | 142 | void backing_src_help(const char *flag); |
9e965bb7 | 143 | enum vm_mem_backing_src_type parse_backing_src_type(const char *type_name); |
20175d5e | 144 | long get_run_delay(void); |
9e965bb7 | 145 | |
33090a88 AR |
146 | /* |
147 | * Whether or not the given source type is shared memory (as opposed to | |
148 | * anonymous). | |
149 | */ | |
150 | static inline bool backing_src_is_shared(enum vm_mem_backing_src_type t) | |
151 | { | |
152 | return vm_mem_backing_src_alias(t)->flag & MAP_SHARED; | |
153 | } | |
154 | ||
bb2968ad SC |
155 | static inline bool backing_src_can_be_huge(enum vm_mem_backing_src_type t) |
156 | { | |
157 | return t != VM_MEM_SRC_ANONYMOUS && t != VM_MEM_SRC_SHMEM; | |
158 | } | |
159 | ||
c071ff41 SC |
160 | /* Aligns x up to the next multiple of size. Size must be a power of 2. */ |
161 | static inline uint64_t align_up(uint64_t x, uint64_t size) | |
162 | { | |
163 | uint64_t mask = size - 1; | |
164 | ||
165 | TEST_ASSERT(size != 0 && !(size & (size - 1)), | |
166 | "size not a power of 2: %lu", size); | |
167 | return ((x + mask) & ~mask); | |
168 | } | |
169 | ||
170 | static inline uint64_t align_down(uint64_t x, uint64_t size) | |
171 | { | |
172 | uint64_t x_aligned_up = align_up(x, size); | |
173 | ||
174 | if (x == x_aligned_up) | |
175 | return x; | |
176 | else | |
177 | return x_aligned_up - size; | |
178 | } | |
179 | ||
180 | static inline void *align_ptr_up(void *x, size_t size) | |
181 | { | |
182 | return (void *)align_up((unsigned long)x, size); | |
183 | } | |
184 | ||
018ea2d7 VS |
185 | int atoi_paranoid(const char *num_str); |
186 | ||
0001725d VS |
187 | static inline uint32_t atoi_positive(const char *name, const char *num_str) |
188 | { | |
189 | int num = atoi_paranoid(num_str); | |
190 | ||
191 | TEST_ASSERT(num > 0, "%s must be greater than 0, got '%s'", name, num_str); | |
192 | return num; | |
193 | } | |
194 | ||
195 | static inline uint32_t atoi_non_negative(const char *name, const char *num_str) | |
196 | { | |
197 | int num = atoi_paranoid(num_str); | |
198 | ||
199 | TEST_ASSERT(num >= 0, "%s must be non-negative, got '%s'", name, num_str); | |
200 | return num; | |
201 | } | |
202 | ||
e5119382 | 203 | int guest_vsnprintf(char *buf, int n, const char *fmt, va_list args); |
1b2658e4 | 204 | __printf(3, 4) int guest_snprintf(char *buf, int n, const char *fmt, ...); |
e5119382 | 205 | |
dfaf20af AJ |
206 | char *strdup_printf(const char *fmt, ...) __attribute__((format(printf, 1, 2), nonnull(1))); |
207 | ||
e440c5f2 VK |
208 | char *sys_get_cur_clocksource(void); |
209 | ||
cc68765d | 210 | #endif /* SELFTEST_KVM_TEST_UTIL_H */ |