tools/testing/selftests/kvm/s390/cpumodel_subfuncs_test.c - linux - Git at Google

 // SPDX-License-Identifier: GPL-2.0-only
 /*
  * Copyright IBM Corp. 2024
  *
  * Authors:
  *  Hariharan Mari <hari55@linux.ibm.com>
  *
  * The tests compare the result of the KVM ioctl for obtaining CPU subfunction data with those
  * from an ASM block performing the same CPU subfunction. Currently KVM doesn't mask instruction
  * query data reported via the CPU Model, allowing us to directly compare it with the data
  * acquired through executing the queries in the test.
  */

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/ioctl.h>
 #include "facility.h"

 #include "kvm_util.h"

 #define PLO_FUNCTION_MAX 256

 /* Query available CPU subfunctions */
 struct kvm_s390_vm_cpu_subfunc cpu_subfunc;

 static void get_cpu_machine_subfuntions(struct kvm_vm *vm,
 					struct kvm_s390_vm_cpu_subfunc *cpu_subfunc)
 {
 	int r;

 	r = __kvm_device_attr_get(vm->fd, KVM_S390_VM_CPU_MODEL,
 				  KVM_S390_VM_CPU_MACHINE_SUBFUNC, cpu_subfunc);

 	TEST_ASSERT(!r, "Get cpu subfunctions failed r=%d errno=%d", r, errno);
 }

 static inline int plo_test_bit(unsigned char nr)
 {
 	unsigned long function = nr | 0x100;
 	int cc;

 	asm volatile("	lgr	0,%[function]\n"
 			/* Parameter registers are ignored for "test bit" */
 			"	plo	0,0,0,0(0)\n"
 			"	ipm	%0\n"
 			"	srl	%0,28\n"
 			: "=d" (cc)
 			: [function] "d" (function)
 			: "cc", "0");
 	return cc == 0;
 }

 /* Testing Perform Locked Operation (PLO) CPU subfunction's ASM block */
 static void test_plo_asm_block(u8 (*query)[32])
 {
 	for (int i = 0; i < PLO_FUNCTION_MAX; ++i) {
 		if (plo_test_bit(i))
 			(*query)[i >> 3] |= 0x80 >> (i & 7);
 	}
 }

 /* Testing Crypto Compute Message Authentication Code (KMAC) CPU subfunction's ASM block */
 static void test_kmac_asm_block(u8 (*query)[16])
 {
 	asm volatile("	la	%%r1,%[query]\n"
 			"	xgr	%%r0,%%r0\n"
 			"	.insn	rre,0xb91e0000,0,2\n"
 			: [query] "=R" (*query)
 			:
 			: "cc", "r0", "r1");
 }

 /* Testing Crypto Cipher Message with Chaining (KMC) CPU subfunction's ASM block */
 static void test_kmc_asm_block(u8 (*query)[16])
 {
 	asm volatile("	la	%%r1,%[query]\n"
 			"	xgr	%%r0,%%r0\n"
 			"	.insn	rre,0xb92f0000,2,4\n"
 			: [query] "=R" (*query)
 			:
 			: "cc", "r0", "r1");
 }

 /* Testing Crypto Cipher Message (KM) CPU subfunction's ASM block */
 static void test_km_asm_block(u8 (*query)[16])
 {
 	asm volatile("	la	%%r1,%[query]\n"
 			"	xgr	%%r0,%%r0\n"
 			"	.insn	rre,0xb92e0000,2,4\n"
 			: [query] "=R" (*query)
 			:
 			: "cc", "r0", "r1");
 }

 /* Testing Crypto Compute Intermediate Message Digest (KIMD) CPU subfunction's ASM block */
 static void test_kimd_asm_block(u8 (*query)[16])
 {
 	asm volatile("	la	%%r1,%[query]\n"
 			"	xgr	%%r0,%%r0\n"
 			"	.insn	rre,0xb93e0000,0,2\n"
 			: [query] "=R" (*query)
 			:
 			: "cc", "r0", "r1");
 }

 /* Testing Crypto Compute Last Message Digest (KLMD) CPU subfunction's ASM block */
 static void test_klmd_asm_block(u8 (*query)[16])
 {
 	asm volatile("	la	%%r1,%[query]\n"
 			"	xgr	%%r0,%%r0\n"
 			"	.insn	rre,0xb93f0000,0,2\n"
 			: [query] "=R" (*query)
 			:
 			: "cc", "r0", "r1");
 }

 /* Testing Crypto Cipher Message with Counter (KMCTR) CPU subfunction's ASM block */
 static void test_kmctr_asm_block(u8 (*query)[16])
 {
 	asm volatile("	la	%%r1,%[query]\n"
 			"	xgr	%%r0,%%r0\n"
 			"	.insn	rrf,0xb92d0000,2,4,6,0\n"
 			: [query] "=R" (*query)
 			:
 			: "cc", "r0", "r1");
 }

 /* Testing Crypto Cipher Message with Cipher Feedback (KMF) CPU subfunction's ASM block */
 static void test_kmf_asm_block(u8 (*query)[16])
 {
 	asm volatile("	la	%%r1,%[query]\n"
 			"	xgr	%%r0,%%r0\n"
 			"	.insn	rre,0xb92a0000,2,4\n"
 			: [query] "=R" (*query)
 			:
 			: "cc", "r0", "r1");
 }

 /* Testing Crypto Cipher Message with Output Feedback (KMO) CPU subfunction's ASM block */
 static void test_kmo_asm_block(u8 (*query)[16])
 {
 	asm volatile("	la	%%r1,%[query]\n"
 			"	xgr	%%r0,%%r0\n"
 			"	.insn	rre,0xb92b0000,2,4\n"
 			: [query] "=R" (*query)
 			:
 			: "cc", "r0", "r1");
 }

 /* Testing Crypto Perform Cryptographic Computation (PCC) CPU subfunction's ASM block */
 static void test_pcc_asm_block(u8 (*query)[16])
 {
 	asm volatile("	la	%%r1,%[query]\n"
 			"	xgr	%%r0,%%r0\n"
 			"	.insn	rre,0xb92c0000,0,0\n"
 			: [query] "=R" (*query)
 			:
 			: "cc", "r0", "r1");
 }

 /* Testing Crypto Perform Random Number Operation (PRNO) CPU subfunction's ASM block */
 static void test_prno_asm_block(u8 (*query)[16])
 {
 	asm volatile("	la	%%r1,%[query]\n"
 			"	xgr	%%r0,%%r0\n"
 			"	.insn	rre,0xb93c0000,2,4\n"
 			: [query] "=R" (*query)
 			:
 			: "cc", "r0", "r1");
 }

 /* Testing Crypto Cipher Message with Authentication (KMA) CPU subfunction's ASM block */
 static void test_kma_asm_block(u8 (*query)[16])
 {
 	asm volatile("	la	%%r1,%[query]\n"
 			"	xgr	%%r0,%%r0\n"
 			"	.insn	rrf,0xb9290000,2,4,6,0\n"
 			: [query] "=R" (*query)
 			:
 			: "cc", "r0", "r1");
 }

 /* Testing Crypto Compute Digital Signature Authentication (KDSA) CPU subfunction's ASM block */
 static void test_kdsa_asm_block(u8 (*query)[16])
 {
 	asm volatile("	la	%%r1,%[query]\n"
 			"	xgr	%%r0,%%r0\n"
 			"	.insn	rre,0xb93a0000,0,2\n"
 			: [query] "=R" (*query)
 			:
 			: "cc", "r0", "r1");
 }

 /* Testing Sort Lists (SORTL) CPU subfunction's ASM block */
 static void test_sortl_asm_block(u8 (*query)[32])
 {
 	asm volatile("	lghi	0,0\n"
 			"	la	1,%[query]\n"
 			"	.insn	rre,0xb9380000,2,4\n"
 			: [query] "=R" (*query)
 			:
 			: "cc", "0", "1");
 }

 /* Testing Deflate Conversion Call (DFLTCC) CPU subfunction's ASM block */
 static void test_dfltcc_asm_block(u8 (*query)[32])
 {
 	asm volatile("	lghi	0,0\n"
 			"	la	1,%[query]\n"
 			"	.insn	rrf,0xb9390000,2,4,6,0\n"
 			: [query] "=R" (*query)
 			:
 			: "cc", "0", "1");
 }

 /*
  * Testing Perform Function with Concurrent Results (PFCR)
  * CPU subfunctions's ASM block
  */
 static void test_pfcr_asm_block(u8 (*query)[16])
 {
 	asm volatile("	lghi	0,0\n"
 			"	.insn   rsy,0xeb0000000016,0,0,%[query]\n"
 			: [query] "=QS" (*query)
 			:
 			: "cc", "0");
 }

 typedef void (*testfunc_t)(u8 (*array)[]);

 struct testdef {
 	const char *subfunc_name;
 	u8 *subfunc_array;
 	size_t array_size;
 	testfunc_t test;
 	int facility_bit;
 } testlist[] = {
 	/*
 	 * PLO was introduced in the very first 64-bit machine generation.
 	 * Hence it is assumed PLO is always installed in Z Arch.
 	 */
 	{ "PLO", cpu_subfunc.plo, sizeof(cpu_subfunc.plo), test_plo_asm_block, 1 },
 	/* MSA - Facility bit 17 */
 	{ "KMAC", cpu_subfunc.kmac, sizeof(cpu_subfunc.kmac), test_kmac_asm_block, 17 },
 	{ "KMC", cpu_subfunc.kmc, sizeof(cpu_subfunc.kmc), test_kmc_asm_block, 17 },
 	{ "KM", cpu_subfunc.km, sizeof(cpu_subfunc.km), test_km_asm_block, 17 },
 	{ "KIMD", cpu_subfunc.kimd, sizeof(cpu_subfunc.kimd), test_kimd_asm_block, 17 },
 	{ "KLMD", cpu_subfunc.klmd, sizeof(cpu_subfunc.klmd), test_klmd_asm_block, 17 },
 	/* MSA - Facility bit 77 */
 	{ "KMCTR", cpu_subfunc.kmctr, sizeof(cpu_subfunc.kmctr), test_kmctr_asm_block, 77 },
 	{ "KMF", cpu_subfunc.kmf, sizeof(cpu_subfunc.kmf), test_kmf_asm_block, 77 },
 	{ "KMO", cpu_subfunc.kmo, sizeof(cpu_subfunc.kmo), test_kmo_asm_block, 77 },
 	{ "PCC", cpu_subfunc.pcc, sizeof(cpu_subfunc.pcc), test_pcc_asm_block, 77 },
 	/* MSA5 - Facility bit 57 */
 	{ "PPNO", cpu_subfunc.ppno, sizeof(cpu_subfunc.ppno), test_prno_asm_block, 57 },
 	/* MSA8 - Facility bit 146 */
 	{ "KMA", cpu_subfunc.kma, sizeof(cpu_subfunc.kma), test_kma_asm_block, 146 },
 	/* MSA9 - Facility bit 155 */
 	{ "KDSA", cpu_subfunc.kdsa, sizeof(cpu_subfunc.kdsa), test_kdsa_asm_block, 155 },
 	/* SORTL - Facility bit 150 */
 	{ "SORTL", cpu_subfunc.sortl, sizeof(cpu_subfunc.sortl), test_sortl_asm_block, 150 },
 	/* DFLTCC - Facility bit 151 */
 	{ "DFLTCC", cpu_subfunc.dfltcc, sizeof(cpu_subfunc.dfltcc), test_dfltcc_asm_block, 151 },
 	/* Concurrent-function facility - Facility bit 201 */
 	{ "PFCR", cpu_subfunc.pfcr, sizeof(cpu_subfunc.pfcr), test_pfcr_asm_block, 201 },
 };

 int main(int argc, char *argv[])
 {
 	struct kvm_vm *vm;
 	int idx;

 	ksft_print_header();

 	vm = vm_create(1);

 	memset(&cpu_subfunc, 0, sizeof(cpu_subfunc));
 	get_cpu_machine_subfuntions(vm, &cpu_subfunc);

 	ksft_set_plan(ARRAY_SIZE(testlist));
 	for (idx = 0; idx < ARRAY_SIZE(testlist); idx++) {
 		if (test_facility(testlist[idx].facility_bit)) {
 			u8 *array = malloc(testlist[idx].array_size);

 			testlist[idx].test((u8 (*)[testlist[idx].array_size])array);

 			TEST_ASSERT_EQ(memcmp(testlist[idx].subfunc_array,
 					      array, testlist[idx].array_size), 0);

 			ksft_test_result_pass("%s\n", testlist[idx].subfunc_name);
 			free(array);
 		} else {
 			ksft_test_result_skip("%s feature is not available\n",
 					      testlist[idx].subfunc_name);
 		}
 	}

 	kvm_vm_free(vm);
 	ksft_finished();
 }
	// SPDX-License-Identifier: GPL-2.0-only
	/*
	* Copyright IBM Corp. 2024
	*
	* Authors:
	* Hariharan Mari <hari55@linux.ibm.com>
	*
	* The tests compare the result of the KVM ioctl for obtaining CPU subfunction data with those
	* from an ASM block performing the same CPU subfunction. Currently KVM doesn't mask instruction
	* query data reported via the CPU Model, allowing us to directly compare it with the data
	* acquired through executing the queries in the test.
	*/

	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <sys/ioctl.h>
	#include "facility.h"

	#include "kvm_util.h"

	#define PLO_FUNCTION_MAX 256

	/* Query available CPU subfunctions */
	struct kvm_s390_vm_cpu_subfunc cpu_subfunc;

	static void get_cpu_machine_subfuntions(struct kvm_vm *vm,
	struct kvm_s390_vm_cpu_subfunc *cpu_subfunc)
	{
	int r;

	r = __kvm_device_attr_get(vm->fd, KVM_S390_VM_CPU_MODEL,
	KVM_S390_VM_CPU_MACHINE_SUBFUNC, cpu_subfunc);

	TEST_ASSERT(!r, "Get cpu subfunctions failed r=%d errno=%d", r, errno);
	}

	static inline int plo_test_bit(unsigned char nr)
	{
	unsigned long function = nr \| 0x100;
	int cc;

	asm volatile(" lgr 0,%[function]\n"
	/* Parameter registers are ignored for "test bit" */
	" plo 0,0,0,0(0)\n"
	" ipm %0\n"
	" srl %0,28\n"
	: "=d" (cc)
	: [function] "d" (function)
	: "cc", "0");
	return cc == 0;
	}

	/* Testing Perform Locked Operation (PLO) CPU subfunction's ASM block */
	static void test_plo_asm_block(u8 (*query)[32])
	{
	for (int i = 0; i < PLO_FUNCTION_MAX; ++i) {
	if (plo_test_bit(i))
	(*query)[i >> 3] \|= 0x80 >> (i & 7);
	}
	}

	/* Testing Crypto Compute Message Authentication Code (KMAC) CPU subfunction's ASM block */
	static void test_kmac_asm_block(u8 (*query)[16])
	{
	asm volatile(" la %%r1,%[query]\n"
	" xgr %%r0,%%r0\n"
	" .insn rre,0xb91e0000,0,2\n"
	: [query] "=R" (*query)
	:
	: "cc", "r0", "r1");
	}

	/* Testing Crypto Cipher Message with Chaining (KMC) CPU subfunction's ASM block */
	static void test_kmc_asm_block(u8 (*query)[16])
	{
	asm volatile(" la %%r1,%[query]\n"
	" xgr %%r0,%%r0\n"
	" .insn rre,0xb92f0000,2,4\n"
	: [query] "=R" (*query)
	:
	: "cc", "r0", "r1");
	}

	/* Testing Crypto Cipher Message (KM) CPU subfunction's ASM block */
	static void test_km_asm_block(u8 (*query)[16])
	{
	asm volatile(" la %%r1,%[query]\n"
	" xgr %%r0,%%r0\n"
	" .insn rre,0xb92e0000,2,4\n"
	: [query] "=R" (*query)
	:
	: "cc", "r0", "r1");
	}

	/* Testing Crypto Compute Intermediate Message Digest (KIMD) CPU subfunction's ASM block */
	static void test_kimd_asm_block(u8 (*query)[16])
	{
	asm volatile(" la %%r1,%[query]\n"
	" xgr %%r0,%%r0\n"
	" .insn rre,0xb93e0000,0,2\n"
	: [query] "=R" (*query)
	:
	: "cc", "r0", "r1");
	}

	/* Testing Crypto Compute Last Message Digest (KLMD) CPU subfunction's ASM block */
	static void test_klmd_asm_block(u8 (*query)[16])
	{
	asm volatile(" la %%r1,%[query]\n"
	" xgr %%r0,%%r0\n"
	" .insn rre,0xb93f0000,0,2\n"
	: [query] "=R" (*query)
	:
	: "cc", "r0", "r1");
	}

	/* Testing Crypto Cipher Message with Counter (KMCTR) CPU subfunction's ASM block */
	static void test_kmctr_asm_block(u8 (*query)[16])
	{
	asm volatile(" la %%r1,%[query]\n"
	" xgr %%r0,%%r0\n"
	" .insn rrf,0xb92d0000,2,4,6,0\n"
	: [query] "=R" (*query)
	:
	: "cc", "r0", "r1");
	}

	/* Testing Crypto Cipher Message with Cipher Feedback (KMF) CPU subfunction's ASM block */
	static void test_kmf_asm_block(u8 (*query)[16])
	{
	asm volatile(" la %%r1,%[query]\n"
	" xgr %%r0,%%r0\n"
	" .insn rre,0xb92a0000,2,4\n"
	: [query] "=R" (*query)
	:
	: "cc", "r0", "r1");
	}

	/* Testing Crypto Cipher Message with Output Feedback (KMO) CPU subfunction's ASM block */
	static void test_kmo_asm_block(u8 (*query)[16])
	{
	asm volatile(" la %%r1,%[query]\n"
	" xgr %%r0,%%r0\n"
	" .insn rre,0xb92b0000,2,4\n"
	: [query] "=R" (*query)
	:
	: "cc", "r0", "r1");
	}

	/* Testing Crypto Perform Cryptographic Computation (PCC) CPU subfunction's ASM block */
	static void test_pcc_asm_block(u8 (*query)[16])
	{
	asm volatile(" la %%r1,%[query]\n"
	" xgr %%r0,%%r0\n"
	" .insn rre,0xb92c0000,0,0\n"
	: [query] "=R" (*query)
	:
	: "cc", "r0", "r1");
	}

	/* Testing Crypto Perform Random Number Operation (PRNO) CPU subfunction's ASM block */
	static void test_prno_asm_block(u8 (*query)[16])
	{
	asm volatile(" la %%r1,%[query]\n"
	" xgr %%r0,%%r0\n"
	" .insn rre,0xb93c0000,2,4\n"
	: [query] "=R" (*query)
	:
	: "cc", "r0", "r1");
	}

	/* Testing Crypto Cipher Message with Authentication (KMA) CPU subfunction's ASM block */
	static void test_kma_asm_block(u8 (*query)[16])
	{
	asm volatile(" la %%r1,%[query]\n"
	" xgr %%r0,%%r0\n"
	" .insn rrf,0xb9290000,2,4,6,0\n"
	: [query] "=R" (*query)
	:
	: "cc", "r0", "r1");
	}

	/* Testing Crypto Compute Digital Signature Authentication (KDSA) CPU subfunction's ASM block */
	static void test_kdsa_asm_block(u8 (*query)[16])
	{
	asm volatile(" la %%r1,%[query]\n"
	" xgr %%r0,%%r0\n"
	" .insn rre,0xb93a0000,0,2\n"
	: [query] "=R" (*query)
	:
	: "cc", "r0", "r1");
	}

	/* Testing Sort Lists (SORTL) CPU subfunction's ASM block */
	static void test_sortl_asm_block(u8 (*query)[32])
	{
	asm volatile(" lghi 0,0\n"
	" la 1,%[query]\n"
	" .insn rre,0xb9380000,2,4\n"
	: [query] "=R" (*query)
	:
	: "cc", "0", "1");
	}

	/* Testing Deflate Conversion Call (DFLTCC) CPU subfunction's ASM block */
	static void test_dfltcc_asm_block(u8 (*query)[32])
	{
	asm volatile(" lghi 0,0\n"
	" la 1,%[query]\n"
	" .insn rrf,0xb9390000,2,4,6,0\n"
	: [query] "=R" (*query)
	:
	: "cc", "0", "1");
	}

	/*
	* Testing Perform Function with Concurrent Results (PFCR)
	* CPU subfunctions's ASM block
	*/
	static void test_pfcr_asm_block(u8 (*query)[16])
	{
	asm volatile(" lghi 0,0\n"
	" .insn rsy,0xeb0000000016,0,0,%[query]\n"
	: [query] "=QS" (*query)
	:
	: "cc", "0");
	}

	typedef void (testfunc_t)(u8 (array)[]);

	struct testdef {
	const char *subfunc_name;
	u8 *subfunc_array;
	size_t array_size;
	testfunc_t test;
	int facility_bit;
	} testlist[] = {
	/*
	* PLO was introduced in the very first 64-bit machine generation.
	* Hence it is assumed PLO is always installed in Z Arch.
	*/
	{ "PLO", cpu_subfunc.plo, sizeof(cpu_subfunc.plo), test_plo_asm_block, 1 },
	/* MSA - Facility bit 17 */
	{ "KMAC", cpu_subfunc.kmac, sizeof(cpu_subfunc.kmac), test_kmac_asm_block, 17 },
	{ "KMC", cpu_subfunc.kmc, sizeof(cpu_subfunc.kmc), test_kmc_asm_block, 17 },
	{ "KM", cpu_subfunc.km, sizeof(cpu_subfunc.km), test_km_asm_block, 17 },
	{ "KIMD", cpu_subfunc.kimd, sizeof(cpu_subfunc.kimd), test_kimd_asm_block, 17 },
	{ "KLMD", cpu_subfunc.klmd, sizeof(cpu_subfunc.klmd), test_klmd_asm_block, 17 },
	/* MSA - Facility bit 77 */
	{ "KMCTR", cpu_subfunc.kmctr, sizeof(cpu_subfunc.kmctr), test_kmctr_asm_block, 77 },
	{ "KMF", cpu_subfunc.kmf, sizeof(cpu_subfunc.kmf), test_kmf_asm_block, 77 },
	{ "KMO", cpu_subfunc.kmo, sizeof(cpu_subfunc.kmo), test_kmo_asm_block, 77 },
	{ "PCC", cpu_subfunc.pcc, sizeof(cpu_subfunc.pcc), test_pcc_asm_block, 77 },
	/* MSA5 - Facility bit 57 */
	{ "PPNO", cpu_subfunc.ppno, sizeof(cpu_subfunc.ppno), test_prno_asm_block, 57 },
	/* MSA8 - Facility bit 146 */
	{ "KMA", cpu_subfunc.kma, sizeof(cpu_subfunc.kma), test_kma_asm_block, 146 },
	/* MSA9 - Facility bit 155 */
	{ "KDSA", cpu_subfunc.kdsa, sizeof(cpu_subfunc.kdsa), test_kdsa_asm_block, 155 },
	/* SORTL - Facility bit 150 */
	{ "SORTL", cpu_subfunc.sortl, sizeof(cpu_subfunc.sortl), test_sortl_asm_block, 150 },
	/* DFLTCC - Facility bit 151 */
	{ "DFLTCC", cpu_subfunc.dfltcc, sizeof(cpu_subfunc.dfltcc), test_dfltcc_asm_block, 151 },
	/* Concurrent-function facility - Facility bit 201 */
	{ "PFCR", cpu_subfunc.pfcr, sizeof(cpu_subfunc.pfcr), test_pfcr_asm_block, 201 },
	};

	int main(int argc, char *argv[])
	{
	struct kvm_vm *vm;
	int idx;

	ksft_print_header();

	vm = vm_create(1);

	memset(&cpu_subfunc, 0, sizeof(cpu_subfunc));
	get_cpu_machine_subfuntions(vm, &cpu_subfunc);

	ksft_set_plan(ARRAY_SIZE(testlist));
	for (idx = 0; idx < ARRAY_SIZE(testlist); idx++) {
	if (test_facility(testlist[idx].facility_bit)) {
	u8 *array = malloc(testlist[idx].array_size);

	testlist[idx].test((u8 (*)[testlist[idx].array_size])array);

	TEST_ASSERT_EQ(memcmp(testlist[idx].subfunc_array,
	array, testlist[idx].array_size), 0);

	ksft_test_result_pass("%s\n", testlist[idx].subfunc_name);
	free(array);
	} else {
	ksft_test_result_skip("%s feature is not available\n",
	testlist[idx].subfunc_name);
	}
	}

	kvm_vm_free(vm);
	ksft_finished();
	}