Commit 39f1c201 authored by Paolo Bonzini's avatar Paolo Bonzini
Browse files

Merge tag 'kvm-x86-selftests_kernel_types-7.1' of https://github.com/kvm-x86/linux into HEAD 

KVM selftests type renames for 7.1

Renames types across all KVM selftests to more closely align with types used
in the kernel:

  vm_vaddr_t -> gva_t
  vm_paddr_t -> gpa_t

  uint64_t -> u64
  uint32_t -> u32
  uint16_t -> u16
  uint8_t  -> u8

  int64_t -> s64
  int32_t -> s32
  int16_t -> s16
  int8_t  -> s8

Using the kernel's preferred types eliminates a source of friction for many
contributors, as the majority of KVM selftests contributions come from kernel
developers.  The kernel names are also shorter, which allows for more concise
code, and in any many cases eliminates newlines thanks to shorter types and
parameter names.

Rename variables and parameters as well as types, e.g. gpa instead of paddr,
to again align with the kernel, and in a few cases to remove ambiguity, e.g.
where paddr is used to refer to a _host_ physical address.
parents 909eac68 dfd2a8b0

tools/testing/selftests/kvm/access_tracking_perf_test.c

+22 −22
Original line number Diff line number Diff line
@@ -101,15 +101,15 @@ struct test_params { 
	enum vm_mem_backing_src_type backing_src;



	/* The amount of memory to allocate for each vCPU. */

	uint64_t vcpu_memory_bytes;

	u64 vcpu_memory_bytes;



	/* The number of vCPUs to create in the VM. */

	int nr_vcpus;

};



static uint64_t pread_uint64(int fd, const char *filename, uint64_t index)

static u64 pread_u64(int fd, const char *filename, u64 index)

