1/* SPDX-License-Identifier: GPL-2.0-or-later */
  2#ifndef _MEMBLOCK_TEST_H
  3#define _MEMBLOCK_TEST_H
  4
  5#include <stdlib.h>
  6#include <assert.h>
  7#include <linux/types.h>
  8#include <linux/seq_file.h>
  9#include <linux/memblock.h>
 10#include <linux/sizes.h>
 11#include <linux/printk.h>
 12#include <../selftests/kselftest.h>
 13
 14#define MEM_SIZE		SZ_32K
 15#define NUMA_NODES		8
 16
 17#define INIT_MEMBLOCK_REGIONS			128
 18#define INIT_MEMBLOCK_RESERVED_REGIONS		INIT_MEMBLOCK_REGIONS
 19
 20enum test_flags {
 21	/* No special request. */
 22	TEST_F_NONE = 0x0,
 23	/* Perform raw allocations (no zeroing of memory). */
 24	TEST_F_RAW = 0x1,
 25	/* Perform allocations on the exact node specified. */
 26	TEST_F_EXACT = 0x2
 27};
 28
 29/**
 30 * ASSERT_EQ():
 31 * Check the condition
 32 * @_expected == @_seen
 33 * If false, print failed test message (if running with --verbose) and then
 34 * assert.
 35 */
 36#define ASSERT_EQ(_expected, _seen) do { \
 37	if ((_expected) != (_seen)) \
 38		test_fail(); \
 39	assert((_expected) == (_seen)); \
 40} while (0)
 41
 42/**
 43 * ASSERT_NE():
 44 * Check the condition
 45 * @_expected != @_seen
 46 * If false, print failed test message (if running with --verbose) and then
 47 * assert.
 48 */
 49#define ASSERT_NE(_expected, _seen) do { \
 50	if ((_expected) == (_seen)) \
 51		test_fail(); \
 52	assert((_expected) != (_seen)); \
 53} while (0)
 54
 55/**
 56 * ASSERT_LT():
 57 * Check the condition
 58 * @_expected < @_seen
 59 * If false, print failed test message (if running with --verbose) and then
 60 * assert.
 61 */
 62#define ASSERT_LT(_expected, _seen) do { \
 63	if ((_expected) >= (_seen)) \
 64		test_fail(); \
 65	assert((_expected) < (_seen)); \
 66} while (0)
 67
 68/**
 69 * ASSERT_LE():
 70 * Check the condition
 71 * @_expected <= @_seen
 72 * If false, print failed test message (if running with --verbose) and then
 73 * assert.
 74 */
 75#define ASSERT_LE(_expected, _seen) do { \
 76	if ((_expected) > (_seen)) \
 77		test_fail(); \
 78	assert((_expected) <= (_seen)); \
 79} while (0)
 80
 81/**
 82 * ASSERT_MEM_EQ():
 83 * Check that the first @_size bytes of @_seen are all equal to @_expected.
 84 * If false, print failed test message (if running with --verbose) and then
 85 * assert.
 86 */
 87#define ASSERT_MEM_EQ(_seen, _expected, _size) do { \
 88	for (int _i = 0; _i < (_size); _i++) { \
 89		ASSERT_EQ(((char *)_seen)[_i], (_expected)); \
 90	} \
 91} while (0)
 92
 93/**
 94 * ASSERT_MEM_NE():
 95 * Check that none of the first @_size bytes of @_seen are equal to @_expected.
 96 * If false, print failed test message (if running with --verbose) and then
 97 * assert.
 98 */
 99#define ASSERT_MEM_NE(_seen, _expected, _size) do { \
100	for (int _i = 0; _i < (_size); _i++) { \
101		ASSERT_NE(((char *)_seen)[_i], (_expected)); \
102	} \
103} while (0)
104
105#define PREFIX_PUSH() prefix_push(__func__)
106
107/*
108 * Available memory registered with memblock needs to be valid for allocs
109 * test to run. This is a convenience wrapper for memory allocated in
110 * dummy_physical_memory_init() that is later registered with memblock
111 * in setup_memblock().
112 */
113struct test_memory {
114	void *base;
115};
116
117struct region {
118	phys_addr_t base;
119	phys_addr_t size;
120};
121
122static inline phys_addr_t __maybe_unused region_end(struct memblock_region *rgn)
123{
124	return rgn->base + rgn->size;
125}
126
127void reset_memblock_regions(void);
128void reset_memblock_attributes(void);
129void setup_memblock(void);
130void setup_numa_memblock(const unsigned int node_fracs[]);
131void dummy_physical_memory_init(void);
132void dummy_physical_memory_cleanup(void);
133phys_addr_t dummy_physical_memory_base(void);
134void parse_args(int argc, char **argv);
135
136void test_fail(void);
137void test_pass(void);
138void test_print(const char *fmt, ...);
139void prefix_reset(void);
140void prefix_push(const char *prefix);
141void prefix_pop(void);
142
143static inline void test_pass_pop(void)
144{
145	test_pass();
146	prefix_pop();
147}
148
149static inline void run_top_down(int (*func)())
150{
151	memblock_set_bottom_up(false);
152	prefix_push("top-down");
153	func();
154	prefix_pop();
155}
156
157static inline void run_bottom_up(int (*func)())
158{
159	memblock_set_bottom_up(true);
160	prefix_push("bottom-up");
161	func();
162	prefix_pop();
163}
164
165static inline void assert_mem_content(void *mem, int size, int flags)
166{
167	if (flags & TEST_F_RAW)
168		ASSERT_MEM_NE(mem, 0, size);
169	else
170		ASSERT_MEM_EQ(mem, 0, size);
171}
172
173#endif