diff options
Diffstat (limited to 'tests-m32/s390_sthyi.c')
| -rw-r--r-- | tests-m32/s390_sthyi.c | 786 |
1 files changed, 786 insertions, 0 deletions
diff --git a/tests-m32/s390_sthyi.c b/tests-m32/s390_sthyi.c new file mode 100644 index 00000000..8b241dd2 --- /dev/null +++ b/tests-m32/s390_sthyi.c @@ -0,0 +1,786 @@ +/* + * Check decoding of s390_sthyi syscall. + * + * Copyright (c) 2018 The strace developers. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "tests.h" +#include <asm/unistd.h> + +#if defined HAVE_ICONV_H && defined HAVE_ICONV_OPEN && defined __NR_s390_sthyi + +# include <errno.h> +# include <iconv.h> +# include <inttypes.h> +# include <stdbool.h> +# include <stdint.h> +# include <stdio.h> +# include <unistd.h> + +# include <sys/user.h> + +# define EBCDIC_MAX_LEN 16 + +# ifndef VERBOSE +# define VERBOSE 0 +# endif + +static bool +print_0x8(const char *prefix, unsigned char *buf, unsigned int offs, bool zero) +{ + if (!zero && !buf[offs]) + return false; + + printf("%s=%#02hhx", prefix, buf[offs]); + + return true; +} + +static bool +print_u8(const char *prefix, unsigned char *buf, unsigned int offs, bool zero) +{ + if (!zero && !buf[offs]) + return false; + + printf("%s=%hhu", prefix, buf[offs]); + + return true; +} + +static bool +print_u16(const char *prefix, unsigned char *buf, unsigned int offs, bool zero) +{ + uint16_t val = *(uint16_t *) (buf + offs); + + if (!zero && !val) + return false; + + printf("%s=%" PRIu16, prefix, val); + + return true; +} + +static bool +print_x32(const char *prefix, unsigned char *buf, unsigned int offs, bool zero) +{ + uint32_t val = *(uint32_t *) (buf + offs); + + if (!zero && !val) + return false; + + printf("%s=%#" PRIx32, prefix, val); + + return true; +} + +static bool +print_weight(const char *prefix, unsigned char *buf, unsigned int offs, + bool zero) +{ + uint32_t val = *(uint32_t *) (buf + offs); + + if (print_x32(prefix, buf, offs, zero)) { + if (val) + printf(" /* %u %u/65536 cores */", + val >> 16, val & 0xFFFF); + else + printf(" /* unlimited */"); + + return true; + } + + return false; +} + +static char * +ebcdic2ascii(unsigned char *ebcdic, size_t size) +{ + static char ascii_buf[EBCDIC_MAX_LEN]; + + char *ebcdic_pos = (char *) ebcdic; + char *ascii_pos = ascii_buf; + size_t ebcdic_left = size; + size_t ascii_left = size; + size_t ret; + + iconv_t cd = iconv_open("ASCII", "EBCDICUS"); + + if (size > sizeof(ascii_buf)) + error_msg_and_fail("ebcdic2ascii: EBCDIC string is too big: " + "%zu (maximum is %zu)", + size, sizeof(ascii_buf)); + if (cd == (iconv_t) -1) + perror_msg_and_fail("ebcdic2ascii: unable to allocate a " + "conversion descriptior for converting " + "EBCDIC to ASCII"); + + while ((ret = iconv(cd, &ebcdic_pos, &ebcdic_left, + &ascii_pos, &ascii_left)) == (size_t) -1) { + switch (errno) { + case EILSEQ: + case EINVAL: /* That one is quite unexpected, actually */ + if (!ebcdic_left || !ascii_left) + goto ebcdic2ascii_end; + + *ascii_pos++ = ' '; + ebcdic_pos++; + ebcdic_left--; + + break; + + case E2BIG: + perror_msg_and_fail("ebcdic2ascii: ran out of " + "ASCII buffer unexpectedly"); + default: + perror_msg_and_fail("ebcdic2ascii: unexpected error"); + } + } + +ebcdic2ascii_end: + iconv_close(cd); + + if (ebcdic_left != ascii_left) + error_msg_and_fail("ebcdic2ascii: ASCII string differs in size " + "from EBCDIC"); + + return ascii_buf; +} + +# if VERBOSE +static bool +is_empty(unsigned char *ptr, size_t size) +{ + size_t i; + + for (i = 0; !*ptr && i < size; ptr++, i++) + ; + + return i == size; +} +# endif /* !VERBOSE */ + +static bool +print_ebcdic(const char *prefix, unsigned char *addr, unsigned int offs, + size_t size, bool zero, bool blank) +{ + const char *ascii = ebcdic2ascii(addr + offs, size); + + if (!zero) { + size_t i; + + for (i = 0; (addr[offs + i] == (blank ? 64 : 0)) && (i < size); + i++) + ; + + if (i == size) + return false; + } + + printf("%s=", prefix); + print_quoted_hex((char *) (addr + offs), size); + printf(" /* "); + print_quoted_memory(ascii, size); + printf(" */"); + + return true; +} + +static void +print_hypervisor_header(unsigned char *buf, int level, unsigned int offs_pos, + unsigned int len_pos, bool mt) +{ + uint16_t offs = *(uint16_t *) (buf + offs_pos); + uint16_t hdr_size = *(uint16_t *) (buf + len_pos); + unsigned char *cur; + + if (!offs) + return; + if (hdr_size < 32) + error_msg_and_fail("sthyi: hypervisor %d section is too small " + "(got %hu, 32 expected)", level, hdr_size); + + cur = buf + offs; + + printf(", /* hypervisor %d */ {infyflg1", level); + print_0x8("", cur, 0, true); +# if VERBOSE + if (cur[0]) { + bool printed = false; + + printf(" /* "); + if (cur[0] & 0x80) { + printf("0x80 - guest CPU usage had limiting is using " + "the consumption method"); + printed = true; + } + if (cur[0] & 0x40) { + if (printed) + printf(", "); + printf("0x40 - LIMITHARD caps use prorated core time " + "for capping"); + printed = true; + } + if (cur[0] & 0x3F) { + if (printed) + printf(", "); + printf("%#hhx - ???", cur[0] & 0x3F); + } + printf(" */"); + } + + print_0x8(", infyflg2", cur, 1, false); + print_0x8(", infyval1", cur, 2, false); + print_0x8(", infyval2", cur, 3, false); + + print_u8(", infytype", cur, 4, true); + if (cur[4] == 1) + printf(" /* z/VM is the hypervisor */"); + else + printf(" /* unknown hypervisor type */"); + + if (cur[5]) + printf(", reserved_1__=\"\\x%#02hhx\"", cur[5]); + + print_u8(", infycpt", cur, 6, mt); + print_u8(", infyiflt", cur, 7, mt); +# endif /* !VERBOSE */ + + print_ebcdic(", infysyid", cur, 8, 8, VERBOSE, true); + print_ebcdic(", infyclnm", cur, 16, 8, VERBOSE, true); + + print_u16(", infyscps", cur, 24, VERBOSE); + print_u16(", infydcps", cur, 26, VERBOSE); + print_u16(", infysifl", cur, 28, VERBOSE); + print_u16(", infydifl", cur, 30, VERBOSE); + +# if VERBOSE + if (hdr_size > 32 && !is_empty(cur + 32, hdr_size - 32)) { + printf(", "); + print_quoted_hex((char *) (cur + 32), hdr_size - 32); + } +# else /* !VERBOSE */ + printf(", ..."); +# endif /* !VERBOSE */ + + printf("}"); +} + +static void +print_guest_header(unsigned char *buf, int level, unsigned int offs_pos, + unsigned int len_pos) +{ + uint16_t offs = *(uint16_t *) (buf + offs_pos); + uint16_t hdr_size = *(uint16_t *) (buf + len_pos); + unsigned char *cur; + + if (!offs) + return; + if (hdr_size < 56) + error_msg_and_fail("sthyi: guest %d section is too small " + "(got %hu, 56 expected)", level, hdr_size); + + cur = buf + offs; + + printf(", /* guest %d */ {infgflg1", level); + print_0x8("", cur, 0, true); +# if VERBOSE + if (cur[0]) { + bool printed = false; + + printf(" /* "); + if (cur[0] & 0x80) { + printf("0x80 - guest is mobility enabled"); + printed = true; + } + if (cur[0] & 0x40) { + if (printed) + printf(", "); + printf("0x40 - guest has multiple virtual CPU types"); + printed = true; + } + if (cur[0] & 0x20) { + if (printed) + printf(", "); + printf("0x20 - guest CP dispatch type has LIMITHARD " + "cap"); + printed = true; + } + if (cur[0] & 0x10) { + if (printed) + printf(", "); + printf("0x10 - guest IFL dispatch type has LIMITHARD " + "cap"); + printed = true; + } + if (cur[0] & 0x08) { + if (printed) + printf(", "); + printf("0x08 - virtual CPs are thread dispatched"); + printed = true; + } + if (cur[0] & 0x04) { + if (printed) + printf(", "); + printf("0x04 - virtual IFLs are thread dispatched"); + printed = true; + } + if (cur[0] & 0x3) { + if (printed) + printf(", "); + printf("%#hhx - ???", cur[0] & 0x3); + } + printf(" */"); + } + + print_0x8(", infgflg2", cur, 1, false); + print_0x8(", infgval1", cur, 2, false); + print_0x8(", infgval2", cur, 3, false); +# endif /* !VERBOSE */ + + print_ebcdic(", infgusid", cur, 4, 8, true, false); + + print_u16(", infgscps", cur, 12, VERBOSE); + print_u16(", infgdcps", cur, 14, VERBOSE); + +# if VERBOSE + print_u8(", infgcpdt", cur, 16, true); + if (cur[16] == 0) + printf(" /* General Purpose (CP) */"); + else + printf(" /* unknown */"); + + if (cur[17] || cur[18] || cur[19]) + printf(", reserved_1__=\"\\x%#02hhx\\x%#02hhx\\x%#02hhx\"", + cur[17], cur[18], cur[19]); +# endif /* !VERBOSE */ + + print_weight(", infgcpcc", cur, 20, VERBOSE); + + print_u16(", infgsifl", cur, 24, VERBOSE); + print_u16(", infgdifl", cur, 26, VERBOSE); + +# if VERBOSE + print_u8(", infgifdt", cur, 28, true); + if (cur[28] == 0) + printf(" /* General Purpose (CP) */"); + else if (cur[28] == 3) + printf(" /* Integrated Facility for Linux (IFL) */"); + else + printf(" /* unknown */"); + + if (cur[29] || cur[30] || cur[31]) + printf(", reserved_2__=\"\\x%#02hhx\\x%#02hhx\\x%#02hhx\"", + cur[29], cur[30], cur[31]); +# endif /* !VERBOSE */ + + print_weight(", infgifcc", cur, 32, VERBOSE); + + print_0x8(", infgpflg", cur, 36, true); +# if VERBOSE + if (cur[36]) { + bool printed = false; + + printf(" /* "); + if (cur[36] & 0x80) { + printf("0x80 - CPU pool's CP virtual type has " + "LIMITHARD cap"); + printed = true; + } + if (cur[36] & 0x40) { + if (printed) + printf(", "); + printf("0x40 - CPU pool's CP virtual type has " + "CAPACITY cap"); + printed = true; + } + if (cur[36] & 0x20) { + if (printed) + printf(", "); + printf("0x20 - CPU pool's IFL virtual type has " + "LIMITHARD cap"); + printed = true; + } + if (cur[36] & 0x10) { + if (printed) + printf(", "); + printf("0x10 - CPU pool's IFL virtual type has " + "CAPACITY cap"); + printed = true; + } + if (cur[36] & 0x08) { + if (printed) + printf(", "); + printf("0x08 - CPU pool uses prorated core time"); + printed = true; + } + if (cur[36] & 0x7) { + if (printed) + printf(", "); + printf("%#hhx - ???", cur[36] & 0x7); + } + printf(" */"); + } + + if (cur[37] || cur[38] || cur[39]) + printf(", reserved_3__=\"\\x%#02hhx\\x%#02hhx\\x%#02hhx\"", + cur[37], cur[38], cur[39]); + + print_ebcdic(", infgpnam", cur, 40, 8, false, true); + + print_weight(", infgpccc", cur, 48, true); + print_weight(", infgpicc", cur, 52, true); + + if (hdr_size > 56 && !is_empty(cur + 56, hdr_size - 56)) { + printf(", "); + print_quoted_hex((char *) (cur + 56), hdr_size - 56); + } +# else /* !VERBOSE */ + printf(", ..."); +# endif /* !VERBOSE */ + + printf("}"); +} + +static void +print_sthyi(unsigned char *buf) +{ + unsigned char *cur; + uint16_t hdr_size; + uint16_t offs; + bool mt = false; + + hdr_size = *(uint16_t *) (buf + 10); + if (hdr_size < 44) + error_msg_and_fail("sthyi: header section is too small " + "(got %hu, 44 expected)", hdr_size); + + /* INFHFLG1 */ + print_0x8("{/* header */ {infhflg1", buf, 0, true); +# if VERBOSE + if (buf[0]) { + bool printed = false; + + printf(" /* "); + if (buf[0] & 0x80) { + printf("0x80 - Global Performance Data unavailable"); + printed = true; + } + if (buf[0] & 0x40) { + if (printed) + printf(", "); + printf("0x40 - One or more hypervisor levels below " + "this level does not support the STHYI " + "instruction"); + printed = true; + } + if (buf[0] & 0x20) { + if (printed) + printf(", "); + printf("0x20 - Virtualization stack is incomplete"); + printed = true; + } + if (buf[0] & 0x10) { + if (printed) + printf(", "); + printf("0x10 - Execution environment is not within a " + "logical partition"); + printed = true; + } + if (buf[0] & 0xF) { + if (printed) + printf(", "); + printf("%#hhx - ???", buf[0] & 0xF); + } + printf(" */"); + } + + print_0x8(", infhflg2", buf, 1, false); + print_0x8(", infhval1", buf, 2, false); + print_0x8(", infhval2", buf, 3, false); + + /* Reserved */ + if (buf[4] || buf[5] || buf[6]) + printf(", reserved_1__=\"\\x%#02hhx\\x%#02hhx\\x%#02hhx\"", + buf[4], buf[5], buf[6]); + + print_u8(", infhygct", buf, 7, true); + print_u16(", infhtotl", buf, 8, true); + print_u16(", infhdln", buf, 10, true); + print_u16(", infmoff", buf, 12, true); + print_u16(", infmlen", buf, 14, true); + print_u16(", infpoff", buf, 16, true); + print_u16(", infplen", buf, 18, true); + print_u16(", infhoff1", buf, 20, true); + print_u16(", infhlen1", buf, 22, true); + print_u16(", infgoff1", buf, 24, true); + print_u16(", infglen1", buf, 26, true); + print_u16(", infhoff2", buf, 28, true); + print_u16(", infhlen2", buf, 30, true); + print_u16(", infgoff2", buf, 32, true); + print_u16(", infglen2", buf, 34, true); + print_u16(", infhoff3", buf, 36, true); + print_u16(", infhlen3", buf, 38, true); + print_u16(", infgoff3", buf, 40, true); + print_u16(", infglen3", buf, 42, true); + + if (hdr_size > 44 && !is_empty(buf + 44, hdr_size - 44)) { + printf(", "); + print_quoted_hex((char *) (buf + 44), hdr_size - 44); + } +# else /* !VERBOSE */ + printf(", ..."); +# endif /* !VERBOSE */ + + printf("}"); + + /* Machine header */ + offs = *(uint16_t *) (buf + 12); + if (!offs) + goto partition_hdr; + + hdr_size = *(uint16_t *) (buf + 14); + if (hdr_size < 60) + error_msg_and_fail("sthyi: machine section is too small " + "(got %hu, 60 expected)", hdr_size); + + cur = buf + offs; + + printf(", /* machine */ {"); + +# if VERBOSE + print_0x8("infmflg1", cur, 0, false); + if (cur[0]) + printf(", "); + print_0x8("infmflg2", cur, 1, false); + if (cur[1]) + printf(", "); +# endif /* !VERBOSE */ + print_0x8("infmval1", cur, 2, true); + + bool cnt_valid = cur[2] & 0x80; +# if VERBOSE + bool id_valid = cur[2] & 0x40; + bool name_valid = cur[2] & 0x20; + + printf(" /* processor count validity: %d, machine ID validity: %d, " + "machine name validity: %d", + !!cnt_valid, !!id_valid, !!name_valid); + if (cur[2] & 0x1F) + printf(", %#hhx - ???", cur[2] & 0x1F); + printf(" */"); + print_0x8(", infmval2", cur, 3, false); +# endif /* !VERBOSE */ + + print_u16(", infmscps", cur, 4, cnt_valid); + print_u16(", infmdcps", cur, 6, cnt_valid); + print_u16(", infmsifl", cur, 8, cnt_valid); + print_u16(", infmdifl", cur, 10, cnt_valid); + +# if VERBOSE + print_ebcdic(", infmname", cur, 12, 8, name_valid, false); + + print_ebcdic(", infmtype", cur, 20, 4, id_valid, false); + print_ebcdic(", infmmanu", cur, 24, 16, id_valid, false); + print_ebcdic(", infmseq", cur, 40, 16, id_valid, false); + print_ebcdic(", infmpman", cur, 56, 4, id_valid, false); + + if (hdr_size > 60 && !is_empty(cur + 60, hdr_size - 60)) { + printf(", "); + print_quoted_hex((char *) (cur + 60), hdr_size - 60); + } +# else /* !VERBOSE */ + printf(", ..."); +# endif /* !VERBOSE */ + + printf("}"); + +partition_hdr: + /* Partition header */ + offs = *(uint16_t *) (buf + 16); + if (!offs) + goto hv_hdr; + + hdr_size = *(uint16_t *) (buf + 18); + if (hdr_size < 56) + error_msg_and_fail("sthyi: partition section is too small " + "(got %hu, 56 expected)", hdr_size); + + cur = buf + offs; + + print_0x8(", /* partition */ {infpflg1", cur, 0, true); + mt = !!(cur[0] & 0x80); +# if VERBOSE + if (cur[0]) { + bool printed = false; + + printf(" /* "); + if (cur[0] & 0x80) { + printf("0x80 - multithreading is enabled"); + printed = true; + } + if (cur[0] & 0x7F) { + if (printed) + printf(", "); + printf("%#hhx - ???", cur[0] & 0x7F); + } + printf(" */"); + } + print_0x8(", infpflg2", cur, 1, false); +# endif /* !VERBOSE */ + print_0x8(", infpval1", cur, 2, true); + + bool pcnt_valid = cur[2] & 0x80; + bool pid_valid = cur[2] & 0x10; +# if VERBOSE + bool pwcap_valid = cur[2] & 0x40; + bool pacap_valid = cur[2] & 0x20; + bool lpar_valid = cur[2] & 0x08; +# endif /* !VERBOSE */ + +# if VERBOSE + printf(" /* processor count validity: %d, partition weight-based " + "capacity validity: %d, partition absolute capacity validity: " + "%d, partition ID validity: %d, LPAR group absolute capacity " + "capping information validity: %d", + !!pcnt_valid, !!pwcap_valid, !!pacap_valid, !!pid_valid, + !!lpar_valid); + if (cur[2] & 0x7) + printf(", %#hhx - ???", cur[2] & 0x7); + printf(" */"); + + print_0x8(", infpval2", cur, 3, false); +# endif /* !VERBOSE */ + + print_u16(", infppnum", cur, 4, pid_valid); + + print_u16(", infpscps", cur, 6, pcnt_valid); + print_u16(", infpdcps", cur, 8, pcnt_valid); + print_u16(", infpsifl", cur, 10, pcnt_valid); + print_u16(", infpdifl", cur, 12, pcnt_valid); + +# if VERBOSE + if (cur[14] || cur[15]) + printf(", reserved_1__=\"\\x%#02hhx\\x%#02hhx\"", + cur[14], cur[15]); +# endif /* !VERBOSE */ + + print_ebcdic(", infppnam", cur, 16, 8, pid_valid, false); + +# if VERBOSE + print_weight(", infpwbcp", cur, 24, pwcap_valid); + print_weight(", infpabcp", cur, 28, pacap_valid); + print_weight(", infpwbif", cur, 32, pwcap_valid); + print_weight(", infpabif", cur, 36, pacap_valid); + + if (print_ebcdic(", infplgnm", cur, 40, 8, false, false)) { + + print_weight(", infplgcp", cur, 48, false); + print_weight(", infplgif", cur, 52, false); + } else { + if (lpar_valid) { + printf(", infplgnm="); + print_quoted_hex((char *) (cur + 40), 8); + } + + print_x32(", infplgcp", cur, 48, false); + print_x32(", infplgif", cur, 52, false); + } + + if (hdr_size > 56 && !is_empty(cur + 56, hdr_size - 56)) { + printf(", "); + print_quoted_hex((char *) (cur + 56), hdr_size - 56); + } +# else /* !VERBOSE */ + printf(", ..."); +# endif /* !VERBOSE */ + + printf("}"); + +hv_hdr: + /* Hypervisor/guest headers */ + print_hypervisor_header(buf, 1, 20, 22, mt); + print_guest_header(buf, 1, 24, 26); + print_hypervisor_header(buf, 2, 28, 30, mt); + print_guest_header(buf, 2, 32, 34); + print_hypervisor_header(buf, 3, 36, 38, mt); + print_guest_header(buf, 3, 40, 42); + + printf("}"); +} + +int +main(void) +{ + static const kernel_ulong_t bogus_func = + (kernel_ulong_t) 0xdeafbeefdeadc0deULL; + static const kernel_ulong_t bogus_resp_buf = + (kernel_ulong_t) 0xfacefeedac0ffeedULL; + static const kernel_ulong_t bogus_ret_code = + (kernel_ulong_t) 0xf00dfa57decaffedULL; + static const kernel_ulong_t bogus_flags = + (kernel_ulong_t) 0xfee1deadfa57beefULL; + + unsigned char *buf = tail_alloc(PAGE_SIZE); + uint64_t *ret = tail_alloc(sizeof(*ret)); + + long rc; + + rc = syscall(__NR_s390_sthyi, 0, 0, 0, 0); + printf("s390_sthyi(STHYI_FC_CP_IFL_CAP, NULL, NULL, 0) = %s\n", + sprintrc(rc)); + + rc = syscall(__NR_s390_sthyi, bogus_func, bogus_resp_buf, + bogus_ret_code, bogus_flags); + printf("s390_sthyi(%#llx /* STHYI_FC_??? */, %#llx, %#llx, %#llx) = " + "%s\n", + (unsigned long long) bogus_func, + (unsigned long long) bogus_resp_buf, + (unsigned long long) bogus_ret_code, + (unsigned long long) bogus_flags, + sprintrc(rc)); + + rc = syscall(__NR_s390_sthyi, bogus_func, buf, ret, 0); + printf("s390_sthyi(%#llx /* STHYI_FC_??? */, %p, %p, 0) = %s\n", + (unsigned long long) bogus_func, buf, ret, sprintrc(rc)); + + rc = syscall(__NR_s390_sthyi, 0, buf, ret, 0); + if (rc) + error_msg_and_fail("syscall(__NR_s390_sthyi, 0, buf, ret, 0) " + "returned unexpected value of %ld", rc); + + printf("s390_sthyi(STHYI_FC_CP_IFL_CAP, "); + print_sthyi(buf); + printf(", [0], 0) = 0\n"); + + puts("+++ exited with 0 +++"); + return 0; +} + +#else + +SKIP_MAIN_UNDEFINED("HAVE_ICONV_H && HAVE_ICONV_OPEN && __NR_s390_sthyi") + +#endif |