{

	uint64_t value;

	u64 value;

	off_t offset = index * sizeof(value);



	TEST_ASSERT(pread(fd, &value, sizeof(value), offset) == sizeof(value),
@@ -123,13 +123,13 @@ static uint64_t pread_uint64(int fd, const char *filename, uint64_t index) 
#define PAGEMAP_PRESENT (1ULL << 63)

#define PAGEMAP_PFN_MASK ((1ULL << 55) - 1)



static uint64_t lookup_pfn(int pagemap_fd, struct kvm_vm *vm, uint64_t gva)

static u64 lookup_pfn(int pagemap_fd, struct kvm_vm *vm, gva_t gva)

{

	uint64_t hva = (uint64_t) addr_gva2hva(vm, gva);

	uint64_t entry;

	uint64_t pfn;

	u64 hva = (u64)addr_gva2hva(vm, gva);

	u64 entry;

	u64 pfn;



	entry = pread_uint64(pagemap_fd, "pagemap", hva / getpagesize());

	entry = pread_u64(pagemap_fd, "pagemap", hva / getpagesize());

	if (!(entry & PAGEMAP_PRESENT))

		return 0;
@@ -139,16 +139,16 @@ static uint64_t lookup_pfn(int pagemap_fd, struct kvm_vm *vm, uint64_t gva) 
	return pfn;

}



static bool is_page_idle(int page_idle_fd, uint64_t pfn)

static bool is_page_idle(int page_idle_fd, u64 pfn)

{

	uint64_t bits = pread_uint64(page_idle_fd, "page_idle", pfn / 64);

	u64 bits = pread_u64(page_idle_fd, "page_idle", pfn / 64);



	return !!((bits >> (pfn % 64)) & 1);

}



static void mark_page_idle(int page_idle_fd, uint64_t pfn)

static void mark_page_idle(int page_idle_fd, u64 pfn)

{

	uint64_t bits = 1ULL << (pfn % 64);

	u64 bits = 1ULL << (pfn % 64);



	TEST_ASSERT(pwrite(page_idle_fd, &bits, 8, 8 * (pfn / 64)) == 8,

		    "Set page_idle bits for PFN 0x%" PRIx64, pfn);
@@ -174,11 +174,11 @@ static void pageidle_mark_vcpu_memory_idle(struct kvm_vm *vm, 
					   struct memstress_vcpu_args *vcpu_args)

{

	int vcpu_idx = vcpu_args->vcpu_idx;

	uint64_t base_gva = vcpu_args->gva;

	uint64_t pages = vcpu_args->pages;

	uint64_t page;

	uint64_t still_idle = 0;

	uint64_t no_pfn = 0;

	gva_t base_gva = vcpu_args->gva;

	u64 pages = vcpu_args->pages;

	u64 page;

	u64 still_idle = 0;

	u64 no_pfn = 0;

	int page_idle_fd;

	int pagemap_fd;
@@ -193,8 +193,8 @@ static void pageidle_mark_vcpu_memory_idle(struct kvm_vm *vm, 
	TEST_ASSERT(pagemap_fd > 0, "Failed to open pagemap.");



	for (page = 0; page < pages; page++) {

		uint64_t gva = base_gva + page * memstress_args.guest_page_size;

		uint64_t pfn = lookup_pfn(pagemap_fd, vm, gva);

		gva_t gva = base_gva + page * memstress_args.guest_page_size;

		u64 pfn = lookup_pfn(pagemap_fd, vm, gva);



		if (!pfn) {

			no_pfn++;
@@ -297,10 +297,10 @@ static void lru_gen_mark_memory_idle(struct kvm_vm *vm) 
	lru_gen_last_gen = new_gen;

}



static void assert_ucall(struct kvm_vcpu *vcpu, uint64_t expected_ucall)

static void assert_ucall(struct kvm_vcpu *vcpu, u64 expected_ucall)

{

	struct ucall uc;

	uint64_t actual_ucall = get_ucall(vcpu, &uc);

	u64 actual_ucall = get_ucall(vcpu, &uc);



	TEST_ASSERT(expected_ucall == actual_ucall,

		    "Guest exited unexpectedly (expected ucall %" PRIu64
@@ -417,7 +417,7 @@ static void run_test(enum vm_guest_mode mode, void *arg) 
	 */

	test_pages = params->nr_vcpus * params->vcpu_memory_bytes /

		      max(memstress_args.guest_page_size,

			  (uint64_t)getpagesize());

			  (u64)getpagesize());



	memstress_start_vcpu_threads(nr_vcpus, vcpu_thread_main);

tools/testing/selftests/kvm/arch_timer.c

+3 −3
Original line number Diff line number Diff line
@@ -78,9 +78,9 @@ static void *test_vcpu_run(void *arg) 
	return NULL;

}



static uint32_t test_get_pcpu(void)

static u32 test_get_pcpu(void)

{

	uint32_t pcpu;

	u32 pcpu;

	unsigned int nproc_conf;

	cpu_set_t online_cpuset;
@@ -98,7 +98,7 @@ static uint32_t test_get_pcpu(void) 
static int test_migrate_vcpu(unsigned int vcpu_idx)

{

	int ret;

	uint32_t new_pcpu = test_get_pcpu();

	u32 new_pcpu = test_get_pcpu();



	pr_debug("Migrating vCPU: %u to pCPU: %u\n", vcpu_idx, new_pcpu);

tools/testing/selftests/kvm/arm64/aarch32_id_regs.c

+7 −7
Original line number Diff line number Diff line
@@ -66,7 +66,7 @@ static void test_guest_raz(struct kvm_vcpu *vcpu) 
	}

}



static uint64_t raz_wi_reg_ids[] = {

static u64 raz_wi_reg_ids[] = {

	KVM_ARM64_SYS_REG(SYS_ID_PFR0_EL1),

	KVM_ARM64_SYS_REG(SYS_ID_PFR1_EL1),

	KVM_ARM64_SYS_REG(SYS_ID_DFR0_EL1),
@@ -94,8 +94,8 @@ static void test_user_raz_wi(struct kvm_vcpu *vcpu) 
	int i;



	for (i = 0; i < ARRAY_SIZE(raz_wi_reg_ids); i++) {

		uint64_t reg_id = raz_wi_reg_ids[i];

		uint64_t val;

		u64 reg_id = raz_wi_reg_ids[i];

		u64 val;



		val = vcpu_get_reg(vcpu, reg_id);

		TEST_ASSERT_EQ(val, 0);
@@ -111,7 +111,7 @@ static void test_user_raz_wi(struct kvm_vcpu *vcpu) 
	}

}



static uint64_t raz_invariant_reg_ids[] = {

static u64 raz_invariant_reg_ids[] = {

	KVM_ARM64_SYS_REG(SYS_ID_AFR0_EL1),

	KVM_ARM64_SYS_REG(sys_reg(3, 0, 0, 3, 3)),

	KVM_ARM64_SYS_REG(SYS_ID_DFR1_EL1),
@@ -123,8 +123,8 @@ static void test_user_raz_invariant(struct kvm_vcpu *vcpu) 
	int i, r;



	for (i = 0; i < ARRAY_SIZE(raz_invariant_reg_ids); i++) {

		uint64_t reg_id = raz_invariant_reg_ids[i];

		uint64_t val;

		u64 reg_id = raz_invariant_reg_ids[i];

		u64 val;



		val = vcpu_get_reg(vcpu, reg_id);

		TEST_ASSERT_EQ(val, 0);
@@ -142,7 +142,7 @@ static void test_user_raz_invariant(struct kvm_vcpu *vcpu) 


static bool vcpu_aarch64_only(struct kvm_vcpu *vcpu)

{

	uint64_t val, el0;

	u64 val, el0;



	val = vcpu_get_reg(vcpu, KVM_ARM64_SYS_REG(SYS_ID_AA64PFR0_EL1));

tools/testing/selftests/kvm/arm64/arch_timer.c

+4 −4
Original line number Diff line number Diff line
@@ -56,7 +56,7 @@ static void guest_validate_irq(unsigned int intid, 
				struct test_vcpu_shared_data *shared_data)

{

	enum guest_stage stage = shared_data->guest_stage;

	uint64_t xcnt = 0, xcnt_diff_us, cval = 0;

	u64 xcnt = 0, xcnt_diff_us, cval = 0;

	unsigned long xctl = 0;

	unsigned int timer_irq = 0;

	unsigned int accessor;
@@ -105,7 +105,7 @@ static void guest_validate_irq(unsigned int intid, 
static void guest_irq_handler(struct ex_regs *regs)

{

	unsigned int intid = gic_get_and_ack_irq();

	uint32_t cpu = guest_get_vcpuid();

	u32 cpu = guest_get_vcpuid();

	struct test_vcpu_shared_data *shared_data = &vcpu_shared_data[cpu];



	guest_validate_irq(intid, shared_data);
@@ -116,7 +116,7 @@ static void guest_irq_handler(struct ex_regs *regs) 
static void guest_run_stage(struct test_vcpu_shared_data *shared_data,

				enum guest_stage stage)

{

	uint32_t irq_iter, config_iter;

	u32 irq_iter, config_iter;



	shared_data->guest_stage = stage;

	shared_data->nr_iter = 0;
@@ -140,7 +140,7 @@ static void guest_run_stage(struct test_vcpu_shared_data *shared_data, 


static void guest_code(void)

{

	uint32_t cpu = guest_get_vcpuid();

	u32 cpu = guest_get_vcpuid();

	struct test_vcpu_shared_data *shared_data = &vcpu_shared_data[cpu];



	local_irq_disable();

tools/testing/selftests/kvm/arm64/arch_timer_edge_cases.c

+80 −81
Original line number Diff line number Diff line
@@ -23,25 +23,25 @@ 
#include "vgic.h"



/* Depends on counter width. */

static uint64_t CVAL_MAX;

static u64 CVAL_MAX;

/* tval is a signed 32-bit int. */

static const int32_t TVAL_MAX = INT32_MAX;

static const int32_t TVAL_MIN = INT32_MIN;

static const s32 TVAL_MAX = INT32_MAX;

static const s32 TVAL_MIN = INT32_MIN;



/* After how much time we say there is no IRQ. */

static const uint32_t TIMEOUT_NO_IRQ_US = 50000;

static const u32 TIMEOUT_NO_IRQ_US = 50000;



/* Counter value to use as the starting one for most tests. Set to CVAL_MAX/2 */

static uint64_t DEF_CNT;

static u64 DEF_CNT;



/* Number of runs. */

static const uint32_t NR_TEST_ITERS_DEF = 5;

static const u32 NR_TEST_ITERS_DEF = 5;



/* Default wait test time in ms. */

static const uint32_t WAIT_TEST_MS = 10;

static const u32 WAIT_TEST_MS = 10;



/* Default "long" wait test time in ms. */

static const uint32_t LONG_WAIT_TEST_MS = 100;

static const u32 LONG_WAIT_TEST_MS = 100;



/* Shared with IRQ handler. */

struct test_vcpu_shared_data {
@@ -53,9 +53,9 @@ struct test_args { 
	/* Virtual or physical timer and counter tests. */

	enum arch_timer timer;

	/* Delay used for most timer tests. */

	uint64_t wait_ms;

	u64 wait_ms;

	/* Delay used in the test_long_timer_delays test. */

	uint64_t long_wait_ms;

	u64 long_wait_ms;

	/* Number of iterations. */

	int iterations;

	/* Whether to test the physical timer. */
@@ -82,12 +82,12 @@ enum sync_cmd { 
	NO_USERSPACE_CMD,

};



typedef void (*sleep_method_t)(enum arch_timer timer, uint64_t usec);

typedef void (*sleep_method_t)(enum arch_timer timer, u64 usec);



static void sleep_poll(enum arch_timer timer, uint64_t usec);

static void sleep_sched_poll(enum arch_timer timer, uint64_t usec);

static void sleep_in_userspace(enum arch_timer timer, uint64_t usec);

static void sleep_migrate(enum arch_timer timer, uint64_t usec);

static void sleep_poll(enum arch_timer timer, u64 usec);

static void sleep_sched_poll(enum arch_timer timer, u64 usec);

static void sleep_in_userspace(enum arch_timer timer, u64 usec);

static void sleep_migrate(enum arch_timer timer, u64 usec);



sleep_method_t sleep_method[] = {

	sleep_poll,
@@ -115,14 +115,14 @@ enum timer_view { 
	TIMER_TVAL,

};



static void assert_irqs_handled(uint32_t n)

static void assert_irqs_handled(u32 n)

{

	int h = atomic_read(&shared_data.handled);



	__GUEST_ASSERT(h == n, "Handled %d IRQS but expected %d", h, n);

}



static void userspace_cmd(uint64_t cmd)

static void userspace_cmd(u64 cmd)

{

	GUEST_SYNC_ARGS(cmd, 0, 0, 0, 0);

}
@@ -132,12 +132,12 @@ static void userspace_migrate_vcpu(void) 
	userspace_cmd(USERSPACE_MIGRATE_SELF);

}



static void userspace_sleep(uint64_t usecs)

static void userspace_sleep(u64 usecs)

{

	GUEST_SYNC_ARGS(USERSPACE_USLEEP, usecs, 0, 0, 0);

}



static void set_counter(enum arch_timer timer, uint64_t counter)

static void set_counter(enum arch_timer timer, u64 counter)

{

	GUEST_SYNC_ARGS(SET_COUNTER_VALUE, counter, timer, 0, 0);

}
@@ -146,8 +146,8 @@ static void guest_irq_handler(struct ex_regs *regs) 
{

	unsigned int intid = gic_get_and_ack_irq();

	enum arch_timer timer;

	uint64_t cnt, cval;

	uint32_t ctl;

	u64 cnt, cval;

	u32 ctl;

	bool timer_condition, istatus;



	if (intid == IAR_SPURIOUS) {
@@ -178,8 +178,8 @@ static void guest_irq_handler(struct ex_regs *regs) 
	gic_set_eoi(intid);

}



static void set_cval_irq(enum arch_timer timer, uint64_t cval_cycles,

			 uint32_t ctl)

static void set_cval_irq(enum arch_timer timer, u64 cval_cycles,

			 u32 ctl)

{

	atomic_set(&shared_data.handled, 0);

	atomic_set(&shared_data.spurious, 0);
@@ -187,8 +187,8 @@ static void set_cval_irq(enum arch_timer timer, uint64_t cval_cycles, 
	timer_set_ctl(timer, ctl);

}



static void set_tval_irq(enum arch_timer timer, uint64_t tval_cycles,

			 uint32_t ctl)

static void set_tval_irq(enum arch_timer timer, u64 tval_cycles,

			 u32 ctl)

{

	atomic_set(&shared_data.handled, 0);

	atomic_set(&shared_data.spurious, 0);
@@ -196,7 +196,7 @@ static void set_tval_irq(enum arch_timer timer, uint64_t tval_cycles, 
	timer_set_ctl(timer, ctl);

}



static void set_xval_irq(enum arch_timer timer, uint64_t xval, uint32_t ctl,

static void set_xval_irq(enum arch_timer timer, u64 xval, u32 ctl,

			 enum timer_view tv)

{

	switch (tv) {
@@ -275,13 +275,13 @@ static void wait_migrate_poll_for_irq(void) 
 * Sleep for usec microseconds by polling in the guest or in

 * userspace (e.g. userspace_cmd=USERSPACE_SCHEDULE).

 */

static void guest_poll(enum arch_timer test_timer, uint64_t usec,

static void guest_poll(enum arch_timer test_timer, u64 usec,

		       enum sync_cmd usp_cmd)

{

	uint64_t cycles = usec_to_cycles(usec);

	u64 cycles = usec_to_cycles(usec);

	/* Whichever timer we are testing with, sleep with the other. */

	enum arch_timer sleep_timer = 1 - test_timer;

	uint64_t start = timer_get_cntct(sleep_timer);

	u64 start = timer_get_cntct(sleep_timer);



	while ((timer_get_cntct(sleep_timer) - start) < cycles) {

		if (usp_cmd == NO_USERSPACE_CMD)
@@ -291,22 +291,22 @@ static void guest_poll(enum arch_timer test_timer, uint64_t usec, 
	}

}



static void sleep_poll(enum arch_timer timer, uint64_t usec)

static void sleep_poll(enum arch_timer timer, u64 usec)

{

	guest_poll(timer, usec, NO_USERSPACE_CMD);

}



static void sleep_sched_poll(enum arch_timer timer, uint64_t usec)

static void sleep_sched_poll(enum arch_timer timer, u64 usec)

{

	guest_poll(timer, usec, USERSPACE_SCHED_YIELD);

}



static void sleep_migrate(enum arch_timer timer, uint64_t usec)

static void sleep_migrate(enum arch_timer timer, u64 usec)

{

	guest_poll(timer, usec, USERSPACE_MIGRATE_SELF);

}



static void sleep_in_userspace(enum arch_timer timer, uint64_t usec)

static void sleep_in_userspace(enum arch_timer timer, u64 usec)

{

	userspace_sleep(usec);

}
@@ -315,15 +315,15 @@ static void sleep_in_userspace(enum arch_timer timer, uint64_t usec) 
 * Reset the timer state to some nice values like the counter not being close

 * to the edge, and the control register masked and disabled.

 */

static void reset_timer_state(enum arch_timer timer, uint64_t cnt)

static void reset_timer_state(enum arch_timer timer, u64 cnt)

{

	set_counter(timer, cnt);

	timer_set_ctl(timer, CTL_IMASK);

}



static void test_timer_xval(enum arch_timer timer, uint64_t xval,

static void test_timer_xval(enum arch_timer timer, u64 xval,

			    enum timer_view tv, irq_wait_method_t wm, bool reset_state,

			    uint64_t reset_cnt)

			    u64 reset_cnt)

{

	local_irq_disable();
@@ -348,23 +348,23 @@ static void test_timer_xval(enum arch_timer timer, uint64_t xval, 
 * the "runner", like: tools/testing/selftests/kselftest/runner.sh.

 */



static void test_timer_cval(enum arch_timer timer, uint64_t cval,

static void test_timer_cval(enum arch_timer timer, u64 cval,

			    irq_wait_method_t wm, bool reset_state,

			    uint64_t reset_cnt)

			    u64 reset_cnt)

{

	test_timer_xval(timer, cval, TIMER_CVAL, wm, reset_state, reset_cnt);

}



static void test_timer_tval(enum arch_timer timer, int32_t tval,

static void test_timer_tval(enum arch_timer timer, s32 tval,

			    irq_wait_method_t wm, bool reset_state,

			    uint64_t reset_cnt)

			    u64 reset_cnt)

{

	test_timer_xval(timer, (uint64_t) tval, TIMER_TVAL, wm, reset_state,

	test_timer_xval(timer, (u64)tval, TIMER_TVAL, wm, reset_state,

			reset_cnt);

}



static void test_xval_check_no_irq(enum arch_timer timer, uint64_t xval,

				   uint64_t usec, enum timer_view timer_view,

static void test_xval_check_no_irq(enum arch_timer timer, u64 xval,

				   u64 usec, enum timer_view timer_view,

				   sleep_method_t guest_sleep)

{

	local_irq_disable();
@@ -379,17 +379,17 @@ static void test_xval_check_no_irq(enum arch_timer timer, uint64_t xval, 
	assert_irqs_handled(0);

}



static void test_cval_no_irq(enum arch_timer timer, uint64_t cval,

			     uint64_t usec, sleep_method_t wm)

static void test_cval_no_irq(enum arch_timer timer, u64 cval,

			     u64 usec, sleep_method_t wm)

{

	test_xval_check_no_irq(timer, cval, usec, TIMER_CVAL, wm);

}



static void test_tval_no_irq(enum arch_timer timer, int32_t tval, uint64_t usec,

static void test_tval_no_irq(enum arch_timer timer, s32 tval, u64 usec,

			     sleep_method_t wm)

{

	/* tval will be cast to an int32_t in test_xval_check_no_irq */

	test_xval_check_no_irq(timer, (uint64_t) tval, usec, TIMER_TVAL, wm);

	/* tval will be cast to an s32 in test_xval_check_no_irq */

	test_xval_check_no_irq(timer, (u64)tval, usec, TIMER_TVAL, wm);

}



/* Test masking/unmasking a timer using the timer mask (not the IRQ mask). */
@@ -463,7 +463,7 @@ static void test_timers_fired_multiple_times(enum arch_timer timer) 
 * timeout for the wait: we use the wfi instruction.

 */

static void test_reprogramming_timer(enum arch_timer timer, irq_wait_method_t wm,

				     int32_t delta_1_ms, int32_t delta_2_ms)

				     s32 delta_1_ms, s32 delta_2_ms)

{

	local_irq_disable();

	reset_timer_state(timer, DEF_CNT);
@@ -488,7 +488,7 @@ static void test_reprogramming_timer(enum arch_timer timer, irq_wait_method_t wm 
static void test_reprogram_timers(enum arch_timer timer)

{

	int i;

	uint64_t base_wait = test_args.wait_ms;

	u64 base_wait = test_args.wait_ms;



	for (i = 0; i < ARRAY_SIZE(irq_wait_method); i++) {

		/*
@@ -504,8 +504,8 @@ static void test_reprogram_timers(enum arch_timer timer) 


static void test_basic_functionality(enum arch_timer timer)

{

	int32_t tval = (int32_t) msec_to_cycles(test_args.wait_ms);

	uint64_t cval = DEF_CNT + msec_to_cycles(test_args.wait_ms);

	s32 tval = (s32)msec_to_cycles(test_args.wait_ms);

	u64 cval = DEF_CNT + msec_to_cycles(test_args.wait_ms);

	int i;



	for (i = 0; i < ARRAY_SIZE(irq_wait_method); i++) {
@@ -593,7 +593,7 @@ static void test_set_cnt_after_tval_max(enum arch_timer timer, irq_wait_method_t 
	reset_timer_state(timer, DEF_CNT);



	set_cval_irq(timer,

		     (uint64_t) TVAL_MAX +

		     (u64)TVAL_MAX +

		     msec_to_cycles(test_args.wait_ms) / 2, CTL_ENABLE);



	set_counter(timer, TVAL_MAX);
@@ -608,7 +608,7 @@ static void test_set_cnt_after_tval_max(enum arch_timer timer, irq_wait_method_t 
/* Test timers set for: cval = now + TVAL_MAX + wait_ms / 2 */

static void test_timers_above_tval_max(enum arch_timer timer)

{

	uint64_t cval;

	u64 cval;

	int i;



	/*
@@ -638,8 +638,8 @@ static void test_timers_above_tval_max(enum arch_timer timer) 
 * sets the counter to cnt_1, the [c|t]val, the counter to cnt_2, and

 * then waits for an IRQ.

 */

static void test_set_cnt_after_xval(enum arch_timer timer, uint64_t cnt_1,

				    uint64_t xval, uint64_t cnt_2,

static void test_set_cnt_after_xval(enum arch_timer timer, u64 cnt_1,

				    u64 xval, u64 cnt_2,

				    irq_wait_method_t wm, enum timer_view tv)

{

	local_irq_disable();
@@ -662,8 +662,8 @@ static void test_set_cnt_after_xval(enum arch_timer timer, uint64_t cnt_1, 
 * then waits for an IRQ.

 */

static void test_set_cnt_after_xval_no_irq(enum arch_timer timer,

					   uint64_t cnt_1, uint64_t xval,

					   uint64_t cnt_2,

					   u64 cnt_1, u64 xval,

					   u64 cnt_2,

					   sleep_method_t guest_sleep,

					   enum timer_view tv)

{
@@ -684,31 +684,31 @@ static void test_set_cnt_after_xval_no_irq(enum arch_timer timer, 
	timer_set_ctl(timer, CTL_IMASK);

}



static void test_set_cnt_after_tval(enum arch_timer timer, uint64_t cnt_1,

				    int32_t tval, uint64_t cnt_2,

static void test_set_cnt_after_tval(enum arch_timer timer, u64 cnt_1,

				    s32 tval, u64 cnt_2,

				    irq_wait_method_t wm)

{

	test_set_cnt_after_xval(timer, cnt_1, tval, cnt_2, wm, TIMER_TVAL);

}



static void test_set_cnt_after_cval(enum arch_timer timer, uint64_t cnt_1,

				    uint64_t cval, uint64_t cnt_2,

static void test_set_cnt_after_cval(enum arch_timer timer, u64 cnt_1,

				    u64 cval, u64 cnt_2,

				    irq_wait_method_t wm)

{

	test_set_cnt_after_xval(timer, cnt_1, cval, cnt_2, wm, TIMER_CVAL);

}



static void test_set_cnt_after_tval_no_irq(enum arch_timer timer,

					   uint64_t cnt_1, int32_t tval,

					   uint64_t cnt_2, sleep_method_t wm)

					   u64 cnt_1, s32 tval,

					   u64 cnt_2, sleep_method_t wm)

{

	test_set_cnt_after_xval_no_irq(timer, cnt_1, tval, cnt_2, wm,

				       TIMER_TVAL);

}



static void test_set_cnt_after_cval_no_irq(enum arch_timer timer,

					   uint64_t cnt_1, uint64_t cval,

					   uint64_t cnt_2, sleep_method_t wm)

					   u64 cnt_1, u64 cval,

					   u64 cnt_2, sleep_method_t wm)

{

	test_set_cnt_after_xval_no_irq(timer, cnt_1, cval, cnt_2, wm,

				       TIMER_CVAL);
@@ -718,7 +718,7 @@ static void test_set_cnt_after_cval_no_irq(enum arch_timer timer, 
static void test_move_counters_ahead_of_timers(enum arch_timer timer)

{

	int i;

	int32_t tval;

	s32 tval;



	for (i = 0; i < ARRAY_SIZE(irq_wait_method); i++) {

		irq_wait_method_t wm = irq_wait_method[i];
@@ -730,8 +730,7 @@ static void test_move_counters_ahead_of_timers(enum arch_timer timer) 
		test_set_cnt_after_tval(timer, 0, -1, DEF_CNT + 1, wm);

		test_set_cnt_after_tval(timer, 0, -1, TVAL_MAX, wm);

		tval = TVAL_MAX;

		test_set_cnt_after_tval(timer, 0, tval, (uint64_t) tval + 1,

					wm);

		test_set_cnt_after_tval(timer, 0, tval, (u64)tval + 1, wm);

	}

}
@@ -754,8 +753,8 @@ static void test_move_counters_behind_timers(enum arch_timer timer) 


static void test_timers_in_the_past(enum arch_timer timer)

{

	int32_t tval = -1 * (int32_t) msec_to_cycles(test_args.wait_ms);

	uint64_t cval;

	s32 tval = -1 * (s32)msec_to_cycles(test_args.wait_ms);

	u64 cval;

	int i;



	for (i = 0; i < ARRAY_SIZE(irq_wait_method); i++) {
@@ -790,8 +789,8 @@ static void test_timers_in_the_past(enum arch_timer timer) 


static void test_long_timer_delays(enum arch_timer timer)

{

	int32_t tval = (int32_t) msec_to_cycles(test_args.long_wait_ms);

	uint64_t cval = DEF_CNT + msec_to_cycles(test_args.long_wait_ms);

	s32 tval = (s32)msec_to_cycles(test_args.long_wait_ms);

	u64 cval = DEF_CNT + msec_to_cycles(test_args.long_wait_ms);

	int i;



	for (i = 0; i < ARRAY_SIZE(irq_wait_method); i++) {
@@ -846,11 +845,11 @@ static void guest_code(enum arch_timer timer) 


static cpu_set_t default_cpuset;



static uint32_t next_pcpu(void)

static u32 next_pcpu(void)

{

	uint32_t max = get_nprocs();

	uint32_t cur = sched_getcpu();

	uint32_t next = cur;

	u32 max = get_nprocs();

	u32 cur = sched_getcpu();

	u32 next = cur;

	cpu_set_t cpuset = default_cpuset;



	TEST_ASSERT(max > 1, "Need at least two physical cpus");
@@ -862,7 +861,7 @@ static uint32_t next_pcpu(void) 
	return next;

}



static void kvm_set_cntxct(struct kvm_vcpu *vcpu, uint64_t cnt,

static void kvm_set_cntxct(struct kvm_vcpu *vcpu, u64 cnt,

			   enum arch_timer timer)

{

	if (timer == PHYSICAL)
@@ -874,7 +873,7 @@ static void kvm_set_cntxct(struct kvm_vcpu *vcpu, uint64_t cnt, 
static void handle_sync(struct kvm_vcpu *vcpu, struct ucall *uc)

{

	enum sync_cmd cmd = uc->args[1];

	uint64_t val = uc->args[2];

	u64 val = uc->args[2];

	enum arch_timer timer = uc->args[3];



	switch (cmd) {
@@ -1018,8 +1017,8 @@ static bool parse_args(int argc, char *argv[]) 


static void set_counter_defaults(void)

{

	const uint64_t MIN_ROLLOVER_SECS = 40ULL * 365 * 24 * 3600;

	uint64_t freq = read_sysreg(CNTFRQ_EL0);

	const u64 MIN_ROLLOVER_SECS = 40ULL * 365 * 24 * 3600;

	u64 freq = read_sysreg(CNTFRQ_EL0);

	int width = ilog2(MIN_ROLLOVER_SECS * freq);



	width = clamp(width, 56, 64);