KVM: selftests: Call a dummy helper in VM/vCPU ioctls() to enforce type

Replace the goofy static_assert on the size of the @vm/@vcpu parameters
with a call to a dummy helper, i.e. let the compiler naturally complain
about an incompatible type instead of homebrewing a poor replacement.

Reported-by: Andrew Jones <drjones@redhat.com>
Fixes: fcba483e8246 ("KVM: selftests: Sanity check input to ioctls() at build time")
Signed-off-by: Sean Christopherson <seanjc@google.com>
Message-Id: <20220613161942.1586791-3-seanjc@google.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>

diff --git a/tools/testing/selftests/kvm/include/kvm_util_base.h b/tools/testing/selftests/kvm/include/kvm_util_base.h
index cdaea2383543a0776ce8971950a8b92150798cf7..7ebfc8c7de177119795e060cbf5cf7258e0d0c6a 100644 (file)
--- a/tools/testing/selftests/kvm/include/kvm_util_base.h
+++ b/tools/testing/selftests/kvm/include/kvm_util_base.h
@@ -186,50 +186,55 @@ static inline bool kvm_has_cap(long cap)
        ioctl(fd, cmd, arg);                                                    \
 })
 
-#define __kvm_ioctl(kvm_fd, cmd, arg)                                          \
+#define __kvm_ioctl(kvm_fd, cmd, arg)                          \
        kvm_do_ioctl(kvm_fd, cmd, arg)
 
 
-#define _kvm_ioctl(kvm_fd, cmd, name, arg)                                     \
-({                                                                             \
-       int ret = __kvm_ioctl(kvm_fd, cmd, arg);                                \
-                                                                               \
-       TEST_ASSERT(!ret, __KVM_IOCTL_ERROR(name, ret));                        \
+#define _kvm_ioctl(kvm_fd, cmd, name, arg)                     \
+({                                                             \
+       int ret = __kvm_ioctl(kvm_fd, cmd, arg);                \
+                                                               \
+       TEST_ASSERT(!ret, __KVM_IOCTL_ERROR(name, ret));        \
 })
 
 #define kvm_ioctl(kvm_fd, cmd, arg) \
        _kvm_ioctl(kvm_fd, cmd, #cmd, arg)
 
-#define __vm_ioctl(vm, cmd, arg)                                               \
-({                                                                             \
-       static_assert(sizeof(*(vm)) == sizeof(struct kvm_vm), "");              \
-       kvm_do_ioctl((vm)->fd, cmd, arg);                                       \
+static __always_inline void static_assert_is_vm(struct kvm_vm *vm) { }
+
+#define __vm_ioctl(vm, cmd, arg)                               \
+({                                                             \
+       static_assert_is_vm(vm);                                \
+       kvm_do_ioctl((vm)->fd, cmd, arg);                       \
 })
 
-#define _vm_ioctl(vm, cmd, name, arg)                                          \
-({                                                                             \
-       int ret = __vm_ioctl(vm, cmd, arg);                                     \
-                                                                               \
-       TEST_ASSERT(!ret, __KVM_IOCTL_ERROR(name, ret));                        \
+#define _vm_ioctl(vm, cmd, name, arg)                          \
+({                                                             \
+       int ret = __vm_ioctl(vm, cmd, arg);                     \
+                                                               \
+       TEST_ASSERT(!ret, __KVM_IOCTL_ERROR(name, ret));        \
 })
 
-#define vm_ioctl(vm, cmd, arg)                                                 \
+#define vm_ioctl(vm, cmd, arg)                                 \
        _vm_ioctl(vm, cmd, #cmd, arg)
 
-#define __vcpu_ioctl(vcpu, cmd, arg)                                           \
-({                                                                             \
-       static_assert(sizeof(*(vcpu)) == sizeof(struct kvm_vcpu), "");          \
-       kvm_do_ioctl((vcpu)->fd, cmd, arg);                                     \
+
+static __always_inline void static_assert_is_vcpu(struct kvm_vcpu *vcpu) { }
+
+#define __vcpu_ioctl(vcpu, cmd, arg)                           \
+({                                                             \
+       static_assert_is_vcpu(vcpu);                            \
+       kvm_do_ioctl((vcpu)->fd, cmd, arg);                     \
 })
 
-#define _vcpu_ioctl(vcpu, cmd, name, arg)                                      \
-({                                                                             \
-       int ret = __vcpu_ioctl(vcpu, cmd, arg);                                 \
-                                                                               \
-       TEST_ASSERT(!ret, __KVM_IOCTL_ERROR(name, ret));                        \
+#define _vcpu_ioctl(vcpu, cmd, name, arg)                      \
+({                                                             \
+       int ret = __vcpu_ioctl(vcpu, cmd, arg);                 \
+                                                               \
+       TEST_ASSERT(!ret, __KVM_IOCTL_ERROR(name, ret));        \
 })
 
-#define vcpu_ioctl(vcpu, cmd, arg)                                             \
+#define vcpu_ioctl(vcpu, cmd, arg)                             \
        _vcpu_ioctl(vcpu, cmd, #cmd, arg)
 
 /*