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 static bool 455 is_filled(char *ptr, char fill, size_t size) 456 { 457 while (size--) 458 if (*ptr++ != fill) 459 return false; 460 461 return true; 462 } 463 464 #define IS_ZERO(arr_) \ 465 is_filled(arr_, '\0', sizeof(arr_) + MUST_BE_ARRAY(arr_)) 466 #define IS_BLANK(arr_) /* 0x40 is space in EBCDIC */ \ 467 is_filled(arr_, '\x40', sizeof(arr_) + MUST_BE_ARRAY(arr_)) 468 469 #define CHECK_SIZE(hdr_, size_, name_, ...) \ 470 do { \ 471 if ((size_) < sizeof(*(hdr_))) { \ 472 tprintf_comment("Invalid " name_ " with size " \ 473 "%hu < %zu expected", \ 474 ##__VA_ARGS__, \ 475 (size_), sizeof(*(hdr_))); \ 476 print_quoted_string((char *) (hdr_), (size_), \ 477 QUOTE_FORCE_HEX); \ 478 \ 479 return; \ 480 } \ 481 } while (0) 482 483 #define PRINT_UNKNOWN_TAIL(hdr_, size_) \ 484 do { \ 485 if ((size_) > sizeof(*(hdr_)) && \ 486 !is_filled((char *) ((hdr_) + 1), '\0', \ 487 (size_) - sizeof(*(hdr_)))) \ 488 print_quoted_string((char *) ((hdr_) + 1), \ 489 (size_) - sizeof(*(hdr_)), \ 490 QUOTE_FORCE_HEX); \ 491 } while (0) 492 493 static void 494 print_sthyi_machine(struct tcb *tcp, struct sthyi_machine *hdr, uint16_t size, 495 bool *dummy) 496 { 497 int cnt_val, name_val, id_val; 498 499 CHECK_SIZE(hdr, size, "machine structure"); 500 501 tprints("/* machine */ {"); 502 if (!abbrev(tcp)) { 503 if (hdr->infmflg1) { /* Reserved */ 504 PRINT_FIELD_0X("", *hdr, infmflg1); 505 tprints(", "); 506 } 507 if (hdr->infmflg2) { /* Reserved */ 508 PRINT_FIELD_0X(", ", *hdr, infmflg2); 509 tprints(", "); 510 } 511 } 512 513 PRINT_FIELD_0X("", *hdr, infmval1); 514 cnt_val = !!(hdr->infmval1 & 0x80); 515 id_val = !!(hdr->infmval1 & 0x40); 516 name_val = !!(hdr->infmval1 & 0x20); 517 518 if (!abbrev(tcp)) { 519 if (hdr->infmval1) 520 tprintf_comment("processor count validity: %d, " 521 "machine ID validity: %d, " 522 "machine name validity: %d%s%#.0x%s", 523 cnt_val, id_val, name_val, 524 hdr->infmval1 & 0x1F ? ", " : "", 525 hdr->infmval1 & 0x1F, 526 hdr->infmval1 & 0x1F ? " - ???" : ""); 527 if (hdr->infmval2) 528 PRINT_FIELD_0X(", ", *hdr, infmval2); 529 } 530 531 if (cnt_val || hdr->infmscps) 532 PRINT_FIELD_U(", ", *hdr, infmscps); 533 if (cnt_val || hdr->infmdcps) 534 PRINT_FIELD_U(", ", *hdr, infmdcps); 535 if (cnt_val || hdr->infmsifl) 536 PRINT_FIELD_U(", ", *hdr, infmsifl); 537 if (cnt_val || hdr->infmdifl) 538 PRINT_FIELD_U(", ", *hdr, infmdifl); 539 540 if (!abbrev(tcp)) { 541 if (name_val || hdr->infmname) 542 PRINT_FIELD_EBCDIC(", ", *hdr, infmname); 543 544 if (id_val || !IS_ZERO(hdr->infmtype)) 545 PRINT_FIELD_EBCDIC(", ", *hdr, infmtype); 546 if (id_val || !IS_ZERO(hdr->infmmanu)) 547 PRINT_FIELD_EBCDIC(", ", *hdr, infmmanu); 548 if (id_val || !IS_ZERO(hdr->infmseq)) 549 PRINT_FIELD_EBCDIC(", ", *hdr, infmseq); 550 if (id_val || !IS_ZERO(hdr->infmpman)) 551 PRINT_FIELD_EBCDIC(", ", *hdr, infmpman); 552 553 PRINT_UNKNOWN_TAIL(hdr, size); 554 } else { 555 tprints(", ..."); 556 } 557 558 tprints("}"); 559 } 560 561 static void 562 print_sthyi_partition(struct tcb *tcp, struct sthyi_partition *hdr, 563 uint16_t size, bool *mt) 564 { 565 int cnt_val, wcap_val, acap_val, id_val, lpar_val; 566 567 *mt = false; 568 569 CHECK_SIZE(hdr, size, "partition structure"); 570 571 *mt = !!(hdr->infpflg1 & 0x80); 572 573 PRINT_FIELD_0X("/* partition */ {", *hdr, infpflg1); 574 if (!abbrev(tcp) && hdr->infpflg1) 575 tprintf_comment("%s%s%#.0x%s", 576 hdr->infpflg1 & 0x80 ? 577 "0x80 - multithreading is enabled" : "", 578 (hdr->infpflg1 & 0x80) && (hdr->infpflg1 & 0x7F) ? 579 ", " : "", 580 hdr->infpflg1 & 0x7F, 581 hdr->infpflg1 & 0x7F ? " - ???" : ""); 582 if (!abbrev(tcp) && hdr->infpflg2) /* Reserved */ 583 PRINT_FIELD_0X(", ", *hdr, infpflg2); 584 585 PRINT_FIELD_0X(", ", *hdr, infpval1); 586 cnt_val = !!(hdr->infpval1 & 0x80); 587 wcap_val = !!(hdr->infpval1 & 0x40); 588 acap_val = !!(hdr->infpval1 & 0x20); 589 id_val = !!(hdr->infpval1 & 0x10); 590 lpar_val = !!(hdr->infpval1 & 0x08); 591 592 if (!abbrev(tcp) && hdr->infpval1) 593 tprintf_comment("processor count validity: %d, " 594 "partition weight-based capacity validity: %d, " 595 "partition absolute capacity validity: %d, " 596 "partition ID validity: %d, " 597 "LPAR group absolute capacity capping " 598 "information validity: %d%s%#.0x%s", 599 cnt_val, wcap_val, acap_val, id_val, lpar_val, 600 hdr->infpval1 & 0x07 ? ", " : "", 601 hdr->infpval1 & 0x07, 602 hdr->infpval1 & 0x07 ? " - ???" : ""); 603 if (!abbrev(tcp) && hdr->infpval2) /* Reserved */ 604 PRINT_FIELD_0X(", ", *hdr, infpval2); 605 606 if (id_val || hdr->infppnum) 607 PRINT_FIELD_U(", ", *hdr, infppnum); 608 609 if (cnt_val || hdr->infpscps) 610 PRINT_FIELD_U(", ", *hdr, infpscps); 611 if (cnt_val || hdr->infpdcps) 612 PRINT_FIELD_U(", ", *hdr, infpdcps); 613 if (cnt_val || hdr->infpsifl) 614 PRINT_FIELD_U(", ", *hdr, infpsifl); 615 if (cnt_val || hdr->infpdifl) 616 PRINT_FIELD_U(", ", *hdr, infpdifl); 617 618 if (!abbrev(tcp) && !IS_ZERO(hdr->reserved_1__)) 619 PRINT_FIELD_HEX_ARRAY(", ", *hdr, reserved_1__); 620 621 if (id_val || !IS_ZERO(hdr->infppnam)) 622 PRINT_FIELD_EBCDIC(", ", *hdr, infppnam); 623 624 if (!abbrev(tcp)) { 625 if (wcap_val || hdr->infpwbcp) 626 PRINT_FIELD_WEIGHT(", ", *hdr, infpwbcp); 627 if (acap_val || hdr->infpabcp) 628 PRINT_FIELD_WEIGHT(", ", *hdr, infpabcp); 629 if (wcap_val || hdr->infpwbif) 630 PRINT_FIELD_WEIGHT(", ", *hdr, infpwbif); 631 if (acap_val || hdr->infpabif) 632 PRINT_FIELD_WEIGHT(", ", *hdr, infpabif); 633 634 if (!IS_ZERO(hdr->infplgnm)) { 635 PRINT_FIELD_EBCDIC(", ", *hdr, infplgnm); 636 637 PRINT_FIELD_WEIGHT(", ", *hdr, infplgcp); 638 PRINT_FIELD_WEIGHT(", ", *hdr, infplgif); 639 } else { 640 if (lpar_val) 641 PRINT_FIELD_HEX_ARRAY(", ", *hdr, infplgnm); 642 if (hdr->infplgcp) 643 PRINT_FIELD_X(", ", *hdr, infplgcp); 644 if (hdr->infplgif) 645 PRINT_FIELD_X(", ", *hdr, infplgif); 646 } 647 648 PRINT_UNKNOWN_TAIL(hdr, size); 649 } else { 650 tprints(", ..."); 651 } 652 653 tprints("}"); 654 } 655 656 static void 657 print_sthyi_hypervisor(struct tcb *tcp, struct sthyi_hypervisor *hdr, 658 uint16_t size, int num, bool mt) 659 { 660 CHECK_SIZE(hdr, size, "hypervisor %d structure", num); 661 662 tprintf("/* hypervisor %d */ ", num); 663 PRINT_FIELD_0X("{", *hdr, infyflg1); 664 if (!abbrev(tcp) && hdr->infyflg1) 665 tprintf_comment("%s%s%s%s%#.0x%s", 666 hdr->infyflg1 & 0x80 ? 667 "0x80 - guest CPU usage had limiting is using " 668 "the consumption method" : "", 669 (hdr->infyflg1 & 0x80) && (hdr->infyflg1 & 0x40) ? 670 ", " : "", 671 hdr->infyflg1 & 0x40 ? 672 "0x40 - LIMITHARD caps use prorated core time " 673 "for capping" : "", 674 (hdr->infyflg1 & 0xC0) && (hdr->infyflg1 & 0x3F) ? 675 ", " : "", 676 hdr->infyflg1 & 0x3F, 677 hdr->infyflg1 & 0x3F ? " - ???" : ""); 678 679 if (!abbrev(tcp)) { 680 if (hdr->infyflg2) /* Reserved */ 681 PRINT_FIELD_0X(", ", *hdr, infyflg2); 682 if (hdr->infyval1) /* Reserved */ 683 PRINT_FIELD_0X(", ", *hdr, infyval1); 684 if (hdr->infyval2) /* Reserved */ 685 PRINT_FIELD_0X(", ", *hdr, infyval2); 686 687 PRINT_FIELD_U(", ", *hdr, infytype); 688 switch (hdr->infytype) { 689 case 1: 690 tprints_comment("z/VM is the hypervisor"); 691 break; 692 default: 693 tprints_comment("unknown hypervisor type"); 694 } 695 696 if (!IS_ZERO(hdr->reserved_1__)) 697 PRINT_FIELD_HEX_ARRAY(", ", *hdr, reserved_1__); 698 699 if (mt || hdr->infycpt) 700 PRINT_FIELD_U(", ", *hdr, infycpt); 701 if (mt || hdr->infyiflt) 702 PRINT_FIELD_U(", ", *hdr, infyiflt); 703 } 704 705 if (!abbrev(tcp) || !IS_BLANK(hdr->infysyid)) 706 PRINT_FIELD_EBCDIC(", ", *hdr, infysyid); 707 if (!abbrev(tcp) || !IS_BLANK(hdr->infyclnm)) 708 PRINT_FIELD_EBCDIC(", ", *hdr, infyclnm); 709 710 if (!abbrev(tcp) || hdr->infyscps) 711 PRINT_FIELD_U(", ", *hdr, infyscps); 712 if (!abbrev(tcp) || hdr->infydcps) 713 PRINT_FIELD_U(", ", *hdr, infydcps); 714 if (!abbrev(tcp) || hdr->infysifl) 715 PRINT_FIELD_U(", ", *hdr, infysifl); 716 if (!abbrev(tcp) || hdr->infydifl) 717 PRINT_FIELD_U(", ", *hdr, infydifl); 718 719 if (!abbrev(tcp)) { 720 PRINT_UNKNOWN_TAIL(hdr, size); 721 } else { 722 tprints(", ..."); 723 } 724 725 tprints("}"); 726 } 727 728 static void 729 print_sthyi_guest(struct tcb *tcp, struct sthyi_guest *hdr, uint16_t size, 730 int num, bool mt) 731 { 732 CHECK_SIZE(hdr, size, "guest %d structure", num); 733 734 tprintf("/* guest %d */ ", num); 735 PRINT_FIELD_0X("{", *hdr, infgflg1); 736 if (!abbrev(tcp) && hdr->infgflg1) 737 tprintf_comment("%s%s%s%s%s%s%s%s%s%s%s%s%#.0x%s", 738 hdr->infgflg1 & 0x80 ? 739 "0x80 - guest is mobility enabled" : "", 740 (hdr->infgflg1 & 0x80) && (hdr->infgflg1 & 0x40) ? 741 ", " : "", 742 hdr->infgflg1 & 0x40 ? 743 "0x40 - guest has multiple virtual CPU types" : 744 "", 745 (hdr->infgflg1 & 0xC0) && (hdr->infgflg1 & 0x20) ? 746 ", " : "", 747 hdr->infgflg1 & 0x20 ? 748 "0x20 - guest CP dispatch type has LIMITHARD " 749 "cap" : "", 750 (hdr->infgflg1 & 0xE0) && (hdr->infgflg1 & 0x10) ? 751 ", " : "", 752 hdr->infgflg1 & 0x10 ? 753 "0x10 - guest IFL dispatch type has LIMITHARD " 754 "cap" : "", 755 (hdr->infgflg1 & 0xF0) && (hdr->infgflg1 & 0x08) ? 756 ", " : "", 757 hdr->infgflg1 & 0x08 ? 758 "0x08 - virtual CPs are thread dispatched" : 759 "", 760 (hdr->infgflg1 & 0xF8) && (hdr->infgflg1 & 0x04) ? 761 ", " : "", 762 hdr->infgflg1 & 0x04 ? 763 "0x04 - virtual IFLs are thread dispatched" : 764 "", 765 (hdr->infgflg1 & 0xFC) && (hdr->infgflg1 & 0x03) ? 766 ", " : "", 767 hdr->infgflg1 & 0x03, 768 hdr->infgflg1 & 0x03 ? " - ???" : ""); 769 if (!abbrev(tcp)) { 770 if (hdr->infgflg2) /* Reserved */ 771 PRINT_FIELD_0X(", ", *hdr, infgflg2); 772 if (hdr->infgval1) /* Reserved */ 773 PRINT_FIELD_0X(", ", *hdr, infgval1); 774 if (hdr->infgval2) /* Reserved */ 775 PRINT_FIELD_0X(", ", *hdr, infgval2); 776 } 777 778 PRINT_FIELD_EBCDIC(", ", *hdr, infgusid); 779 780 if (!abbrev(tcp) || hdr->infgscps) 781 PRINT_FIELD_U(", ", *hdr, infgscps); 782 if (!abbrev(tcp) || hdr->infgdcps) 783 PRINT_FIELD_U(", ", *hdr, infgdcps); 784 785 if (!abbrev(tcp)) { 786 PRINT_FIELD_U(", ", *hdr, infgcpdt); 787 switch (hdr->infgcpdt) { 788 case 0: 789 tprints_comment("General Purpose (CP)"); 790 break; 791 default: 792 tprints_comment("unknown"); 793 } 794 795 if (!IS_ZERO(hdr->reserved_1__)) 796 PRINT_FIELD_HEX_ARRAY(", ", *hdr, reserved_1__); 797 } 798 799 if (!abbrev(tcp) || hdr->infgcpcc) 800 PRINT_FIELD_WEIGHT(", ", *hdr, infgcpcc); 801 802 if (!abbrev(tcp) || hdr->infgsifl) 803 PRINT_FIELD_U(", ", *hdr, infgsifl); 804 if (!abbrev(tcp) || hdr->infgdifl) 805 PRINT_FIELD_U(", ", *hdr, infgdifl); 806 807 if (!abbrev(tcp)) { 808 PRINT_FIELD_U(", ", *hdr, infgifdt); 809 switch (hdr->infgifdt) { 810 case 0: 811 tprints_comment("General Purpose (CP)"); 812 break; 813 case 3: 814 tprints_comment("Integrated Facility for Linux (IFL)"); 815 break; 816 default: 817 tprints_comment("unknown"); 818 } 819 820 if (!IS_ZERO(hdr->reserved_2__)) 821 PRINT_FIELD_HEX_ARRAY(", ", *hdr, reserved_2__); 822 } 823 824 if (!abbrev(tcp) || hdr->infgifcc) 825 PRINT_FIELD_WEIGHT(", ", *hdr, infgifcc); 826 827 PRINT_FIELD_0X(", ", *hdr, infgpflg); 828 if (!abbrev(tcp) && hdr->infgpflg) 829 tprintf_comment("%s%s%s%s%s%s%s%s%s%s%#.0x%s", 830 hdr->infgpflg & 0x80 ? 831 "0x80 - CPU pool's CP virtual type has " 832 "LIMITHARD cap" : "", 833 (hdr->infgpflg & 0x80) && (hdr->infgpflg & 0x40) ? 834 ", " : "", 835 hdr->infgpflg & 0x40 ? 836 "0x40 - CPU pool's CP virtual type has " 837 "CAPACITY cap" : "", 838 (hdr->infgpflg & 0xC0) && (hdr->infgpflg & 0x20) ? 839 ", " : "", 840 hdr->infgpflg & 0x20 ? 841 "0x20 - CPU pool's IFL virtual type has " 842 "LIMITHARD cap" : "", 843 (hdr->infgpflg & 0xE0) && (hdr->infgpflg & 0x10) ? 844 ", " : "", 845 hdr->infgpflg & 0x10 ? 846 "0x10 - CPU pool's IFL virtual type has " 847 "CAPACITY cap" : "", 848 (hdr->infgpflg & 0xF0) && (hdr->infgpflg & 0x08) ? 849 ", " : "", 850 hdr->infgpflg & 0x08 ? 851 "0x08 - CPU pool uses prorated core time" : "", 852 (hdr->infgpflg & 0xF8) && (hdr->infgpflg & 0x07) ? 853 ", " : "", 854 hdr->infgpflg & 0x07, 855 hdr->infgpflg & 0x07 ? " - ???" : ""); 856 857 if (!abbrev(tcp)) { 858 if (!IS_ZERO(hdr->reserved_3__)) 859 PRINT_FIELD_HEX_ARRAY(", ", *hdr, reserved_3__); 860 861 if (!IS_BLANK(hdr->infgpnam)) 862 PRINT_FIELD_EBCDIC(", ", *hdr, infgpnam); 863 864 PRINT_FIELD_WEIGHT(", ", *hdr, infgpccc); 865 PRINT_FIELD_WEIGHT(", ", *hdr, infgpicc); 866 867 PRINT_UNKNOWN_TAIL(hdr, size); 868 } else { 869 tprints(", ..."); 870 } 871 872 tprints("}"); 873 } 874 875 #define STHYI_PRINT_STRUCT(l_, name_) \ 876 do { \ 877 if (hdr->inf ##l_## off && hdr->inf ##l_## off + \ 878 hdr->inf ##l_## len <= sizeof(data)) { \ 879 tprints(", "); \ 880 print_sthyi_ ##name_(tcp, (struct sthyi_ ##name_ *) \ 881 (data + hdr->inf ##l_## off), \ 882 hdr->inf ##l_## len, &mt); \ 883 } \ 884 } while (0) 885 886 #define STHYI_PRINT_HV_STRUCT(l_, n_, name_) \ 887 do { \ 888 if (hdr->inf ##l_## off ##n_ && hdr->inf ##l_## off ##n_ + \ 889 hdr->inf ##l_## len ##n_ <= sizeof(data)) { \ 890 tprints(", "); \ 891 print_sthyi_ ##name_(tcp, (struct sthyi_ ##name_ *) \ 892 (data + hdr->inf ##l_## off ##n_), \ 893 hdr->inf ##l_## len ##n_, n_, mt); \ 894 } \ 895 } while (0) 896 897 static void 898 print_sthyi_buf(struct tcb *tcp, kernel_ulong_t ptr) 899 { 900 char data[PAGE_SIZE]; 901 struct sthyi_hdr *hdr = (struct sthyi_hdr *) data; 902 bool mt = false; 903 904 if (umove_or_printaddr(tcp, ptr, &data)) 905 return; 906 907 tprints("{"); 908 909 /* Header */ 910 PRINT_FIELD_0X("/* header */ {", *hdr, infhflg1); 911 912 if (abbrev(tcp)) { 913 tprints(", ..."); 914 goto sthyi_sections; 915 } 916 917 if (hdr->infhflg1) 918 tprintf_comment("%s%s%s%s%s%s%s%s%#.0x%s", 919 hdr->infhflg1 & 0x80 ? 920 "0x80 - Global Performance Data unavailable" : 921 "", 922 (hdr->infhflg1 & 0x80) && (hdr->infhflg1 & 0x40) ? 923 ", " : "", 924 hdr->infhflg1 & 0x40 ? 925 "0x40 - One or more hypervisor levels below " 926 "this level does not support the STHYI " 927 "instruction" : "", 928 (hdr->infhflg1 & 0xC0) && (hdr->infhflg1 & 0x20) ? 929 ", " : "", 930 hdr->infhflg1 & 0x20 ? 931 "0x20 - Virtualization stack is incomplete" : 932 "", 933 (hdr->infhflg1 & 0xE0) && (hdr->infhflg1 & 0x10) ? 934 ", " : "", 935 hdr->infhflg1 & 0x10 ? 936 "0x10 - Execution environment is not within " 937 "a logical partition" : "", 938 (hdr->infhflg1 & 0xF0) && (hdr->infhflg1 & 0x0F) ? 939 ", " : "", 940 hdr->infhflg1 & 0x0F, 941 hdr->infhflg1 & 0x0F ? " - ???" : ""); 942 if (hdr->infhflg2) /* Reserved */ 943 PRINT_FIELD_0X(", ", *hdr, infhflg2); 944 if (hdr->infhval1) /* Reserved */ 945 PRINT_FIELD_0X(", ", *hdr, infhval1); 946 if (hdr->infhval2) /* Reserved */ 947 PRINT_FIELD_0X(", ", *hdr, infhval2); 948 949 if (!IS_ZERO(hdr->reserved_1__)) 950 PRINT_FIELD_HEX_ARRAY(", ", *hdr, reserved_1__); 951 952 PRINT_FIELD_U(", ", *hdr, infhygct); 953 PRINT_FIELD_U(", ", *hdr, infhtotl); 954 955 PRINT_FIELD_U(", ", *hdr, infhdln); 956 PRINT_FIELD_U(", ", *hdr, infmoff); 957 PRINT_FIELD_U(", ", *hdr, infmlen); 958 PRINT_FIELD_U(", ", *hdr, infpoff); 959 PRINT_FIELD_U(", ", *hdr, infplen); 960 961 PRINT_FIELD_U(", ", *hdr, infhoff1); 962 PRINT_FIELD_U(", ", *hdr, infhlen1); 963 PRINT_FIELD_U(", ", *hdr, infgoff1); 964 PRINT_FIELD_U(", ", *hdr, infglen1); 965 PRINT_FIELD_U(", ", *hdr, infhoff2); 966 PRINT_FIELD_U(", ", *hdr, infhlen2); 967 PRINT_FIELD_U(", ", *hdr, infgoff2); 968 PRINT_FIELD_U(", ", *hdr, infglen2); 969 PRINT_FIELD_U(", ", *hdr, infhoff3); 970 PRINT_FIELD_U(", ", *hdr, infhlen3); 971 PRINT_FIELD_U(", ", *hdr, infgoff3); 972 PRINT_FIELD_U(", ", *hdr, infglen3); 973 974 PRINT_UNKNOWN_TAIL(hdr, hdr->infhdln); 975 976 sthyi_sections: 977 tprints("}"); 978 979 STHYI_PRINT_STRUCT(m, machine); 980 STHYI_PRINT_STRUCT(p, partition); 981 982 STHYI_PRINT_HV_STRUCT(h, 1, hypervisor); 983 STHYI_PRINT_HV_STRUCT(g, 1, guest); 984 STHYI_PRINT_HV_STRUCT(h, 2, hypervisor); 985 STHYI_PRINT_HV_STRUCT(g, 2, guest); 986 STHYI_PRINT_HV_STRUCT(h, 3, hypervisor); 987 STHYI_PRINT_HV_STRUCT(g, 3, guest); 988 989 tprints("}"); 990 } 991 992 /** 993 * Wrapper for the s390 STHYI instruction that provides hypervisor information. 994 * 995 * See https://www.ibm.com/support/knowledgecenter/SSB27U_6.3.0/com.ibm.zvm.v630.hcpb4/hcpb4sth.htm 996 * for the instruction documentation. 997 * 998 * The difference in the kernel wrapper is that it doesn't require the 4K 999 * alignment for the resp_buffer page (as it just copies from the internal 1000 * cache). 1001 */ 1002 SYS_FUNC(s390_sthyi) 1003 { 1004 /* in, function ID from s390_sthyi_function_codes */ 1005 kernel_ulong_t function_code = tcp->u_arg[0]; 1006 /* out, pointer to page-sized buffer */ 1007 kernel_ulong_t resp_buffer_ptr = tcp->u_arg[1]; 1008 /* out, pointer to u64 containing function result */ 1009 kernel_ulong_t return_code_ptr = tcp->u_arg[2]; 1010 /* in, should be 0, at the moment */ 1011 kernel_ulong_t flags = tcp->u_arg[3]; 1012 1013 if (entering(tcp)) { 1014 printxval64(s390_sthyi_function_codes, function_code, 1015 "STHYI_FC_???"); 1016 tprints(", "); 1017 } else { 1018 switch (function_code) { 1019 case STHYI_FC_CP_IFL_CAP: 1020 print_sthyi_buf(tcp, resp_buffer_ptr); 1021 break; 1022 1023 default: 1024 printaddr(resp_buffer_ptr); 1025 } 1026 1027 tprints(", "); 1028 printnum_int64(tcp, return_code_ptr, "%" PRIu64); 1029 tprintf(", %#" PRI_klx, flags); 1030 } 1031 1032 return 0; 1033 } 1034 1035 1036 /* 1037 * Structures are written based on 1038 * https://www-304.ibm.com/support/docview.wss?uid=isg29c69415c1e82603c852576700058075a&aid=1#page=85 1039 */ 1040 1041 struct guard_storage_control_block { 1042 uint64_t reserved; 1043 /** 1044 * Guard Storage Designation 1045 * - Bits 0..J, J == 64-GSC - Guard Storage Origin (GSO) 1046 * - Bits 53..55 - Guard Load Shift (GLS) 1047 * - Bits 58..63 - Guard Storage Characteristic (GSC), this is J from 1048 * the first item, valud values are 25..56. 1049 */ 1050 uint64_t gsd; 1051 uint64_t gssm; /**< Guard Storage Section Mask */ 1052 uint64_t gs_epl_a; /**< Guard Storage Event Parameter List Address */ 1053 }; 1054 1055 struct guard_storage_event_parameter_list { 1056 uint8_t pad1; 1057 /** 1058 * Guard Storage Event Addressing Mode 1059 * - 0x40 - Extended addressing mode (E) 1060 * - 0x80 - Basic addressing mode (B) 1061 */ 1062 uint8_t gs_eam; 1063 /** 1064 * Guard Storage Event Cause indication 1065 * - 0x01 - CPU was in transaction execution mode (TX) 1066 * - 0x02 - CPU was in constrained transaction execution mode (CX) 1067 * - 0x80 - Instruction causing the event: 0 - LGG, 1 - LLGFGS 1068 */ 1069 uint8_t gs_eci; 1070 /** 1071 * Guard Storage Event Access Information 1072 * - 0x01 - DAT mode 1073 * - Bits 1..2 - Address space indication 1074 * - Bits 4..7 - AR number 1075 */ 1076 uint8_t gs_eai; 1077 uint32_t pad2; 1078 uint64_t gs_eha; /**< Guard Storage Event Handler Address */ 1079 uint64_t gs_eia; /**< Guard Storage Event Instruction Address */ 1080 uint64_t gs_eoa; /**< Guard Storage Event Operation Address */ 1081 uint64_t gs_eir; /**< Guard Storage Event Intermediate Result */ 1082 uint64_t gs_era; /**< Guard Storage Event Return Address */ 1083 }; 1084 1085 static void 1086 guard_storage_print_gsepl(struct tcb *tcp, uint64_t addr) 1087 { 1088 struct guard_storage_event_parameter_list gsepl; 1089 1090 /* Since it is 64-bit even on 31-bit s390... */ 1091 if (sizeof(addr) > current_klongsize && 1092 addr >= (1ULL << (current_klongsize * 8))) { 1093 tprintf("%#" PRIx64, addr); 1094 1095 return; 1096 } 1097 1098 if (umove_or_printaddr(tcp, addr, &gsepl)) 1099 return; 1100 1101 tprints("[{"); 1102 1103 if (!abbrev(tcp)) { 1104 if (gsepl.pad1) { 1105 PRINT_FIELD_0X("", gsepl, pad1); 1106 tprints(", "); 1107 } 1108 1109 PRINT_FIELD_0X("", gsepl, gs_eam); 1110 tprintf_comment("extended addressing mode: %u, " 1111 "basic addressing mode: %u", 1112 !!(gsepl.gs_eam & 0x2), !!(gsepl.gs_eam & 0x1)); 1113 1114 PRINT_FIELD_0X(", ", gsepl, gs_eci); 1115 tprintf_comment("CPU in TX: %u, CPU in CX: %u, instruction: %s", 1116 !!(gsepl.gs_eci & 0x80), 1117 !!(gsepl.gs_eci & 0x40), 1118 gsepl.gs_eci & 0x01 ? "LLGFGS" : "LGG"); 1119 1120 PRINT_FIELD_0X(", ", gsepl, gs_eai); 1121 tprintf_comment("DAT: %u, address space indication: %u, " 1122 "AR number: %u", 1123 !!(gsepl.gs_eai & 0x40), 1124 (gsepl.gs_eai >> 4) & 0x3, 1125 gsepl.gs_eai & 0xF); 1126 1127 if (gsepl.pad2) 1128 PRINT_FIELD_0X(", ", gsepl, pad2); 1129 1130 tprints(", "); 1131 } 1132 1133 PRINT_FIELD_X("", gsepl, gs_eha); 1134 1135 if (!abbrev(tcp)) { 1136 PRINT_FIELD_X(", ", gsepl, gs_eia); 1137 PRINT_FIELD_X(", ", gsepl, gs_eoa); 1138 PRINT_FIELD_X(", ", gsepl, gs_eir); 1139 PRINT_FIELD_X(", ", gsepl, gs_era); 1140 } else { 1141 tprints(", ..."); 1142 } 1143 1144 tprints("}]"); 1145 } 1146 1147 # define DIV_ROUND_UP(x,y) (((x) + ((y) - 1)) / (y)) 1148 1149 static void 1150 guard_storage_print_gscb(struct tcb *tcp, kernel_ulong_t addr) 1151 { 1152 struct guard_storage_control_block gscb; 1153 1154 if (umove_or_printaddr(tcp, addr, &gscb)) 1155 return; 1156 1157 tprints("{"); 1158 1159 if (gscb.reserved) { 1160 PRINT_FIELD_0X("", gscb, reserved); 1161 tprints(", "); 1162 } 1163 1164 PRINT_FIELD_0X("", gscb, gsd); 1165 1166 if (!abbrev(tcp)) { 1167 unsigned int gsc = gscb.gsd & 0x3F; 1168 bool gsc_valid = gsc >= 25 && gsc <= 56; 1169 tprintf_comment("GS origin: %#*.*" PRIx64 "%s, " 1170 "guard load shift: %" PRIu64 ", " 1171 "GS characteristic: %u", 1172 gsc_valid ? 2 + DIV_ROUND_UP(64 - gsc, 4) : 0, 1173 gsc_valid ? DIV_ROUND_UP(64 - gsc, 4) : 0, 1174 gsc_valid ? gscb.gsd >> gsc : 0, 1175 gsc_valid ? "" : "[invalid]", 1176 (gscb.gsd >> 8) & 0x7, gsc); 1177 } 1178 1179 PRINT_FIELD_0X(", ", gscb, gssm); 1180 1181 tprints(", gs_epl_a="); 1182 guard_storage_print_gsepl(tcp, gscb.gs_epl_a); 1183 1184 tprints("}"); 1185 } 1186 1187 SYS_FUNC(s390_guarded_storage) 1188 { 1189 int command = (int) tcp->u_arg[0]; 1190 kernel_ulong_t gs_cb = tcp->u_arg[1]; 1191 1192 printxval(s390_guarded_storage_commands, command, "GS_???"); 1193 1194 switch (command) { 1195 case GS_ENABLE: 1196 case GS_DISABLE: 1197 case GS_CLEAR_BC_CB: 1198 case GS_BROADCAST: 1199 break; 1200 1201 case GS_SET_BC_CB: 1202 tprints(", "); 1203 guard_storage_print_gscb(tcp, gs_cb); 1204 break; 1205 1206 default: 1207 tprints(", "); 1208 printaddr(gs_cb); 1209 } 1210 1211 return RVAL_DECODED; 1212 } 1213 1214 SYS_FUNC(s390_runtime_instr) 1215 { 1216 int command = (int) tcp->u_arg[0]; 1217 int signum = (int) tcp->u_arg[1]; 1218 1219 const char *command_descr = 1220 xlookup(s390_runtime_instr_commands, command); 1221 1222 tprintf("%d", command); 1223 tprints_comment(command_descr ? command_descr : 1224 "S390_RUNTIME_INSTR_???"); 1225 1226 /* 1227 * signum is ignored since Linux 4.4, but let's print it for start 1228 * command anyway. 1229 */ 1230 switch (command) { 1231 case S390_RUNTIME_INSTR_START: 1232 tprints(", "); 1233 tprints(signame(signum)); 1234 break; 1235 1236 case S390_RUNTIME_INSTR_STOP: 1237 default: 1238 break; 1239 } 1240 1241 return RVAL_DECODED; 1242 } 1243 1244 SYS_FUNC(s390_pci_mmio_write) 1245 { 1246 kernel_ulong_t mmio_addr = tcp->u_arg[0]; 1247 kernel_ulong_t user_buf = tcp->u_arg[1]; 1248 kernel_ulong_t length = tcp->u_arg[2]; 1249 1250 tprintf("%#" PRI_klx ", ", mmio_addr); 1251 printstr_ex(tcp, user_buf, length, QUOTE_FORCE_HEX); 1252 tprintf(", %" PRI_klu, length); 1253 1254 return RVAL_DECODED; 1255 } 1256 1257 SYS_FUNC(s390_pci_mmio_read) 1258 { 1259 kernel_ulong_t mmio_addr = tcp->u_arg[0]; 1260 kernel_ulong_t user_buf = tcp->u_arg[1]; 1261 kernel_ulong_t length = tcp->u_arg[2]; 1262 1263 if (entering(tcp)) { 1264 tprintf("%#" PRI_klx ", ", mmio_addr); 1265 } else { 1266 if (!syserror(tcp)) 1267 printstr_ex(tcp, user_buf, length, QUOTE_FORCE_HEX); 1268 else 1269 printaddr(user_buf); 1270 1271 tprintf(", %" PRI_klu, length); 1272 } 1273 1274 return 0; 1275 } 1276 1277 #endif /* defined S390 || defined S390X */ 1278
