tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

selftests: kvm: Uses TEST_FAIL in tests/utilities

Changed all tests and utilities to use TEST_FAIL macro
instead of TEST_ASSERT(false,...).

Signed-off-by: Wainer dos Santos Moschetta <wainersm@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>

authored by

Wainer dos Santos Moschetta and committed by
Paolo Bonzini 352be2c5 a46f8a63

+46 -53
+3 -4
tools/testing/selftests/kvm/dirty_log_test.c
··· 166 166 pages_count += TEST_PAGES_PER_LOOP; 167 167 generate_random_array(guest_array, TEST_PAGES_PER_LOOP); 168 168 } else { 169 - TEST_ASSERT(false, 170 - "Invalid guest sync status: " 171 - "exit_reason=%s\n", 172 - exit_reason_str(run->exit_reason)); 169 + TEST_FAIL("Invalid guest sync status: " 170 + "exit_reason=%s\n", 171 + exit_reason_str(run->exit_reason)); 173 172 } 174 173 } 175 174
+8 -9
tools/testing/selftests/kvm/lib/aarch64/processor.c
··· 130 130 ptep = addr_gpa2hva(vm, pte_addr(vm, *ptep)) + pte_index(vm, vaddr) * 8; 131 131 break; 132 132 default: 133 - TEST_ASSERT(false, "Page table levels must be 2, 3, or 4"); 133 + TEST_FAIL("Page table levels must be 2, 3, or 4"); 134 134 } 135 135 136 136 *ptep = paddr | 3; ··· 173 173 goto unmapped_gva; 174 174 break; 175 175 default: 176 - TEST_ASSERT(false, "Page table levels must be 2, 3, or 4"); 176 + TEST_FAIL("Page table levels must be 2, 3, or 4"); 177 177 } 178 178 179 179 return pte_addr(vm, *ptep) + (gva & (vm->page_size - 1)); 180 180 181 181 unmapped_gva: 182 - TEST_ASSERT(false, "No mapping for vm virtual address, " 183 - "gva: 0x%lx", gva); 182 + TEST_FAIL("No mapping for vm virtual address, gva: 0x%lx", gva); 184 183 exit(1); 185 184 } 186 185 ··· 261 262 262 263 switch (vm->mode) { 263 264 case VM_MODE_P52V48_4K: 264 - TEST_ASSERT(false, "AArch64 does not support 4K sized pages " 265 - "with 52-bit physical address ranges"); 265 + TEST_FAIL("AArch64 does not support 4K sized pages " 266 + "with 52-bit physical address ranges"); 266 267 case VM_MODE_PXXV48_4K: 267 - TEST_ASSERT(false, "AArch64 does not support 4K sized pages " 268 - "with ANY-bit physical address ranges"); 268 + TEST_FAIL("AArch64 does not support 4K sized pages " 269 + "with ANY-bit physical address ranges"); 269 270 case VM_MODE_P52V48_64K: 270 271 tcr_el1 |= 1ul << 14; /* TG0 = 64KB */ 271 272 tcr_el1 |= 6ul << 32; /* IPS = 52 bits */ ··· 287 288 tcr_el1 |= 2ul << 32; /* IPS = 40 bits */ 288 289 break; 289 290 default: 290 - TEST_ASSERT(false, "Unknown guest mode, mode: 0x%x", vm->mode); 291 + TEST_FAIL("Unknown guest mode, mode: 0x%x", vm->mode); 291 292 } 292 293 293 294 sctlr_el1 |= (1 << 0) | (1 << 2) | (1 << 12) /* M | C | I */;
+1 -1
tools/testing/selftests/kvm/lib/aarch64/ucall.c
··· 62 62 if (ucall_mmio_init(vm, start + offset)) 63 63 return; 64 64 } 65 - TEST_ASSERT(false, "Can't find a ucall mmio address"); 65 + TEST_FAIL("Can't find a ucall mmio address"); 66 66 } 67 67 68 68 void ucall_uninit(struct kvm_vm *vm)
+6 -6
tools/testing/selftests/kvm/lib/io.c
··· 61 61 continue; 62 62 63 63 case 0: 64 - TEST_ASSERT(false, "Unexpected EOF,\n" 65 - " rc: %zi num_written: %zi num_left: %zu", 66 - rc, num_written, num_left); 64 + TEST_FAIL("Unexpected EOF,\n" 65 + " rc: %zi num_written: %zi num_left: %zu", 66 + rc, num_written, num_left); 67 67 break; 68 68 69 69 default: ··· 138 138 break; 139 139 140 140 case 0: 141 - TEST_ASSERT(false, "Unexpected EOF,\n" 142 - " rc: %zi num_read: %zi num_left: %zu", 143 - rc, num_read, num_left); 141 + TEST_FAIL("Unexpected EOF,\n" 142 + " rc: %zi num_read: %zi num_left: %zu", 143 + rc, num_read, num_left); 144 144 break; 145 145 146 146 default:
+9 -12
tools/testing/selftests/kvm/lib/kvm_util.c
··· 198 198 vm->pa_bits); 199 199 vm->pgtable_levels = 4; 200 200 #else 201 - TEST_ASSERT(false, "VM_MODE_PXXV48_4K not supported on " 202 - "non-x86 platforms"); 201 + TEST_FAIL("VM_MODE_PXXV48_4K not supported on non-x86 platforms"); 203 202 #endif 204 203 break; 205 204 default: 206 - TEST_ASSERT(false, "Unknown guest mode, mode: 0x%x", mode); 205 + TEST_FAIL("Unknown guest mode, mode: 0x%x", mode); 207 206 } 208 207 209 208 #ifdef __aarch64__ ··· 602 603 region = (struct userspace_mem_region *) userspace_mem_region_find( 603 604 vm, guest_paddr, (guest_paddr + npages * vm->page_size) - 1); 604 605 if (region != NULL) 605 - TEST_ASSERT(false, "overlapping userspace_mem_region already " 606 + TEST_FAIL("overlapping userspace_mem_region already " 606 607 "exists\n" 607 608 " requested guest_paddr: 0x%lx npages: 0x%lx " 608 609 "page_size: 0x%x\n" ··· 618 619 break; 619 620 } 620 621 if (region != NULL) 621 - TEST_ASSERT(false, "A mem region with the requested slot " 622 + TEST_FAIL("A mem region with the requested slot " 622 623 "already exists.\n" 623 624 " requested slot: %u paddr: 0x%lx npages: 0x%lx\n" 624 625 " existing slot: %u paddr: 0x%lx size: 0x%lx", ··· 722 723 " requested slot: %u\n", memslot); 723 724 fputs("---- vm dump ----\n", stderr); 724 725 vm_dump(stderr, vm, 2); 725 - TEST_ASSERT(false, "Mem region not found"); 726 + TEST_FAIL("Mem region not found"); 726 727 } 727 728 728 729 return region; ··· 840 841 /* Confirm a vcpu with the specified id doesn't already exist. */ 841 842 vcpu = vcpu_find(vm, vcpuid); 842 843 if (vcpu != NULL) 843 - TEST_ASSERT(false, "vcpu with the specified id " 844 + TEST_FAIL("vcpu with the specified id " 844 845 "already exists,\n" 845 846 " requested vcpuid: %u\n" 846 847 " existing vcpuid: %u state: %p", ··· 933 934 } while (pgidx_start != 0); 934 935 935 936 no_va_found: 936 - TEST_ASSERT(false, "No vaddr of specified pages available, " 937 - "pages: 0x%lx", pages); 937 + TEST_FAIL("No vaddr of specified pages available, pages: 0x%lx", pages); 938 938 939 939 /* NOT REACHED */ 940 940 return -1; ··· 1068 1070 + (gpa - region->region.guest_phys_addr)); 1069 1071 } 1070 1072 1071 - TEST_ASSERT(false, "No vm physical memory at 0x%lx", gpa); 1073 + TEST_FAIL("No vm physical memory at 0x%lx", gpa); 1072 1074 return NULL; 1073 1075 } 1074 1076 ··· 1102 1104 + (hva - (uintptr_t) region->host_mem)); 1103 1105 } 1104 1106 1105 - TEST_ASSERT(false, "No mapping to a guest physical address, " 1106 - "hva: %p", hva); 1107 + TEST_FAIL("No mapping to a guest physical address, hva: %p", hva); 1107 1108 return -1; 1108 1109 } 1109 1110
+2 -3
tools/testing/selftests/kvm/lib/x86_64/processor.c
··· 506 506 return (pte[index[0]].address * vm->page_size) + (gva & 0xfffu); 507 507 508 508 unmapped_gva: 509 - TEST_ASSERT(false, "No mapping for vm virtual address, " 510 - "gva: 0x%lx", gva); 509 + TEST_FAIL("No mapping for vm virtual address, gva: 0x%lx", gva); 511 510 exit(EXIT_FAILURE); 512 511 } 513 512 ··· 563 564 break; 564 565 565 566 default: 566 - TEST_ASSERT(false, "Unknown guest mode, mode: 0x%x", vm->mode); 567 + TEST_FAIL("Unknown guest mode, mode: 0x%x", vm->mode); 567 568 } 568 569 569 570 sregs.cr3 = vm->pgd;
+2 -2
tools/testing/selftests/kvm/x86_64/cr4_cpuid_sync_test.c
··· 101 101 vcpu_sregs_set(vm, VCPU_ID, &sregs); 102 102 break; 103 103 case UCALL_ABORT: 104 - TEST_ASSERT(false, "Guest CR4 bit (OSXSAVE) unsynchronized with CPUID bit."); 104 + TEST_FAIL("Guest CR4 bit (OSXSAVE) unsynchronized with CPUID bit."); 105 105 break; 106 106 case UCALL_DONE: 107 107 goto done; 108 108 default: 109 - TEST_ASSERT(false, "Unknown ucall %lu", uc.cmd); 109 + TEST_FAIL("Unknown ucall %lu", uc.cmd); 110 110 } 111 111 } 112 112
+3 -3
tools/testing/selftests/kvm/x86_64/evmcs_test.c
··· 109 109 110 110 switch (get_ucall(vm, VCPU_ID, &uc)) { 111 111 case UCALL_ABORT: 112 - TEST_ASSERT(false, "%s at %s:%ld", (const char *)uc.args[0], 113 - __FILE__, uc.args[1]); 112 + TEST_FAIL("%s at %s:%ld", (const char *)uc.args[0], 113 + __FILE__, uc.args[1]); 114 114 /* NOT REACHED */ 115 115 case UCALL_SYNC: 116 116 break; 117 117 case UCALL_DONE: 118 118 goto done; 119 119 default: 120 - TEST_ASSERT(false, "Unknown ucall %lu", uc.cmd); 120 + TEST_FAIL("Unknown ucall %lu", uc.cmd); 121 121 } 122 122 123 123 /* UCALL_SYNC is handled here. */
+3 -3
tools/testing/selftests/kvm/x86_64/state_test.c
··· 152 152 153 153 switch (get_ucall(vm, VCPU_ID, &uc)) { 154 154 case UCALL_ABORT: 155 - TEST_ASSERT(false, "%s at %s:%ld", (const char *)uc.args[0], 156 - __FILE__, uc.args[1]); 155 + TEST_FAIL("%s at %s:%ld", (const char *)uc.args[0], 156 + __FILE__, uc.args[1]); 157 157 /* NOT REACHED */ 158 158 case UCALL_SYNC: 159 159 break; 160 160 case UCALL_DONE: 161 161 goto done; 162 162 default: 163 - TEST_ASSERT(false, "Unknown ucall %lu", uc.cmd); 163 + TEST_FAIL("Unknown ucall %lu", uc.cmd); 164 164 } 165 165 166 166 /* UCALL_SYNC is handled here. */
+2 -3
tools/testing/selftests/kvm/x86_64/svm_vmcall_test.c
··· 61 61 62 62 switch (get_ucall(vm, VCPU_ID, &uc)) { 63 63 case UCALL_ABORT: 64 - TEST_ASSERT(false, "%s", 65 - (const char *)uc.args[0]); 64 + TEST_FAIL("%s", (const char *)uc.args[0]); 66 65 /* NOT REACHED */ 67 66 case UCALL_SYNC: 68 67 break; 69 68 case UCALL_DONE: 70 69 goto done; 71 70 default: 72 - TEST_ASSERT(false, "Unknown ucall 0x%lx.", uc.cmd); 71 + TEST_FAIL("Unknown ucall 0x%lx.", uc.cmd); 73 72 } 74 73 } 75 74 done:
+2 -2
tools/testing/selftests/kvm/x86_64/vmx_close_while_nested_test.c
··· 78 78 79 79 switch (get_ucall(vm, VCPU_ID, &uc)) { 80 80 case UCALL_ABORT: 81 - TEST_ASSERT(false, "%s", (const char *)uc.args[0]); 81 + TEST_FAIL("%s", (const char *)uc.args[0]); 82 82 /* NOT REACHED */ 83 83 default: 84 - TEST_ASSERT(false, "Unknown ucall %lu", uc.cmd); 84 + TEST_FAIL("Unknown ucall %lu", uc.cmd); 85 85 } 86 86 } 87 87 }
+3 -3
tools/testing/selftests/kvm/x86_64/vmx_dirty_log_test.c
··· 125 125 126 126 switch (get_ucall(vm, VCPU_ID, &uc)) { 127 127 case UCALL_ABORT: 128 - TEST_ASSERT(false, "%s at %s:%ld", (const char *)uc.args[0], 129 - __FILE__, uc.args[1]); 128 + TEST_FAIL("%s at %s:%ld", (const char *)uc.args[0], 129 + __FILE__, uc.args[1]); 130 130 /* NOT REACHED */ 131 131 case UCALL_SYNC: 132 132 /* ··· 151 151 done = true; 152 152 break; 153 153 default: 154 - TEST_ASSERT(false, "Unknown ucall %lu", uc.cmd); 154 + TEST_FAIL("Unknown ucall %lu", uc.cmd); 155 155 } 156 156 } 157 157 }
+2 -2
tools/testing/selftests/kvm/x86_64/vmx_tsc_adjust_test.c
··· 150 150 151 151 switch (get_ucall(vm, VCPU_ID, &uc)) { 152 152 case UCALL_ABORT: 153 - TEST_ASSERT(false, "%s", (const char *)uc.args[0]); 153 + TEST_FAIL("%s", (const char *)uc.args[0]); 154 154 /* NOT REACHED */ 155 155 case UCALL_SYNC: 156 156 report(uc.args[1]); ··· 158 158 case UCALL_DONE: 159 159 goto done; 160 160 default: 161 - TEST_ASSERT(false, "Unknown ucall %lu", uc.cmd); 161 + TEST_FAIL("Unknown ucall %lu", uc.cmd); 162 162 } 163 163 } 164 164