1 /* 2 * s390-specific syscalls decoders. 3 * 4 * Copyright (c) 2018 The strace developers. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. The name of the author may not be used to endorse or promote products 16 * derived from this software without specific prior written permission. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 23 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 */ 29 30 #include "defs.h" 31 32 #if defined S390 || defined S390X 33 34 #include <sys/user.h> 35 36 #include "print_fields.h" 37 38 #include "xlat/s390_guarded_storage_commands.h" 39 #include "xlat/s390_runtime_instr_commands.h" 40 #include "xlat/s390_sthyi_function_codes.h" 41 42 /* 43 * Since, for some reason, kernel doesn't expose all these nice constants and 44 * structures in UAPI, we have to re-declare them ourselves. 45 */ 46 47 /** 48 * "The header section is placed at the beginning of the response buffer and 49 * identifies the location and length of all other sections. Valid sections have 50 * nonzero offset values in the header. Each section provides information about 51 * validity of fields within that section." 52 */ 53 struct sthyi_hdr { 54 /** 55 * Header Flag Byte 1 - These flag settings indicate the environment 56 * that the instruction was executed in and may influence the value of 57 * the validity bits. The validity bits, and not these flags, should be 58 * used to determine if a field is valid. 59 * - 0x80 - Global Performance Data unavailable 60 * - 0x40 - One or more hypervisor levels below this level does not 61 * support the STHYI instruction. When this flag is set the 62 * value of INFGPDU is not meaningful because the state of the 63 * Global Performance Data setting cannot be determined. 64 * - 0x20 - Virtualization stack is incomplete. This bit indicates one 65 * of two cases: 66 * - One or more hypervisor levels does not support the STHYI 67 * instruction. For this case, INFSTHYI will also be set. 68 * - There were more than three levels of guest/hypervisor information 69 * to report. 70 * - 0x10 - Execution environment is not within a logical partition. 71 */ 72 uint8_t infhflg1; 73 uint8_t infhflg2; /**< Header Flag Byte 2 reserved for IBM(R) use */ 74 uint8_t infhval1; /**< Header Validity Byte 1 reserved for IBM use */ 75 uint8_t infhval2; /**< Header Validity Byte 2 reserved for IBM use */ 76 char reserved_1__[3]; /**< Reserved for future IBM use */ 77 uint8_t infhygct; /**< Count of Hypervisor and Guest Sections */ 78 uint16_t infhtotl; /**< Total length of response buffer */ 79 uint16_t infhdln; /**< Length of Header Section mapped by INF0HDR */ 80 uint16_t infmoff; /**< Offset to Machine Section mapped by INF0MAC */ 81 uint16_t infmlen; /**< Length of Machine Section */ 82 uint16_t infpoff; /**< Offset to Partition Section mapped by INF0PAR */ 83 uint16_t infplen; /**< Length of Partition Section */ 84 uint16_t infhoff1; /**< Offset to Hypervisor Section1 mapped by INF0HYP */ 85 uint16_t infhlen1; /**< Length of Hypervisor Section1 */ 86 uint16_t infgoff1; /**< Offset to Guest Section1 mapped by INF0GST */ 87 uint16_t infglen1; /**< Length of Guest Section1 */ 88 uint16_t infhoff2; /**< Offset to Hypervisor Section2 mapped by INF0HYP */ 89 uint16_t infhlen2; /**< Length of Hypervisor Section2 */ 90 uint16_t infgoff2; /**< Offset to Guest Section2 mapped by INF0GST */ 91 uint16_t infglen2; /**< Length of Guest Section2 */ 92 uint16_t infhoff3; /**< Offset to Hypervisor Section3 mapped by INF0HYP */ 93 uint16_t infhlen3; /**< Length of Hypervisor Section3 */ 94 uint16_t infgoff3; /**< Offset to Guest Section3 mapped by INF0GST */ 95 uint16_t infglen3; /**< Length of Guest Section3 */ 96 /* 44 bytes in total */ 97 } ATTRIBUTE_PACKED; 98 99 struct sthyi_machine { 100 uint8_t infmflg1; /**< Machine Flag Byte 1 reserved for IBM use */ 101 uint8_t infmflg2; /**< Machine Flag Byte 2 reserved for IBM use */ 102 /** 103 * Machine Validity Byte 1 104 * - 0x80 - Processor Count Validity. When this bit is on, it indicates 105 * that INFMSCPS, INFMDCPS, INFMSIFL, and INFMDIFL contain 106 * valid counts. The validity bit may be off when: 107 * - STHYI support is not available on a lower level hypervisor, or 108 * - Global Performance Data is not enabled. 109 * - 0x40 - Machine ID Validity. This bit being on indicates that a 110 * SYSIB 1.1.1 was obtained from STSI and information reported 111 * in the following fields is valid: INFMTYPE, INFMMANU, 112 * INFMSEQ, and INFMPMAN. 113 * - 0x20 - Machine Name Validity. This bit being on indicates that the 114 * INFMNAME field is valid. 115 */ 116 uint8_t infmval1; 117 uint8_t infmval2; /**< Machine Validity Byte 2 reserved for IBM use */ 118 /** 119 * Number of shared CPs configured in the machine or in the physical 120 * partition if the system is physically partitioned. 121 */ 122 uint16_t infmscps; 123 /** 124 * Number of dedicated CPs configured in this machine or in the physical 125 * partition if the system is physically partitioned. 126 */ 127 uint16_t infmdcps; 128 /** 129 * Number of shared IFLs configured in this machine or in the physical 130 * partition if the system is physically partitioned. 131 */ 132 uint16_t infmsifl; 133 /** 134 * Number of dedicated IFLs configured in this machine or in the 135 * physical partition if the system is physically partitioned. 136 */ 137 uint16_t infmdifl; 138 char infmname[8]; /**< EBCDIC Machine Name */ 139 char infmtype[4]; /**< EBCDIC Type */ 140 char infmmanu[16]; /**< EBCDIC Manufacturer */ 141 char infmseq[16]; /**< EBCDIC Sequence Code */ 142 char infmpman[4]; /**< EBCDIC Plant of Manufacture */ 143 /* 60 bytes in total*/ 144 } ATTRIBUTE_PACKED; 145 146 struct sthyi_partition { 147 /** 148 * Partition Flag Byte 1 149 * - 0x80 - Multithreading (MT) is enabled. 150 */ 151 uint8_t infpflg1; 152 /** Partition Flag Byte 2 reserved for IBM use */ 153 uint8_t infpflg2; 154 /** 155 * Partition Validity Byte 1 156 * - 0x80 - Processor count validity. This bit being on indicates that 157 * INFPSCPS, INFPDCPS, INFPSIFL, and INFPDIFL contain valid 158 * counts. 159 * - 0x40 - Partition weight-based capped capacity validity. This bit 160 * being on indicates that INFPWBCP and INFPWBIF are valid 161 * - 0x20 - Partition absolute capped capacity validity. This bit being 162 * on indicates that INFPABCP and INFPABIF are valid. 163 * - 0x10 - Partition ID validity. This bit being on indicates that a 164 * SYSIB 2.2.2 was obtained from STSI and information reported 165 * in the following fields is valid: INFPPNUM and INFPPNAM. 166 * - 0x08 - LPAR group absolute capacity capping information validity. 167 * This bit being on indicates that INFPLGNM, INFPLGCP, and 168 * INFPLGIF are valid. 169 */ 170 uint8_t infpval1; 171 /** Partition Validity Byte 2 reserved for IBM use */ 172 uint8_t infpval2; 173 /** Logical partition number */ 174 uint16_t infppnum; 175 /** 176 * Number of shared logical CPs configured for this partition. Count 177 * of cores when MT is enabled. 178 */ 179 uint16_t infpscps; 180 /** 181 * Number of dedicated logical CPs configured for this partition. Count 182 * of cores when MT is enabled. 183 */ 184 uint16_t infpdcps; 185 /** 186 * Number of shared logical IFLs configured for this partition. Count 187 * of cores when MT is enabled. 188 */ 189 uint16_t infpsifl; 190 /** 191 * Number of dedicated logical IFLs configured for this partition. 192 * Count of cores when MT is enabled. 193 */ 194 uint16_t infpdifl; 195 /** Reserved for future IBM use */ 196 char reserved_1__[2]; 197 /** EBCIDIC Logical partition name */ 198 char infppnam[8]; 199 /** 200 * Partition weight-based capped capacity for CPs, a scaled number where 201 * 0x00010000 represents one core. Zero if not capped. 202 */ 203 uint32_t infpwbcp; 204 /** 205 * Partition absolute capped capacity for CPs, a scaled number where 206 * 0x00010000 represents one core. Zero if not capped. 207 */ 208 uint32_t infpabcp; 209 /** 210 * Partition weight-based capped capacity for IFLs, a scaled number 211 * where 0x00010000 represents one core. Zero if not capped. 212 */ 213 uint32_t infpwbif; 214 /** 215 * Partition absolute capped capacity for IFLs, a scaled number where 216 * 0x00010000 represents one core. Zero if not capped. 217 */ 218 uint32_t infpabif; 219 /** 220 * EBCIDIC LPAR group name. Binary zeros when the partition is not in 221 * an LPAR group. EBCDIC and padded with blanks on the right when in a 222 * group. The group name is reported only when there is a group cap on 223 * CP or IFL CPU types and the partition has the capped CPU type. 224 */ 225 char infplgnm[8]; 226 /** 227 * LPAR group absolute capacity value for CP CPU type when nonzero. This 228 * field will be nonzero only when INFPLGNM is nonzero and a cap is 229 * defined for the LPAR group for the CP CPU type. When nonzero, 230 * contains a scaled number where 0x00010000 represents one core. 231 */ 232 uint32_t infplgcp; 233 /** 234 * LPAR group absolute capacity value for IFL CPU type when nonzero. 235 * This field will be nonzero only when INFPLGNM is nonzero and a cap 236 * is defined for the LPAR group for the IFL CPU type. When nonzero, 237 * contains a scaled number where 0x00010000 represents one core. 238 */ 239 uint32_t infplgif; 240 /* 56 bytes */ 241 } ATTRIBUTE_PACKED; 242 243 struct sthyi_hypervisor { 244 /** 245 * Hypervisor Flag Byte 1 246 * - 0x80 - Guest CPU usage hard limiting is using the consumption 247 * method. 248 * - 0x40 - If on, LIMITHARD caps use prorated core time for capping. 249 * If off, raw CPU time is used. 250 */ 251 uint8_t infyflg1; 252 uint8_t infyflg2; /**< Hypervisor Flag Byte 2 reserved for IBM use */ 253 uint8_t infyval1; /**< Hypervisor Validity Byte 1 reserved for IBM use */ 254 uint8_t infyval2; /**< Hypervisor Validity Byte 2 reserved for IBM use */ 255 /** 256 * Hypervisor Type 257 * - 1 - z/VM is the hypervisor. 258 */ 259 uint8_t infytype; 260 char reserved_1__[1]; /**< Reserved for future IBM use */ 261 /** 262 * Threads in use per CP core. Only valid when MT enabled 263 * (INFPFLG1 0x80 is ON). 264 */ 265 uint8_t infycpt; 266 /** 267 * Threads in use per IFL core. Only valid when MT enabled 268 * (INFPFLG1 0x80 is ON). 269 */ 270 uint8_t infyiflt; 271 /** 272 * EBCID System Identifier. Left justified and padded with blanks. 273 * This field will be blanks if non-existent. 274 */ 275 char infysyid[8]; 276 /** 277 * EBCID Cluster Name. Left justified and padded with blanks. This is 278 * the name on the SSI statement in the system configuration file. This 279 * field will be blanks if nonexistent. 280 */ 281 char infyclnm[8]; 282 /** 283 * Total number of CPs shared among guests of this hypervisor. 284 * Number of cores when MT enabled. 285 */ 286 uint16_t infyscps; 287 /** 288 * Total number of CPs dedicated to guests of this hypervisor. 289 * Number of cores when MT enabled. 290 */ 291 uint16_t infydcps; 292 /** 293 * Total number of IFLs shared among guests of this hypervisor. 294 * Number of cores when MT enabled. 295 */ 296 uint16_t infysifl; 297 /** 298 * Total number of IFLs dedicated to guests of this hypervisor. 299 * Number of cores when MT enabled. 300 */ 301 uint16_t infydifl; 302 /* 32 bytes */ 303 } ATTRIBUTE_PACKED; 304 305 struct sthyi_guest { 306 /** 307 * Guest Flag Byte 1 308 * - 0x80 - Guest is mobility enabled 309 * - 0x40 - Guest has multiple virtual CPU types 310 * - 0x20 - Guest CP dispatch type has LIMITHARD cap 311 * - 0x10 - Guest IFL dispatch type has LIMITHARD cap 312 * - 0x08 - Virtual CPs are thread dispatched 313 * - 0x04 - Virtual IFLs are thread dispatched 314 */ 315 uint8_t infgflg1; 316 uint8_t infgflg2; /**< Guest Flag Byte 2 reserved for IBM use */ 317 uint8_t infgval1; /**< Guest Validity Byte 1 reserved for IBM use */ 318 uint8_t infgval2; /**< Guest Validity Byte 2 reserved for IBM use */ 319 char infgusid[8]; /**< EBCDIC Userid */ 320 uint16_t infgscps; /**< Number of guest shared CPs */ 321 uint16_t infgdcps; /**< Number of guest dedicated CPs */ 322 /** 323 * Dispatch type for guest CPs. This field is valid if INFGSCPS or 324 * INFGDCPS is greater than zero. 325 * - 0 - General Purpose (CP) 326 */ 327 uint8_t infgcpdt; 328 char reserved_1__[3]; /**< Reserved for future IBM use */ 329 /** 330 * Guest current capped capacity for shared virtual CPs, a scaled number 331 * where 0x00010000 represents one core. This field is zero to 332 * indicate not capped when: 333 * - There is no CP individual limit (that is, the "Guest CP dispatch 334 * type has LIMITHARD cap" bit in field INFGFLG1 is OFF). 335 * - There are no shared CPs on the system (that is, INFYSCPS = 0). 336 * If there is a CP limit but there are no shared CPs or virtual CPs, 337 * the limit is meaningless and does not apply to anything. 338 */ 339 uint32_t infgcpcc; 340 uint16_t infgsifl; /**< Number of guest shared IFLs */ 341 uint16_t infgdifl; /**< Number of guest dedicated IFLs */ 342 /** 343 * Dispatch type for guest IFLs. This field is valid if INFGSIFL or 344 * INFGDIFL is greater than zero. 345 * - 0 - General Purpose (CP) 346 * - 3 - Integrated Facility for Linux (IFL) 347 */ 348 uint8_t infgifdt; 349 char reserved_2__[3]; /**< Reserved for future IBM use */ 350 /** 351 * Guest current capped capacity for shared virtual IFLs, a scaled 352 * number where 0x00010000 represents one core. This field is zero 353 * to indicate not capped with an IFL limit when: 354 * - There is no IFL individual limit (that is, the "Guest IFL dispatch 355 * type has LIMITHARD cap" bit in field INFGFLG1 is OFF). 356 * - The guest's IFLs are dispatched on CPs (that is, INFGIFDT = 00). 357 * When the guest's IFLs are dispatched on CPs, the CP individual 358 * limit (in INFGCPCC) is applied to the guest's virtual IFLs and 359 * virtual CPs. 360 */ 361 uint32_t infgifcc; 362 /** 363 * CPU Pool Capping Flags 364 * - 0x80 - CPU Pool's CP virtual type has LIMITHARD cap 365 * - 0x40 - CPU Pool's CP virtual type has CAPACITY cap 366 * - 0x20 - CPU Pool's IFL virtual type has LIMITHARD cap 367 * - 0x10 - CPU Pool's IFL virtual type has CAPACITY cap 368 * - 0x08 - CPU Pool uses prorated core time. 369 */ 370 uint8_t infgpflg; 371 char reserved_3__[3]; /**< Reserved for future IBM use */ 372 /** 373 * EBCDIC CPU Pool Name. This field will be blanks if the guest is not 374 * in a CPU Pool. 375 */ 376 char infgpnam[8]; 377 /** 378 * CPU Pool capped capacity for shared virtual CPs, a scaled number 379 * where 0x00010000 represents one core. This field will be zero if 380 * not capped. 381 */ 382 uint32_t infgpccc; 383 /** 384 * CPU Pool capped capacity for shared virtual IFLs, a scaled number 385 * where 0x00010000 represents one core. This field will be zero if 386 * not capped. 387 */ 388 uint32_t infgpicc; 389 /* 56 bytes */ 390 } ATTRIBUTE_PACKED; 391 392 393 static void 394 decode_ebcdic(const char *ebcdic, char *ascii, size_t size) 395 { 396 /* 397 * This is mostly Linux's EBCDIC-ASCII conversion table, except for 398 * various non-representable characters that are converted to spaces for 399 * readability purposes, as it is intended to be a hint for the string 400 * contents and not precise conversion. 401 */ 402 static char conv_table[] = 403 "\0\1\2\3 \11 \177 \13\14\15\16\17" 404 "\20\21\22\23 \n\10 \30\31 \34\35\36\37" 405 " \34 \n\27\33 \5\6\7" 406 " \26 \4 \24\25 \32" 407 " " " .<(+|" 408 "& " "!$*);~" 409 "-/ " "|,%_>?" 410 " `" ":#@'=\"" 411 " abcdefghi" " " 412 " jklmnopqr" " " 413 " ~stuvwxyz" " " 414 "^ " "[] " 415 "{ABCDEFGHI" " " 416 "}JKLMNOPQR" " " 417 "\\ STUVWXYZ" " " 418 "0123456789" " "; 419 420 while (size--) 421 *ascii++ = conv_table[(unsigned char) *ebcdic++]; 422 } 423 424 #define DECODE_EBCDIC(ebcdic_, ascii_) \ 425 decode_ebcdic((ebcdic_), (ascii_), \ 426 sizeof(ebcdic_) + MUST_BE_ARRAY(ebcdic_)) 427 #define PRINT_EBCDIC(ebcdic_) \ 428 do { \ 429 char ascii_str[sizeof(ebcdic_) + MUST_BE_ARRAY(ebcdic_)]; \ 430 \ 431 DECODE_EBCDIC(ebcdic_, ascii_str); \ 432 print_quoted_string(ascii_str, sizeof(ascii_str), \ 433 QUOTE_EMIT_COMMENT); \ 434 } while (0) 435 436 #define PRINT_FIELD_EBCDIC(prefix_, where_, field_) \ 437 do { \ 438 PRINT_FIELD_HEX_ARRAY(prefix_, where_, field_); \ 439 PRINT_EBCDIC((where_).field_); \ 440 } while (0) 441 442 #define PRINT_FIELD_WEIGHT(prefix_, where_, field_) \ 443 do { \ 444 PRINT_FIELD_X(prefix_, where_, field_); \ 445 if ((where_).field_) \ 446 tprintf_comment("%u %u/65536 cores", \ 447 (where_).field_ >> 16, \ 448 (where_).field_ & 0xFFFF); \ 449 else \ 450 tprints_comment("unlimited"); \ 451 } while (0) 452 453 454 #define IS_BLANK(arr_) /* 0x40 is space in EBCDIC */ \ 455 is_filled(arr_, '\x40', sizeof(arr_) + MUST_BE_ARRAY(arr_)) 456 457 #define CHECK_SIZE(hdr_, size_, name_, ...) \ 458 do { \ 459 if ((size_) < sizeof(*(hdr_))) { \ 460 tprintf_comment("Invalid " name_ " with size " \ 461 "%hu < %zu expected", \ 462 ##__VA_ARGS__, \ 463 (size_), sizeof(*(hdr_))); \ 464 print_quoted_string((char *) (hdr_), (size_), \ 465 QUOTE_FORCE_HEX); \ 466 \ 467 return; \ 468 } \ 469 } while (0) 470 471 #define PRINT_UNKNOWN_TAIL(hdr_, size_) \ 472 do { \ 473 if ((size_) > sizeof(*(hdr_)) && \ 474 !is_filled((char *) ((hdr_) + 1), '\0', \ 475 (size_) - sizeof(*(hdr_)))) \ 476 print_quoted_string((char *) ((hdr_) + 1), \ 477 (size_) - sizeof(*(hdr_)), \ 478 QUOTE_FORCE_HEX); \ 479 } while (0) 480 481 static void 482 print_sthyi_machine(struct tcb *tcp, struct sthyi_machine *hdr, uint16_t size, 483 bool *dummy) 484 { 485 int cnt_val, name_val, id_val; 486 487 CHECK_SIZE(hdr, size, "machine structure"); 488 489 tprints("/* machine */ {"); 490 if (!abbrev(tcp)) { 491 if (hdr->infmflg1) { /* Reserved */ 492 PRINT_FIELD_0X("", *hdr, infmflg1); 493 tprints(", "); 494 } 495 if (hdr->infmflg2) { /* Reserved */ 496 PRINT_FIELD_0X(", ", *hdr, infmflg2); 497 tprints(", "); 498 } 499 } 500 501 PRINT_FIELD_0X("", *hdr, infmval1); 502 cnt_val = !!(hdr->infmval1 & 0x80); 503 id_val = !!(hdr->infmval1 & 0x40); 504 name_val = !!(hdr->infmval1 & 0x20); 505 506 if (!abbrev(tcp)) { 507 if (hdr->infmval1) 508 tprintf_comment("processor count validity: %d, " 509 "machine ID validity: %d, " 510 "machine name validity: %d%s%#.0x%s", 511 cnt_val, id_val, name_val, 512 hdr->infmval1 & 0x1F ? ", " : "", 513 hdr->infmval1 & 0x1F, 514 hdr->infmval1 & 0x1F ? " - ???" : ""); 515 if (hdr->infmval2) 516 PRINT_FIELD_0X(", ", *hdr, infmval2); 517 } 518 519 if (cnt_val || hdr->infmscps) 520 PRINT_FIELD_U(", ", *hdr, infmscps); 521 if (cnt_val || hdr->infmdcps) 522 PRINT_FIELD_U(", ", *hdr, infmdcps); 523 if (cnt_val || hdr->infmsifl) 524 PRINT_FIELD_U(", ", *hdr, infmsifl); 525 if (cnt_val || hdr->infmdifl) 526 PRINT_FIELD_U(", ", *hdr, infmdifl); 527 528 if (!abbrev(tcp)) { 529 if (name_val || hdr->infmname) 530 PRINT_FIELD_EBCDIC(", ", *hdr, infmname); 531 532 if (id_val || !IS_ARRAY_ZERO(hdr->infmtype)) 533 PRINT_FIELD_EBCDIC(", ", *hdr, infmtype); 534 if (id_val || !IS_ARRAY_ZERO(hdr->infmmanu)) 535 PRINT_FIELD_EBCDIC(", ", *hdr, infmmanu); 536 if (id_val || !IS_ARRAY_ZERO(hdr->infmseq)) 537 PRINT_FIELD_EBCDIC(", ", *hdr, infmseq); 538 if (id_val || !IS_ARRAY_ZERO(hdr->infmpman)) 539 PRINT_FIELD_EBCDIC(", ", *hdr, infmpman); 540 541 PRINT_UNKNOWN_TAIL(hdr, size); 542 } else { 543 tprints(", ..."); 544 } 545 546 tprints("}"); 547 } 548 549 static void 550 print_sthyi_partition(struct tcb *tcp, struct sthyi_partition *hdr, 551 uint16_t size, bool *mt) 552 { 553 int cnt_val, wcap_val, acap_val, id_val, lpar_val; 554 555 *mt = false; 556 557 CHECK_SIZE(hdr, size, "partition structure"); 558 559 *mt = !!(hdr->infpflg1 & 0x80); 560 561 PRINT_FIELD_0X("/* partition */ {", *hdr, infpflg1); 562 if (!abbrev(tcp) && hdr->infpflg1) 563 tprintf_comment("%s%s%#.0x%s", 564 hdr->infpflg1 & 0x80 ? 565 "0x80 - multithreading is enabled" : "", 566 (hdr->infpflg1 & 0x80) && (hdr->infpflg1 & 0x7F) ? 567 ", " : "", 568 hdr->infpflg1 & 0x7F, 569 hdr->infpflg1 & 0x7F ? " - ???" : ""); 570 if (!abbrev(tcp) && hdr->infpflg2) /* Reserved */ 571 PRINT_FIELD_0X(", ", *hdr, infpflg2); 572 573 PRINT_FIELD_0X(", ", *hdr, infpval1); 574 cnt_val = !!(hdr->infpval1 & 0x80); 575 wcap_val = !!(hdr->infpval1 & 0x40); 576 acap_val = !!(hdr->infpval1 & 0x20); 577 id_val = !!(hdr->infpval1 & 0x10); 578 lpar_val = !!(hdr->infpval1 & 0x08); 579 580 if (!abbrev(tcp) && hdr->infpval1) 581 tprintf_comment("processor count validity: %d, " 582 "partition weight-based capacity validity: %d, " 583 "partition absolute capacity validity: %d, " 584 "partition ID validity: %d, " 585 "LPAR group absolute capacity capping " 586 "information validity: %d%s%#.0x%s", 587 cnt_val, wcap_val, acap_val, id_val, lpar_val, 588 hdr->infpval1 & 0x07 ? ", " : "", 589 hdr->infpval1 & 0x07, 590 hdr->infpval1 & 0x07 ? " - ???" : ""); 591 if (!abbrev(tcp) && hdr->infpval2) /* Reserved */ 592 PRINT_FIELD_0X(", ", *hdr, infpval2); 593 594 if (id_val || hdr->infppnum) 595 PRINT_FIELD_U(", ", *hdr, infppnum); 596 597 if (cnt_val || hdr->infpscps) 598 PRINT_FIELD_U(", ", *hdr, infpscps); 599 if (cnt_val || hdr->infpdcps) 600 PRINT_FIELD_U(", ", *hdr, infpdcps); 601 if (cnt_val || hdr->infpsifl) 602 PRINT_FIELD_U(", ", *hdr, infpsifl); 603 if (cnt_val || hdr->infpdifl) 604 PRINT_FIELD_U(", ", *hdr, infpdifl); 605 606 if (!abbrev(tcp) && !IS_ARRAY_ZERO(hdr->reserved_1__)) 607 PRINT_FIELD_HEX_ARRAY(", ", *hdr, reserved_1__); 608 609 if (id_val || !IS_ARRAY_ZERO(hdr->infppnam)) 610 PRINT_FIELD_EBCDIC(", ", *hdr, infppnam); 611 612 if (!abbrev(tcp)) { 613 if (wcap_val || hdr->infpwbcp) 614 PRINT_FIELD_WEIGHT(", ", *hdr, infpwbcp); 615 if (acap_val || hdr->infpabcp) 616 PRINT_FIELD_WEIGHT(", ", *hdr, infpabcp); 617 if (wcap_val || hdr->infpwbif) 618 PRINT_FIELD_WEIGHT(", ", *hdr, infpwbif); 619 if (acap_val || hdr->infpabif) 620 PRINT_FIELD_WEIGHT(", ", *hdr, infpabif); 621 622 if (!IS_ARRAY_ZERO(hdr->infplgnm)) { 623 PRINT_FIELD_EBCDIC(", ", *hdr, infplgnm); 624 625 PRINT_FIELD_WEIGHT(", ", *hdr, infplgcp); 626 PRINT_FIELD_WEIGHT(", ", *hdr, infplgif); 627 } else { 628 if (lpar_val) 629 PRINT_FIELD_HEX_ARRAY(", ", *hdr, infplgnm); 630 if (hdr->infplgcp) 631 PRINT_FIELD_X(", ", *hdr, infplgcp); 632 if (hdr->infplgif) 633 PRINT_FIELD_X(", ", *hdr, infplgif); 634 } 635 636 PRINT_UNKNOWN_TAIL(hdr, size); 637 } else { 638 tprints(", ..."); 639 } 640 641 tprints("}"); 642 } 643 644 static void 645 print_sthyi_hypervisor(struct tcb *tcp, struct sthyi_hypervisor *hdr, 646 uint16_t size, int num, bool mt) 647 { 648 CHECK_SIZE(hdr, size, "hypervisor %d structure", num); 649 650 tprintf("/* hypervisor %d */ ", num); 651 PRINT_FIELD_0X("{", *hdr, infyflg1); 652 if (!abbrev(tcp) && hdr->infyflg1) 653 tprintf_comment("%s%s%s%s%#.0x%s", 654 hdr->infyflg1 & 0x80 ? 655 "0x80 - guest CPU usage had limiting is using " 656 "the consumption method" : "", 657 (hdr->infyflg1 & 0x80) && (hdr->infyflg1 & 0x40) ? 658 ", " : "", 659 hdr->infyflg1 & 0x40 ? 660 "0x40 - LIMITHARD caps use prorated core time " 661 "for capping" : "", 662 (hdr->infyflg1 & 0xC0) && (hdr->infyflg1 & 0x3F) ? 663 ", " : "", 664 hdr->infyflg1 & 0x3F, 665 hdr->infyflg1 & 0x3F ? " - ???" : ""); 666 667 if (!abbrev(tcp)) { 668 if (hdr->infyflg2) /* Reserved */ 669 PRINT_FIELD_0X(", ", *hdr, infyflg2); 670 if (hdr->infyval1) /* Reserved */ 671 PRINT_FIELD_0X(", ", *hdr, infyval1); 672 if (hdr->infyval2) /* Reserved */ 673 PRINT_FIELD_0X(", ", *hdr, infyval2); 674 675 PRINT_FIELD_U(", ", *hdr, infytype); 676 switch (hdr->infytype) { 677 case 1: 678 tprints_comment("z/VM is the hypervisor"); 679 break; 680 default: 681 tprints_comment("unknown hypervisor type"); 682 } 683 684 if (!IS_ARRAY_ZERO(hdr->reserved_1__)) 685 PRINT_FIELD_HEX_ARRAY(", ", *hdr, reserved_1__); 686 687 if (mt || hdr->infycpt) 688 PRINT_FIELD_U(", ", *hdr, infycpt); 689 if (mt || hdr->infyiflt) 690 PRINT_FIELD_U(", ", *hdr, infyiflt); 691 } 692 693 if (!abbrev(tcp) || !IS_BLANK(hdr->infysyid)) 694 PRINT_FIELD_EBCDIC(", ", *hdr, infysyid); 695 if (!abbrev(tcp) || !IS_BLANK(hdr->infyclnm)) 696 PRINT_FIELD_EBCDIC(", ", *hdr, infyclnm); 697 698 if (!abbrev(tcp) || hdr->infyscps) 699 PRINT_FIELD_U(", ", *hdr, infyscps); 700 if (!abbrev(tcp) || hdr->infydcps) 701 PRINT_FIELD_U(", ", *hdr, infydcps); 702 if (!abbrev(tcp) || hdr->infysifl) 703 PRINT_FIELD_U(", ", *hdr, infysifl); 704 if (!abbrev(tcp) || hdr->infydifl) 705 PRINT_FIELD_U(", ", *hdr, infydifl); 706 707 if (!abbrev(tcp)) { 708 PRINT_UNKNOWN_TAIL(hdr, size); 709 } else { 710 tprints(", ..."); 711 } 712 713 tprints("}"); 714 } 715 716 static void 717 print_sthyi_guest(struct tcb *tcp, struct sthyi_guest *hdr, uint16_t size, 718 int num, bool mt) 719 { 720 CHECK_SIZE(hdr, size, "guest %d structure", num); 721 722 tprintf("/* guest %d */ ", num); 723 PRINT_FIELD_0X("{", *hdr, infgflg1); 724 if (!abbrev(tcp) && hdr->infgflg1) 725 tprintf_comment("%s%s%s%s%s%s%s%s%s%s%s%s%#.0x%s", 726 hdr->infgflg1 & 0x80 ? 727 "0x80 - guest is mobility enabled" : "", 728 (hdr->infgflg1 & 0x80) && (hdr->infgflg1 & 0x40) ? 729 ", " : "", 730 hdr->infgflg1 & 0x40 ? 731 "0x40 - guest has multiple virtual CPU types" : 732 "", 733 (hdr->infgflg1 & 0xC0) && (hdr->infgflg1 & 0x20) ? 734 ", " : "", 735 hdr->infgflg1 & 0x20 ? 736 "0x20 - guest CP dispatch type has LIMITHARD " 737 "cap" : "", 738 (hdr->infgflg1 & 0xE0) && (hdr->infgflg1 & 0x10) ? 739 ", " : "", 740 hdr->infgflg1 & 0x10 ? 741 "0x10 - guest IFL dispatch type has LIMITHARD " 742 "cap" : "", 743 (hdr->infgflg1 & 0xF0) && (hdr->infgflg1 & 0x08) ? 744 ", " : "", 745 hdr->infgflg1 & 0x08 ? 746 "0x08 - virtual CPs are thread dispatched" : 747 "", 748 (hdr->infgflg1 & 0xF8) && (hdr->infgflg1 & 0x04) ? 749 ", " : "", 750 hdr->infgflg1 & 0x04 ? 751 "0x04 - virtual IFLs are thread dispatched" : 752 "", 753 (hdr->infgflg1 & 0xFC) && (hdr->infgflg1 & 0x03) ? 754 ", " : "", 755 hdr->infgflg1 & 0x03, 756 hdr->infgflg1 & 0x03 ? " - ???" : ""); 757 if (!abbrev(tcp)) { 758 if (hdr->infgflg2) /* Reserved */ 759 PRINT_FIELD_0X(", ", *hdr, infgflg2); 760 if (hdr->infgval1) /* Reserved */ 761 PRINT_FIELD_0X(", ", *hdr, infgval1); 762 if (hdr->infgval2) /* Reserved */ 763 PRINT_FIELD_0X(", ", *hdr, infgval2); 764 } 765 766 PRINT_FIELD_EBCDIC(", ", *hdr, infgusid); 767 768 if (!abbrev(tcp) || hdr->infgscps) 769 PRINT_FIELD_U(", ", *hdr, infgscps); 770 if (!abbrev(tcp) || hdr->infgdcps) 771 PRINT_FIELD_U(", ", *hdr, infgdcps); 772 773 if (!abbrev(tcp)) { 774 PRINT_FIELD_U(", ", *hdr, infgcpdt); 775 switch (hdr->infgcpdt) { 776 case 0: 777 tprints_comment("General Purpose (CP)"); 778 break; 779 default: 780 tprints_comment("unknown"); 781 } 782 783 if (!IS_ARRAY_ZERO(hdr->reserved_1__)) 784 PRINT_FIELD_HEX_ARRAY(", ", *hdr, reserved_1__); 785 } 786 787 if (!abbrev(tcp) || hdr->infgcpcc) 788 PRINT_FIELD_WEIGHT(", ", *hdr, infgcpcc); 789 790 if (!abbrev(tcp) || hdr->infgsifl) 791 PRINT_FIELD_U(", ", *hdr, infgsifl); 792 if (!abbrev(tcp) || hdr->infgdifl) 793 PRINT_FIELD_U(", ", *hdr, infgdifl); 794 795 if (!abbrev(tcp)) { 796 PRINT_FIELD_U(", ", *hdr, infgifdt); 797 switch (hdr->infgifdt) { 798 case 0: 799 tprints_comment("General Purpose (CP)"); 800 break; 801 case 3: 802 tprints_comment("Integrated Facility for Linux (IFL)"); 803 break; 804 default: 805 tprints_comment("unknown"); 806 } 807 808 if (!IS_ARRAY_ZERO(hdr->reserved_2__)) 809 PRINT_FIELD_HEX_ARRAY(", ", *hdr, reserved_2__); 810 } 811 812 if (!abbrev(tcp) || hdr->infgifcc) 813 PRINT_FIELD_WEIGHT(", ", *hdr, infgifcc); 814 815 PRINT_FIELD_0X(", ", *hdr, infgpflg); 816 if (!abbrev(tcp) && hdr->infgpflg) 817 tprintf_comment("%s%s%s%s%s%s%s%s%s%s%#.0x%s", 818 hdr->infgpflg & 0x80 ? 819 "0x80 - CPU pool's CP virtual type has " 820 "LIMITHARD cap" : "", 821 (hdr->infgpflg & 0x80) && (hdr->infgpflg & 0x40) ? 822 ", " : "", 823 hdr->infgpflg & 0x40 ? 824 "0x40 - CPU pool's CP virtual type has " 825 "CAPACITY cap" : "", 826 (hdr->infgpflg & 0xC0) && (hdr->infgpflg & 0x20) ? 827 ", " : "", 828 hdr->infgpflg & 0x20 ? 829 "0x20 - CPU pool's IFL virtual type has " 830 "LIMITHARD cap" : "", 831 (hdr->infgpflg & 0xE0) && (hdr->infgpflg & 0x10) ? 832 ", " : "", 833 hdr->infgpflg & 0x10 ? 834 "0x10 - CPU pool's IFL virtual type has " 835 "CAPACITY cap" : "", 836 (hdr->infgpflg & 0xF0) && (hdr->infgpflg & 0x08) ? 837 ", " : "", 838 hdr->infgpflg & 0x08 ? 839 "0x08 - CPU pool uses prorated core time" : "", 840 (hdr->infgpflg & 0xF8) && (hdr->infgpflg & 0x07) ? 841 ", " : "", 842 hdr->infgpflg & 0x07, 843 hdr->infgpflg & 0x07 ? " - ???" : ""); 844 845 if (!abbrev(tcp)) { 846 if (!IS_ARRAY_ZERO(hdr->reserved_3__)) 847 PRINT_FIELD_HEX_ARRAY(", ", *hdr, reserved_3__); 848 849 if (!IS_BLANK(hdr->infgpnam)) 850 PRINT_FIELD_EBCDIC(", ", *hdr, infgpnam); 851 852 PRINT_FIELD_WEIGHT(", ", *hdr, infgpccc); 853 PRINT_FIELD_WEIGHT(", ", *hdr, infgpicc); 854 855 PRINT_UNKNOWN_TAIL(hdr, size); 856 } else { 857 tprints(", ..."); 858 } 859 860 tprints("}"); 861 } 862 863 #define STHYI_PRINT_STRUCT(l_, name_) \ 864 do { \ 865 if (hdr->inf ##l_## off && hdr->inf ##l_## off + \ 866 hdr->inf ##l_## len <= sizeof(data)) { \ 867 tprints(", "); \ 868 print_sthyi_ ##name_(tcp, (struct sthyi_ ##name_ *) \ 869 (data + hdr->inf ##l_## off), \ 870 hdr->inf ##l_## len, &mt); \ 871 } \ 872 } while (0) 873 874 #define STHYI_PRINT_HV_STRUCT(l_, n_, name_) \ 875 do { \ 876 if (hdr->inf ##l_## off ##n_ && hdr->inf ##l_## off ##n_ + \ 877 hdr->inf ##l_## len ##n_ <= sizeof(data)) { \ 878 tprints(", "); \ 879 print_sthyi_ ##name_(tcp, (struct sthyi_ ##name_ *) \ 880 (data + hdr->inf ##l_## off ##n_), \ 881 hdr->inf ##l_## len ##n_, n_, mt); \ 882 } \ 883 } while (0) 884 885 static void 886 print_sthyi_buf(struct tcb *tcp, kernel_ulong_t ptr) 887 { 888 char data[PAGE_SIZE]; 889 struct sthyi_hdr *hdr = (struct sthyi_hdr *) data; 890 bool mt = false; 891 892 if (umove_or_printaddr(tcp, ptr, &data)) 893 return; 894 895 tprints("{"); 896 897 /* Header */ 898 PRINT_FIELD_0X("/* header */ {", *hdr, infhflg1); 899 900 if (abbrev(tcp)) { 901 tprints(", ..."); 902 goto sthyi_sections; 903 } 904 905 if (hdr->infhflg1) 906 tprintf_comment("%s%s%s%s%s%s%s%s%#.0x%s", 907 hdr->infhflg1 & 0x80 ? 908 "0x80 - Global Performance Data unavailable" : 909 "", 910 (hdr->infhflg1 & 0x80) && (hdr->infhflg1 & 0x40) ? 911 ", " : "", 912 hdr->infhflg1 & 0x40 ? 913 "0x40 - One or more hypervisor levels below " 914 "this level does not support the STHYI " 915 "instruction" : "", 916 (hdr->infhflg1 & 0xC0) && (hdr->infhflg1 & 0x20) ? 917 ", " : "", 918 hdr->infhflg1 & 0x20 ? 919 "0x20 - Virtualization stack is incomplete" : 920 "", 921 (hdr->infhflg1 & 0xE0) && (hdr->infhflg1 & 0x10) ? 922 ", " : "", 923 hdr->infhflg1 & 0x10 ? 924 "0x10 - Execution environment is not within " 925 "a logical partition" : "", 926 (hdr->infhflg1 & 0xF0) && (hdr->infhflg1 & 0x0F) ? 927 ", " : "", 928 hdr->infhflg1 & 0x0F, 929 hdr->infhflg1 & 0x0F ? " - ???" : ""); 930 if (hdr->infhflg2) /* Reserved */ 931 PRINT_FIELD_0X(", ", *hdr, infhflg2); 932 if (hdr->infhval1) /* Reserved */ 933 PRINT_FIELD_0X(", ", *hdr, infhval1); 934 if (hdr->infhval2) /* Reserved */ 935 PRINT_FIELD_0X(", ", *hdr, infhval2); 936 937 if (!IS_ARRAY_ZERO(hdr->reserved_1__)) 938 PRINT_FIELD_HEX_ARRAY(", ", *hdr, reserved_1__); 939 940 PRINT_FIELD_U(", ", *hdr, infhygct); 941 PRINT_FIELD_U(", ", *hdr, infhtotl); 942 943 PRINT_FIELD_U(", ", *hdr, infhdln); 944 PRINT_FIELD_U(", ", *hdr, infmoff); 945 PRINT_FIELD_U(", ", *hdr, infmlen); 946 PRINT_FIELD_U(", ", *hdr, infpoff); 947 PRINT_FIELD_U(", ", *hdr, infplen); 948 949 PRINT_FIELD_U(", ", *hdr, infhoff1); 950 PRINT_FIELD_U(", ", *hdr, infhlen1); 951 PRINT_FIELD_U(", ", *hdr, infgoff1); 952 PRINT_FIELD_U(", ", *hdr, infglen1); 953 PRINT_FIELD_U(", ", *hdr, infhoff2); 954 PRINT_FIELD_U(", ", *hdr, infhlen2); 955 PRINT_FIELD_U(", ", *hdr, infgoff2); 956 PRINT_FIELD_U(", ", *hdr, infglen2); 957 PRINT_FIELD_U(", ", *hdr, infhoff3); 958 PRINT_FIELD_U(", ", *hdr, infhlen3); 959 PRINT_FIELD_U(", ", *hdr, infgoff3); 960 PRINT_FIELD_U(", ", *hdr, infglen3); 961 962 PRINT_UNKNOWN_TAIL(hdr, hdr->infhdln); 963 964 sthyi_sections: 965 tprints("}"); 966 967 STHYI_PRINT_STRUCT(m, machine); 968 STHYI_PRINT_STRUCT(p, partition); 969 970 STHYI_PRINT_HV_STRUCT(h, 1, hypervisor); 971 STHYI_PRINT_HV_STRUCT(g, 1, guest); 972 STHYI_PRINT_HV_STRUCT(h, 2, hypervisor); 973 STHYI_PRINT_HV_STRUCT(g, 2, guest); 974 STHYI_PRINT_HV_STRUCT(h, 3, hypervisor); 975 STHYI_PRINT_HV_STRUCT(g, 3, guest); 976 977 tprints("}"); 978 } 979 980 /** 981 * Wrapper for the s390 STHYI instruction that provides hypervisor information. 982 * 983 * See https://www.ibm.com/support/knowledgecenter/SSB27U_6.3.0/com.ibm.zvm.v630.hcpb4/hcpb4sth.htm 984 * for the instruction documentation. 985 * 986 * The difference in the kernel wrapper is that it doesn't require the 4K 987 * alignment for the resp_buffer page (as it just copies from the internal 988 * cache). 989 */ 990 SYS_FUNC(s390_sthyi) 991 { 992 /* in, function ID from s390_sthyi_function_codes */ 993 kernel_ulong_t function_code = tcp->u_arg[0]; 994 /* out, pointer to page-sized buffer */ 995 kernel_ulong_t resp_buffer_ptr = tcp->u_arg[1]; 996 /* out, pointer to u64 containing function result */ 997 kernel_ulong_t return_code_ptr = tcp->u_arg[2]; 998 /* in, should be 0, at the moment */ 999 kernel_ulong_t flags = tcp->u_arg[3]; 1000 1001 if (entering(tcp)) { 1002 printxval64(s390_sthyi_function_codes, function_code, 1003 "STHYI_FC_???"); 1004 tprints(", "); 1005 } else { 1006 switch (function_code) { 1007 case STHYI_FC_CP_IFL_CAP: 1008 print_sthyi_buf(tcp, resp_buffer_ptr); 1009 break; 1010 1011 default: 1012 printaddr(resp_buffer_ptr); 1013 } 1014 1015 tprints(", "); 1016 printnum_int64(tcp, return_code_ptr, "%" PRIu64); 1017 tprintf(", %#" PRI_klx, flags); 1018 } 1019 1020 return 0; 1021 } 1022 1023 1024 /* 1025 * Structures are written based on 1026 * https://www-304.ibm.com/support/docview.wss?uid=isg29c69415c1e82603c852576700058075a&aid=1#page=85 1027 */ 1028 1029 struct guard_storage_control_block { 1030 uint64_t reserved; 1031 /** 1032 * Guard Storage Designation 1033 * - Bits 0..J, J == 64-GSC - Guard Storage Origin (GSO) 1034 * - Bits 53..55 - Guard Load Shift (GLS) 1035 * - Bits 58..63 - Guard Storage Characteristic (GSC), this is J from 1036 * the first item, valud values are 25..56. 1037 */ 1038 uint64_t gsd; 1039 uint64_t gssm; /**< Guard Storage Section Mask */ 1040 uint64_t gs_epl_a; /**< Guard Storage Event Parameter List Address */ 1041 }; 1042 1043 struct guard_storage_event_parameter_list { 1044 uint8_t pad1; 1045 /** 1046 * Guard Storage Event Addressing Mode 1047 * - 0x40 - Extended addressing mode (E) 1048 * - 0x80 - Basic addressing mode (B) 1049 */ 1050 uint8_t gs_eam; 1051 /** 1052 * Guard Storage Event Cause indication 1053 * - 0x01 - CPU was in transaction execution mode (TX) 1054 * - 0x02 - CPU was in constrained transaction execution mode (CX) 1055 * - 0x80 - Instruction causing the event: 0 - LGG, 1 - LLGFGS 1056 */ 1057 uint8_t gs_eci; 1058 /** 1059 * Guard Storage Event Access Information 1060 * - 0x01 - DAT mode 1061 * - Bits 1..2 - Address space indication 1062 * - Bits 4..7 - AR number 1063 */ 1064 uint8_t gs_eai; 1065 uint32_t pad2; 1066 uint64_t gs_eha; /**< Guard Storage Event Handler Address */ 1067 uint64_t gs_eia; /**< Guard Storage Event Instruction Address */ 1068 uint64_t gs_eoa; /**< Guard Storage Event Operation Address */ 1069 uint64_t gs_eir; /**< Guard Storage Event Intermediate Result */ 1070 uint64_t gs_era; /**< Guard Storage Event Return Address */ 1071 }; 1072 1073 static void 1074 guard_storage_print_gsepl(struct tcb *tcp, uint64_t addr) 1075 { 1076 struct guard_storage_event_parameter_list gsepl; 1077 1078 /* Since it is 64-bit even on 31-bit s390... */ 1079 if (sizeof(addr) > current_klongsize && 1080 addr >= (1ULL << (current_klongsize * 8))) { 1081 tprintf("%#" PRIx64, addr); 1082 1083 return; 1084 } 1085 1086 if (umove_or_printaddr(tcp, addr, &gsepl)) 1087 return; 1088 1089 tprints("[{"); 1090 1091 if (!abbrev(tcp)) { 1092 if (gsepl.pad1) { 1093 PRINT_FIELD_0X("", gsepl, pad1); 1094 tprints(", "); 1095 } 1096 1097 PRINT_FIELD_0X("", gsepl, gs_eam); 1098 tprintf_comment("extended addressing mode: %u, " 1099 "basic addressing mode: %u", 1100 !!(gsepl.gs_eam & 0x2), !!(gsepl.gs_eam & 0x1)); 1101 1102 PRINT_FIELD_0X(", ", gsepl, gs_eci); 1103 tprintf_comment("CPU in TX: %u, CPU in CX: %u, instruction: %s", 1104 !!(gsepl.gs_eci & 0x80), 1105 !!(gsepl.gs_eci & 0x40), 1106 gsepl.gs_eci & 0x01 ? "LLGFGS" : "LGG"); 1107 1108 PRINT_FIELD_0X(", ", gsepl, gs_eai); 1109 tprintf_comment("DAT: %u, address space indication: %u, " 1110 "AR number: %u", 1111 !!(gsepl.gs_eai & 0x40), 1112 (gsepl.gs_eai >> 4) & 0x3, 1113 gsepl.gs_eai & 0xF); 1114 1115 if (gsepl.pad2) 1116 PRINT_FIELD_0X(", ", gsepl, pad2); 1117 1118 tprints(", "); 1119 } 1120 1121 PRINT_FIELD_X("", gsepl, gs_eha); 1122 1123 if (!abbrev(tcp)) { 1124 PRINT_FIELD_X(", ", gsepl, gs_eia); 1125 PRINT_FIELD_X(", ", gsepl, gs_eoa); 1126 PRINT_FIELD_X(", ", gsepl, gs_eir); 1127 PRINT_FIELD_X(", ", gsepl, gs_era); 1128 } else { 1129 tprints(", ..."); 1130 } 1131 1132 tprints("}]"); 1133 } 1134 1135 # define DIV_ROUND_UP(x,y) (((x) + ((y) - 1)) / (y)) 1136 1137 static void 1138 guard_storage_print_gscb(struct tcb *tcp, kernel_ulong_t addr) 1139 { 1140 struct guard_storage_control_block gscb; 1141 1142 if (umove_or_printaddr(tcp, addr, &gscb)) 1143 return; 1144 1145 tprints("{"); 1146 1147 if (gscb.reserved) { 1148 PRINT_FIELD_0X("", gscb, reserved); 1149 tprints(", "); 1150 } 1151 1152 PRINT_FIELD_0X("", gscb, gsd); 1153 1154 if (!abbrev(tcp)) { 1155 unsigned int gsc = gscb.gsd & 0x3F; 1156 bool gsc_valid = gsc >= 25 && gsc <= 56; 1157 tprintf_comment("GS origin: %#*.*" PRIx64 "%s, " 1158 "guard load shift: %" PRIu64 ", " 1159 "GS characteristic: %u", 1160 gsc_valid ? 2 + DIV_ROUND_UP(64 - gsc, 4) : 0, 1161 gsc_valid ? DIV_ROUND_UP(64 - gsc, 4) : 0, 1162 gsc_valid ? gscb.gsd >> gsc : 0, 1163 gsc_valid ? "" : "[invalid]", 1164 (gscb.gsd >> 8) & 0x7, gsc); 1165 } 1166 1167 PRINT_FIELD_0X(", ", gscb, gssm); 1168 1169 tprints(", gs_epl_a="); 1170 guard_storage_print_gsepl(tcp, gscb.gs_epl_a); 1171 1172 tprints("}"); 1173 } 1174 1175 SYS_FUNC(s390_guarded_storage) 1176 { 1177 int command = (int) tcp->u_arg[0]; 1178 kernel_ulong_t gs_cb = tcp->u_arg[1]; 1179 1180 printxval(s390_guarded_storage_commands, command, "GS_???"); 1181 1182 switch (command) { 1183 case GS_ENABLE: 1184 case GS_DISABLE: 1185 case GS_CLEAR_BC_CB: 1186 case GS_BROADCAST: 1187 break; 1188 1189 case GS_SET_BC_CB: 1190 tprints(", "); 1191 guard_storage_print_gscb(tcp, gs_cb); 1192 break; 1193 1194 default: 1195 tprints(", "); 1196 printaddr(gs_cb); 1197 } 1198 1199 return RVAL_DECODED; 1200 } 1201 1202 SYS_FUNC(s390_runtime_instr) 1203 { 1204 int command = (int) tcp->u_arg[0]; 1205 int signum = (int) tcp->u_arg[1]; 1206 1207 1208 printxval_d(s390_runtime_instr_commands, command, 1209 "S390_RUNTIME_INSTR_???"); 1210 1211 /* 1212 * signum is ignored since Linux 4.4, but let's print it for start 1213 * command anyway. 1214 */ 1215 switch (command) { 1216 case S390_RUNTIME_INSTR_START: 1217 tprints(", "); 1218 tprints(signame(signum)); 1219 break; 1220 1221 case S390_RUNTIME_INSTR_STOP: 1222 default: 1223 break; 1224 } 1225 1226 return RVAL_DECODED; 1227 } 1228 1229 SYS_FUNC(s390_pci_mmio_write) 1230 { 1231 kernel_ulong_t mmio_addr = tcp->u_arg[0]; 1232 kernel_ulong_t user_buf = tcp->u_arg[1]; 1233 kernel_ulong_t length = tcp->u_arg[2]; 1234 1235 tprintf("%#" PRI_klx ", ", mmio_addr); 1236 printstr_ex(tcp, user_buf, length, QUOTE_FORCE_HEX); 1237 tprintf(", %" PRI_klu, length); 1238 1239 return RVAL_DECODED; 1240 } 1241 1242 SYS_FUNC(s390_pci_mmio_read) 1243 { 1244 kernel_ulong_t mmio_addr = tcp->u_arg[0]; 1245 kernel_ulong_t user_buf = tcp->u_arg[1]; 1246 kernel_ulong_t length = tcp->u_arg[2]; 1247 1248 if (entering(tcp)) { 1249 tprintf("%#" PRI_klx ", ", mmio_addr); 1250 } else { 1251 if (!syserror(tcp)) 1252 printstr_ex(tcp, user_buf, length, QUOTE_FORCE_HEX); 1253 else 1254 printaddr(user_buf); 1255 1256 tprintf(", %" PRI_klu, length); 1257 } 1258 1259 return 0; 1260 } 1261 1262 #endif /* defined S390 || defined S390X */ 1263
