xref: /kvm-unit-tests/s390x/sclp.c (revision 9cab58249f98adc451933530fd7e618e1856eb94)
1  /* SPDX-License-Identifier: GPL-2.0-only */
2  /*
3   * Service Call tests
4   *
5   * Copyright (c) 2020 IBM Corp
6   *
7   * Authors:
8   *  Claudio Imbrenda <imbrenda@linux.ibm.com>
9   */
10  
11  #include <libcflat.h>
12  #include <asm/page.h>
13  #include <asm/asm-offsets.h>
14  #include <asm/interrupt.h>
15  #include <sclp.h>
16  
17  #define PGM_NONE	1
18  #define PGM_BIT_SPEC	(1ULL << PGM_INT_CODE_SPECIFICATION)
19  #define PGM_BIT_ADDR	(1ULL << PGM_INT_CODE_ADDRESSING)
20  #define PGM_BIT_PRIV	(1ULL << PGM_INT_CODE_PRIVILEGED_OPERATION)
21  #define MKPTR(x) ((void *)(uint64_t)(x))
22  
23  #define LC_SIZE (2 * PAGE_SIZE)
24  
25  static uint8_t pagebuf[LC_SIZE] __attribute__((aligned(LC_SIZE)));	/* scratch pages used for some tests */
26  static uint8_t prefix_buf[LC_SIZE] __attribute__((aligned(LC_SIZE)));	/* temporary lowcore for test_sccb_prefix */
27  /* SCCB template to be used */
28  static union {
29  	uint8_t raw[PAGE_SIZE];
30  	SCCBHeader header;
31  	WriteEventData data;
32  } sccb_template;
33  static uint32_t valid_code;						/* valid command code for READ SCP INFO */
34  
35  /*
36   * Perform one service call, handling exceptions and interrupts.
37   */
sclp_service_call_test(unsigned int command,void * sccb)38  static int sclp_service_call_test(unsigned int command, void *sccb)
39  {
40  	int cc;
41  
42  	sclp_mark_busy();
43  	sclp_setup_int();
44  	cc = servc(command, __pa(sccb));
45  	if (lowcore.pgm_int_code) {
46  		sclp_handle_ext();
47  		return 0;
48  	}
49  	if (!cc)
50  		sclp_wait_busy();
51  	return cc;
52  }
53  
54  /*
55   * Perform one test at the given address, optionally using the SCCB template,
56   * checking for the expected program interrupts and return codes.
57   *
58   * The parameter buf_len indicates the number of bytes of the template that
59   * should be copied to the test address, and should be 0 when the test
60   * address is invalid, in which case nothing is copied.
61   *
62   * The template is used to simplify tests where the same buffer content is
63   * used many times in a row, at different addresses.
64   *
65   * Returns true in case of success or false in case of failure
66   */
test_one_sccb(uint32_t cmd,uint8_t * addr,uint16_t buf_len,uint64_t exp_pgm,uint16_t exp_rc)67  static bool test_one_sccb(uint32_t cmd, uint8_t *addr, uint16_t buf_len, uint64_t exp_pgm, uint16_t exp_rc)
68  {
69  	SCCBHeader *h = (SCCBHeader *)addr;
70  	int res, pgm;
71  
72  	/* Copy the template to the test address if needed */
73  	if (buf_len)
74  		memcpy(addr, sccb_template.raw, buf_len);
75  	if (exp_pgm != PGM_NONE)
76  		expect_pgm_int();
77  	/* perform the actual call */
78  	res = sclp_service_call_test(cmd, h);
79  	if (res) {
80  		report_info("SCLP not ready (command %#x, address %p, cc %d)", cmd, addr, res);
81  		return false;
82  	}
83  	pgm = clear_pgm_int();
84  	/* Check if the program exception was one of the expected ones */
85  	if (!((1ULL << pgm) & exp_pgm)) {
86  		report_info("First failure at addr %p, buf_len %d, cmd %#x, pgm code %d",
87  				addr, buf_len, cmd, pgm);
88  		return false;
89  	}
90  	/* Check if the response code is the one expected */
91  	if (exp_rc && exp_rc != h->response_code) {
92  		report_info("First failure at addr %p, buf_len %d, cmd %#x, resp code %#x",
93  				addr, buf_len, cmd, h->response_code);
94  		return false;
95  	}
96  	return true;
97  }
98  
99  /*
100   * Wrapper for test_one_sccb to be used when the template should not be
101   * copied and the memory address should not be touched.
102   */
test_one_ro(uint32_t cmd,uint8_t * addr,uint64_t exp_pgm,uint16_t exp_rc)103  static bool test_one_ro(uint32_t cmd, uint8_t *addr, uint64_t exp_pgm, uint16_t exp_rc)
104  {
105  	return test_one_sccb(cmd, addr, 0, exp_pgm, exp_rc);
106  }
107  
108  /*
109   * Wrapper for test_one_sccb to set up a simple SCCB template.
110   *
111   * The parameter sccb_len indicates the value that will be saved in the SCCB
112   * length field of the SCCB, buf_len indicates the number of bytes of
113   * template that need to be copied to the actual test address. In many cases
114   * it's enough to clear/copy the first 8 bytes of the buffer, while the SCCB
115   * itself can be larger.
116   *
117   * Returns true in case of success or false in case of failure
118   */
test_one_simple(uint32_t cmd,uint8_t * addr,uint16_t sccb_len,uint16_t buf_len,uint64_t exp_pgm,uint16_t exp_rc)119  static bool test_one_simple(uint32_t cmd, uint8_t *addr, uint16_t sccb_len,
120  			uint16_t buf_len, uint64_t exp_pgm, uint16_t exp_rc)
121  {
122  	memset(sccb_template.raw, 0, sizeof(sccb_template.raw));
123  	sccb_template.header.length = sccb_len;
124  	return test_one_sccb(cmd, addr, buf_len, exp_pgm, exp_rc);
125  }
126  
127  /*
128   * Test SCCB lengths < 8.
129   */
test_sccb_too_short(void)130  static void test_sccb_too_short(void)
131  {
132  	int len;
133  
134  	for (len = 0; len < 8; len++)
135  		if (!test_one_simple(valid_code, pagebuf, len, 8, PGM_BIT_SPEC, 0))
136  			break;
137  
138  	report(len == 8, "SCCB too short");
139  }
140  
141  /*
142   * Test SCCBs that are not 64-bit aligned.
143   */
test_sccb_unaligned(void)144  static void test_sccb_unaligned(void)
145  {
146  	int offset;
147  
148  	for (offset = 1; offset < 8; offset++)
149  		if (!test_one_simple(valid_code, offset + pagebuf, 8, 8, PGM_BIT_SPEC, 0))
150  			break;
151  	report(offset == 8, "SCCB unaligned");
152  }
153  
154  /*
155   * Test SCCBs whose address is in the lowcore or prefix area.
156   */
test_sccb_prefix(void)157  static void test_sccb_prefix(void)
158  {
159  	uint8_t scratch[LC_SIZE];
160  	uint32_t prefix, new_prefix;
161  	int offset;
162  
163  	/*
164  	 * copy the current lowcore to the future new location, otherwise we
165  	 * will not have a valid lowcore after setting the new prefix.
166  	 */
167  	memcpy(prefix_buf, 0, LC_SIZE);
168  	/* save the current prefix (it's probably going to be 0) */
169  	prefix = get_prefix();
170  	/*
171  	 * save the current content of absolute pages 0 and 1, so we can
172  	 * restore them after we trash them later on
173  	 */
174  	memcpy(scratch, (void *)(intptr_t)prefix, LC_SIZE);
175  	/* set the new prefix to prefix_buf */
176  	new_prefix = (uint32_t)(intptr_t)prefix_buf;
177  	set_prefix(new_prefix);
178  
179  	/*
180  	 * testing with SCCB addresses in the lowcore; since we can't
181  	 * actually trash the lowcore (unsurprisingly, things break if we
182  	 * do), this will be a read-only test.
183  	 */
184  	for (offset = 0; offset < LC_SIZE; offset += 8)
185  		if (!test_one_ro(valid_code, MKPTR(offset), PGM_BIT_SPEC, 0))
186  			break;
187  	report(offset == LC_SIZE, "SCCB low pages");
188  
189  	/*
190  	 * the SCLP should not even touch the memory, but we will write the
191  	 * SCCBs all over the two pages starting at absolute address 0, thus
192  	 * trashing them; we will need to restore them later.
193  	 */
194  	for (offset = 0; offset < LC_SIZE; offset += 8)
195  		if (!test_one_simple(valid_code, MKPTR(new_prefix + offset), 8, 8, PGM_BIT_SPEC, 0))
196  			break;
197  	report(offset == LC_SIZE, "SCCB prefix pages");
198  
199  	/* restore the previous contents of absolute pages 0 and 1 */
200  	memcpy(prefix_buf, 0, LC_SIZE);
201  	/* restore the prefix to the original value */
202  	set_prefix(prefix);
203  }
204  
205  /*
206   * Test SCCBs that are above 2GB. If outside of memory, an addressing
207   * exception is also allowed.
208   */
test_sccb_high(void)209  static void test_sccb_high(void)
210  {
211  	SCCBHeader *h = (SCCBHeader *)pagebuf;
212  	uintptr_t a[33 * 4 * 2 + 2];	/* for the list of addresses to test */
213  
214  	uint64_t maxram;
215  	int i, pgm, len = 0;
216  
217  	h->length = 8;
218  	/* addresses with 1 bit set in the first 33 bits */
219  	for (i = 0; i < 33; i++)
220  		a[len++] = 1UL << (i + 31);
221  	/* addresses with 2 consecutive bits set in the first 33 bits */
222  	for (i = 0; i < 33; i++)
223  		a[len++] = 3UL << (i + 31);
224  	/* addresses with all bits set in bits 0..N */
225  	for (i = 0; i < 33; i++)
226  		a[len++] = 0xffffffff80000000UL << i;
227  	/* addresses with all bits set in bits N..33 */
228  	a[len++] = 0x80000000;
229  	for (i = 1; i < 33; i++, len++)
230  		a[len] = a[len - 1] | (1UL << (i + 31));
231  	/* all the addresses above, but adding the offset of a valid buffer */
232  	for (i = 0; i < len; i++)
233  		a[len + i] = a[i] + (intptr_t)h;
234  	len += i;
235  	/* two more hand-crafted addresses */
236  	a[len++] = 0xdeadbeef00000000;
237  	a[len++] = 0xdeaddeadbeef0000;
238  
239  	maxram = get_ram_size();
240  	for (i = 0; i < len; i++) {
241  		pgm = PGM_BIT_SPEC | (a[i] >= maxram ? PGM_BIT_ADDR : 0);
242  		if (!test_one_ro(valid_code, (void *)a[i], pgm, 0))
243  			break;
244  	}
245  	report(i == len, "SCCB high addresses");
246  }
247  
248  /*
249   * Test invalid commands, both invalid command detail codes and valid
250   * ones with invalid command class code.
251   */
test_inval(void)252  static void test_inval(void)
253  {
254  	const uint16_t res = SCLP_RC_INVALID_SCLP_COMMAND;
255  	uint32_t cmd;
256  	int i;
257  
258  	report_prefix_push("Invalid command");
259  	for (i = 0; i < 65536; i++) {
260  		cmd = 0xdead0000 | i;
261  		if (!test_one_simple(cmd, pagebuf, PAGE_SIZE, PAGE_SIZE, PGM_NONE, res))
262  			break;
263  	}
264  	report(i == 65536, "Command detail code");
265  
266  	for (i = 0; i < 256; i++) {
267  		cmd = (valid_code & ~0xff) | i;
268  		if (cmd == valid_code)
269  			continue;
270  		if (!test_one_simple(cmd, pagebuf, PAGE_SIZE, PAGE_SIZE, PGM_NONE, res))
271  			break;
272  	}
273  	report(i == 256, "Command class code");
274  	report_prefix_pop();
275  }
276  
277  
278  /*
279   * Test short SCCBs (but larger than 8).
280   */
test_short(void)281  static void test_short(void)
282  {
283  	const uint16_t res = SCLP_RC_INSUFFICIENT_SCCB_LENGTH;
284  	int len;
285  
286  	for (len = 8; len < 144; len++)
287  		if (!test_one_simple(valid_code, pagebuf, len, len, PGM_NONE, res))
288  			break;
289  	report(len == 144, "Insufficient SCCB length (Read SCP info)");
290  
291  	for (len = 8; len < 40; len++)
292  		if (!test_one_simple(SCLP_READ_CPU_INFO, pagebuf, len, len, PGM_NONE, res))
293  			break;
294  	report(len == 40, "Insufficient SCCB length (Read CPU info)");
295  }
296  
297  /*
298   * Test SCCB page boundary violations.
299   */
test_boundary(void)300  static void test_boundary(void)
301  {
302  	const uint32_t cmd = SCLP_CMD_WRITE_EVENT_DATA;
303  	const uint16_t res = SCLP_RC_SCCB_BOUNDARY_VIOLATION;
304  	WriteEventData *sccb = &sccb_template.data;
305  	int len, offset;
306  
307  	memset(sccb_template.raw, 0, sizeof(sccb_template.raw));
308  	sccb->h.function_code = SCLP_FC_NORMAL_WRITE;
309  	for (len = 32; len <= 4096; len++) {
310  		offset = len & 7 ? len & ~7 : len - 8;
311  		for (offset = 4096 - offset; offset < 4096; offset += 8) {
312  			sccb->h.length = len;
313  			if (!test_one_sccb(cmd, offset + pagebuf, len, PGM_NONE, res))
314  				goto out;
315  		}
316  	}
317  out:
318  	report(len > 4096 && offset == 4096, "SCCB page boundary violation");
319  }
320  
321  /*
322   * Test excessively long SCCBs.
323   */
test_toolong(void)324  static void test_toolong(void)
325  {
326  	const uint32_t cmd = SCLP_CMD_WRITE_EVENT_DATA;
327  	const uint16_t res = SCLP_RC_SCCB_BOUNDARY_VIOLATION;
328  	WriteEventData *sccb = &sccb_template.data;
329  	int len;
330  
331  	memset(sccb_template.raw, 0, sizeof(sccb_template.raw));
332  	sccb->h.function_code = SCLP_FC_NORMAL_WRITE;
333  	for (len = 4097; len < 8192; len++) {
334  		sccb->h.length = len;
335  		if (!test_one_sccb(cmd, pagebuf, PAGE_SIZE, PGM_NONE, res))
336  			break;
337  	}
338  	report(len == 8192, "SCCB bigger than 4k");
339  }
340  
341  /*
342   * Test privileged operation.
343   */
test_priv(void)344  static void test_priv(void)
345  {
346  	SCCBHeader *h = (SCCBHeader *)pagebuf;
347  
348  	report_prefix_push("Privileged operation");
349  	h->length = 8;
350  	expect_pgm_int();
351  	enter_pstate();
352  	servc(valid_code, __pa(h));
353  	check_pgm_int_code(PGM_INT_CODE_PRIVILEGED_OPERATION);
354  	report_prefix_pop();
355  }
356  
357  /*
358   * Test addressing exceptions. We need to test SCCB addresses between the
359   * end of available memory and 2GB, because after 2GB a specification
360   * exception is also allowed.
361   * Only applicable if the VM has less than 2GB of memory
362   */
test_addressing(void)363  static void test_addressing(void)
364  {
365  	unsigned long i, maxram = get_ram_size();
366  
367  	/* the VM has more than 2GB of memory */
368  	if (maxram >= 0x80000000) {
369  		report_skip("Invalid SCCB address");
370  		return;
371  	}
372  	/* test all possible valid addresses immediately after the end of memory
373  	 * up to 64KB after the end of memory
374  	 */
375  	for (i = 0; i < 0x10000 && i + maxram < 0x80000000; i += 8)
376  		if (!test_one_ro(valid_code, MKPTR(i + maxram), PGM_BIT_ADDR, 0))
377  			goto out;
378  	/* test more addresses until we reach 1MB after end of memory;
379  	 * increment by a prime number (times 8) in order to test all
380  	 * possible valid offsets inside pages
381  	 */
382  	for (; i < 0x100000 && i + maxram < 0x80000000 ; i += 808)
383  		if (!test_one_ro(valid_code, MKPTR(i + maxram), PGM_BIT_ADDR, 0))
384  			goto out;
385  	/* test the remaining addresses until we reach address 2GB;
386  	 * increment by a prime number (times 8) in order to test all
387  	 * possible valid offsets inside pages
388  	 */
389  	for (; i + maxram < 0x80000000; i += 800024)
390  		if (!test_one_ro(valid_code, MKPTR(i + maxram), PGM_BIT_ADDR, 0))
391  			goto out;
392  out:
393  	report(i + maxram >= 0x80000000, "Invalid SCCB address");
394  }
395  
396  /*
397   * Test some bits in the instruction format that are specified to be ignored.
398   */
test_instbits(void)399  static void test_instbits(void)
400  {
401  	SCCBHeader *h = (SCCBHeader *)pagebuf;
402  	uint64_t bogus_cc = 1;
403  	int cc;
404  
405  	sclp_mark_busy();
406  	h->length = 8;
407  	sclp_setup_int();
408  
409  	asm volatile(
410  		"	tmll	%[bogus_cc],3\n"
411  		"       .insn   rre,0xb2204200,%1,%2\n"  /* servc %1,%2 */
412  		"       ipm     %0\n"
413  		"       srl     %0,28"
414  		: "=&d" (cc)
415  		: "d" (valid_code), "a" (__pa(pagebuf)), [bogus_cc] "d" (bogus_cc)
416  		: "cc", "memory");
417  	/* No exception, but also no command accepted, so no interrupt is
418  	 * expected. We need to clear the flag manually otherwise we will
419  	 * loop forever when we try to report failure.
420  	 */
421  	if (cc)
422  		sclp_handle_ext();
423  	else
424  		sclp_wait_busy();
425  	report(cc == 0, "Instruction format ignored bits");
426  }
427  
428  /*
429   * Find a valid READ INFO command code; not all codes are always allowed, and
430   * probing should be performed in the right order.
431   */
find_valid_sclp_code(void)432  static void find_valid_sclp_code(void)
433  {
434  	const unsigned int commands[] = { SCLP_CMDW_READ_SCP_INFO_FORCED,
435  					  SCLP_CMDW_READ_SCP_INFO };
436  	SCCBHeader *h = (SCCBHeader *)pagebuf;
437  	int i, cc;
438  
439  	for (i = 0; i < ARRAY_SIZE(commands); i++) {
440  		sclp_mark_busy();
441  		memset(h, 0, sizeof(*h));
442  		h->length = 4096;
443  
444  		valid_code = commands[i];
445  		cc = sclp_service_call(commands[i], h);
446  		if (cc)
447  			break;
448  		if (h->response_code == SCLP_RC_NORMAL_READ_COMPLETION)
449  			return;
450  		if (h->response_code != SCLP_RC_INVALID_SCLP_COMMAND)
451  			break;
452  	}
453  	report_abort("READ_SCP_INFO failed");
454  }
455  
main(void)456  int main(void)
457  {
458  	report_prefix_push("sclp");
459  	find_valid_sclp_code();
460  
461  	/* Test some basic things */
462  	test_instbits();
463  	test_priv();
464  	test_addressing();
465  
466  	/* Test the specification exceptions */
467  	test_sccb_too_short();
468  	test_sccb_unaligned();
469  	test_sccb_prefix();
470  	test_sccb_high();
471  
472  	/* Test the expected response codes */
473  	test_inval();
474  	test_short();
475  	test_boundary();
476  	test_toolong();
477  
478  	return report_summary();
479  }
480