1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * store hypervisor information instruction emulation functions. 4 * 5 * Copyright IBM Corp. 2016 6 * Author(s): Janosch Frank <frankja@linux.vnet.ibm.com> 7 */ 8 #include <linux/errno.h> 9 #include <linux/pagemap.h> 10 #include <linux/vmalloc.h> 11 #include <linux/syscalls.h> 12 #include <linux/mutex.h> 13 #include <asm/asm-offsets.h> 14 #include <asm/sclp.h> 15 #include <asm/diag.h> 16 #include <asm/sysinfo.h> 17 #include <asm/ebcdic.h> 18 #include <asm/facility.h> 19 #include <asm/sthyi.h> 20 #include "entry.h" 21 22 #define DED_WEIGHT 0xffff 23 /* 24 * CP and IFL as EBCDIC strings, SP/0x40 determines the end of string 25 * as they are justified with spaces. 26 */ 27 #define CP 0xc3d7404040404040UL 28 #define IFL 0xc9c6d34040404040UL 29 30 enum hdr_flags { 31 HDR_NOT_LPAR = 0x10, 32 HDR_STACK_INCM = 0x20, 33 HDR_STSI_UNAV = 0x40, 34 HDR_PERF_UNAV = 0x80, 35 }; 36 37 enum mac_validity { 38 MAC_NAME_VLD = 0x20, 39 MAC_ID_VLD = 0x40, 40 MAC_CNT_VLD = 0x80, 41 }; 42 43 enum par_flag { 44 PAR_MT_EN = 0x80, 45 }; 46 47 enum par_validity { 48 PAR_GRP_VLD = 0x08, 49 PAR_ID_VLD = 0x10, 50 PAR_ABS_VLD = 0x20, 51 PAR_WGHT_VLD = 0x40, 52 PAR_PCNT_VLD = 0x80, 53 }; 54 55 struct hdr_sctn { 56 u8 infhflg1; 57 u8 infhflg2; /* reserved */ 58 u8 infhval1; /* reserved */ 59 u8 infhval2; /* reserved */ 60 u8 reserved[3]; 61 u8 infhygct; 62 u16 infhtotl; 63 u16 infhdln; 64 u16 infmoff; 65 u16 infmlen; 66 u16 infpoff; 67 u16 infplen; 68 u16 infhoff1; 69 u16 infhlen1; 70 u16 infgoff1; 71 u16 infglen1; 72 u16 infhoff2; 73 u16 infhlen2; 74 u16 infgoff2; 75 u16 infglen2; 76 u16 infhoff3; 77 u16 infhlen3; 78 u16 infgoff3; 79 u16 infglen3; 80 u8 reserved2[4]; 81 } __packed; 82 83 struct mac_sctn { 84 u8 infmflg1; /* reserved */ 85 u8 infmflg2; /* reserved */ 86 u8 infmval1; 87 u8 infmval2; /* reserved */ 88 u16 infmscps; 89 u16 infmdcps; 90 u16 infmsifl; 91 u16 infmdifl; 92 char infmname[8]; 93 char infmtype[4]; 94 char infmmanu[16]; 95 char infmseq[16]; 96 char infmpman[4]; 97 u8 reserved[4]; 98 } __packed; 99 100 struct par_sctn { 101 u8 infpflg1; 102 u8 infpflg2; /* reserved */ 103 u8 infpval1; 104 u8 infpval2; /* reserved */ 105 u16 infppnum; 106 u16 infpscps; 107 u16 infpdcps; 108 u16 infpsifl; 109 u16 infpdifl; 110 u16 reserved; 111 char infppnam[8]; 112 u32 infpwbcp; 113 u32 infpabcp; 114 u32 infpwbif; 115 u32 infpabif; 116 char infplgnm[8]; 117 u32 infplgcp; 118 u32 infplgif; 119 } __packed; 120 121 struct sthyi_sctns { 122 struct hdr_sctn hdr; 123 struct mac_sctn mac; 124 struct par_sctn par; 125 } __packed; 126 127 struct cpu_inf { 128 u64 lpar_cap; 129 u64 lpar_grp_cap; 130 u64 lpar_weight; 131 u64 all_weight; 132 int cpu_num_ded; 133 int cpu_num_shd; 134 }; 135 136 struct lpar_cpu_inf { 137 struct cpu_inf cp; 138 struct cpu_inf ifl; 139 }; 140 141 /* 142 * STHYI requires extensive locking in the higher hypervisors 143 * and is very computational/memory expensive. Therefore we 144 * cache the retrieved data whose valid period is 1s. 145 */ 146 #define CACHE_VALID_JIFFIES HZ 147 148 struct sthyi_info { 149 void *info; 150 unsigned long end; 151 }; 152 153 static DEFINE_MUTEX(sthyi_mutex); 154 static struct sthyi_info sthyi_cache; 155 156 static inline u64 cpu_id(u8 ctidx, void *diag224_buf) 157 { 158 return *((u64 *)(diag224_buf + (ctidx + 1) * DIAG204_CPU_NAME_LEN)); 159 } 160 161 /* 162 * Scales the cpu capping from the lpar range to the one expected in 163 * sthyi data. 164 * 165 * diag204 reports a cap in hundredths of processor units. 166 * z/VM's range for one core is 0 - 0x10000. 167 */ 168 static u32 scale_cap(u32 in) 169 { 170 return (0x10000 * in) / 100; 171 } 172 173 static void fill_hdr(struct sthyi_sctns *sctns) 174 { 175 sctns->hdr.infhdln = sizeof(sctns->hdr); 176 sctns->hdr.infmoff = sizeof(sctns->hdr); 177 sctns->hdr.infmlen = sizeof(sctns->mac); 178 sctns->hdr.infplen = sizeof(sctns->par); 179 sctns->hdr.infpoff = sctns->hdr.infhdln + sctns->hdr.infmlen; 180 sctns->hdr.infhtotl = sctns->hdr.infpoff + sctns->hdr.infplen; 181 } 182 183 static void fill_stsi_mac(struct sthyi_sctns *sctns, 184 struct sysinfo_1_1_1 *sysinfo) 185 { 186 sclp_ocf_cpc_name_copy(sctns->mac.infmname); 187 if (*(u64 *)sctns->mac.infmname != 0) 188 sctns->mac.infmval1 |= MAC_NAME_VLD; 189 190 if (stsi(sysinfo, 1, 1, 1)) 191 return; 192 193 memcpy(sctns->mac.infmtype, sysinfo->type, sizeof(sctns->mac.infmtype)); 194 memcpy(sctns->mac.infmmanu, sysinfo->manufacturer, sizeof(sctns->mac.infmmanu)); 195 memcpy(sctns->mac.infmpman, sysinfo->plant, sizeof(sctns->mac.infmpman)); 196 memcpy(sctns->mac.infmseq, sysinfo->sequence, sizeof(sctns->mac.infmseq)); 197 198 sctns->mac.infmval1 |= MAC_ID_VLD; 199 } 200 201 static void fill_stsi_par(struct sthyi_sctns *sctns, 202 struct sysinfo_2_2_2 *sysinfo) 203 { 204 if (stsi(sysinfo, 2, 2, 2)) 205 return; 206 207 sctns->par.infppnum = sysinfo->lpar_number; 208 memcpy(sctns->par.infppnam, sysinfo->name, sizeof(sctns->par.infppnam)); 209 210 sctns->par.infpval1 |= PAR_ID_VLD; 211 } 212 213 static void fill_stsi(struct sthyi_sctns *sctns) 214 { 215 void *sysinfo; 216 217 /* Errors are handled through the validity bits in the response. */ 218 sysinfo = (void *)__get_free_page(GFP_KERNEL); 219 if (!sysinfo) 220 return; 221 222 fill_stsi_mac(sctns, sysinfo); 223 fill_stsi_par(sctns, sysinfo); 224 225 free_pages((unsigned long)sysinfo, 0); 226 } 227 228 static void fill_diag_mac(struct sthyi_sctns *sctns, 229 struct diag204_x_phys_block *block, 230 void *diag224_buf) 231 { 232 int i; 233 234 for (i = 0; i < block->hdr.cpus; i++) { 235 switch (cpu_id(block->cpus[i].ctidx, diag224_buf)) { 236 case CP: 237 if (block->cpus[i].weight == DED_WEIGHT) 238 sctns->mac.infmdcps++; 239 else 240 sctns->mac.infmscps++; 241 break; 242 case IFL: 243 if (block->cpus[i].weight == DED_WEIGHT) 244 sctns->mac.infmdifl++; 245 else 246 sctns->mac.infmsifl++; 247 break; 248 } 249 } 250 sctns->mac.infmval1 |= MAC_CNT_VLD; 251 } 252 253 /* Returns a pointer to the the next partition block. */ 254 static struct diag204_x_part_block *lpar_cpu_inf(struct lpar_cpu_inf *part_inf, 255 bool this_lpar, 256 void *diag224_buf, 257 struct diag204_x_part_block *block) 258 { 259 int i, capped = 0, weight_cp = 0, weight_ifl = 0; 260 struct cpu_inf *cpu_inf; 261 262 for (i = 0; i < block->hdr.rcpus; i++) { 263 if (!(block->cpus[i].cflag & DIAG204_CPU_ONLINE)) 264 continue; 265 266 switch (cpu_id(block->cpus[i].ctidx, diag224_buf)) { 267 case CP: 268 cpu_inf = &part_inf->cp; 269 if (block->cpus[i].cur_weight < DED_WEIGHT) 270 weight_cp |= block->cpus[i].cur_weight; 271 break; 272 case IFL: 273 cpu_inf = &part_inf->ifl; 274 if (block->cpus[i].cur_weight < DED_WEIGHT) 275 weight_ifl |= block->cpus[i].cur_weight; 276 break; 277 default: 278 continue; 279 } 280 281 if (!this_lpar) 282 continue; 283 284 capped |= block->cpus[i].cflag & DIAG204_CPU_CAPPED; 285 cpu_inf->lpar_cap |= block->cpus[i].cpu_type_cap; 286 cpu_inf->lpar_grp_cap |= block->cpus[i].group_cpu_type_cap; 287 288 if (block->cpus[i].weight == DED_WEIGHT) 289 cpu_inf->cpu_num_ded += 1; 290 else 291 cpu_inf->cpu_num_shd += 1; 292 } 293 294 if (this_lpar && capped) { 295 part_inf->cp.lpar_weight = weight_cp; 296 part_inf->ifl.lpar_weight = weight_ifl; 297 } 298 part_inf->cp.all_weight += weight_cp; 299 part_inf->ifl.all_weight += weight_ifl; 300 return (struct diag204_x_part_block *)&block->cpus[i]; 301 } 302 303 static void fill_diag(struct sthyi_sctns *sctns) 304 { 305 int i, r, pages; 306 bool this_lpar; 307 void *diag204_buf; 308 void *diag224_buf = NULL; 309 struct diag204_x_info_blk_hdr *ti_hdr; 310 struct diag204_x_part_block *part_block; 311 struct diag204_x_phys_block *phys_block; 312 struct lpar_cpu_inf lpar_inf = {}; 313 314 /* Errors are handled through the validity bits in the response. */ 315 pages = diag204((unsigned long)DIAG204_SUBC_RSI | 316 (unsigned long)DIAG204_INFO_EXT, 0, NULL); 317 if (pages <= 0) 318 return; 319 320 diag204_buf = vmalloc(array_size(pages, PAGE_SIZE)); 321 if (!diag204_buf) 322 return; 323 324 r = diag204((unsigned long)DIAG204_SUBC_STIB7 | 325 (unsigned long)DIAG204_INFO_EXT, pages, diag204_buf); 326 if (r < 0) 327 goto out; 328 329 diag224_buf = (void *)__get_free_page(GFP_KERNEL | GFP_DMA); 330 if (!diag224_buf || diag224(diag224_buf)) 331 goto out; 332 333 ti_hdr = diag204_buf; 334 part_block = diag204_buf + sizeof(*ti_hdr); 335 336 for (i = 0; i < ti_hdr->npar; i++) { 337 /* 338 * For the calling lpar we also need to get the cpu 339 * caps and weights. The time information block header 340 * specifies the offset to the partition block of the 341 * caller lpar, so we know when we process its data. 342 */ 343 this_lpar = (void *)part_block - diag204_buf == ti_hdr->this_part; 344 part_block = lpar_cpu_inf(&lpar_inf, this_lpar, diag224_buf, 345 part_block); 346 } 347 348 phys_block = (struct diag204_x_phys_block *)part_block; 349 part_block = diag204_buf + ti_hdr->this_part; 350 if (part_block->hdr.mtid) 351 sctns->par.infpflg1 = PAR_MT_EN; 352 353 sctns->par.infpval1 |= PAR_GRP_VLD; 354 sctns->par.infplgcp = scale_cap(lpar_inf.cp.lpar_grp_cap); 355 sctns->par.infplgif = scale_cap(lpar_inf.ifl.lpar_grp_cap); 356 memcpy(sctns->par.infplgnm, part_block->hdr.hardware_group_name, 357 sizeof(sctns->par.infplgnm)); 358 359 sctns->par.infpscps = lpar_inf.cp.cpu_num_shd; 360 sctns->par.infpdcps = lpar_inf.cp.cpu_num_ded; 361 sctns->par.infpsifl = lpar_inf.ifl.cpu_num_shd; 362 sctns->par.infpdifl = lpar_inf.ifl.cpu_num_ded; 363 sctns->par.infpval1 |= PAR_PCNT_VLD; 364 365 sctns->par.infpabcp = scale_cap(lpar_inf.cp.lpar_cap); 366 sctns->par.infpabif = scale_cap(lpar_inf.ifl.lpar_cap); 367 sctns->par.infpval1 |= PAR_ABS_VLD; 368 369 /* 370 * Everything below needs global performance data to be 371 * meaningful. 372 */ 373 if (!(ti_hdr->flags & DIAG204_LPAR_PHYS_FLG)) { 374 sctns->hdr.infhflg1 |= HDR_PERF_UNAV; 375 goto out; 376 } 377 378 fill_diag_mac(sctns, phys_block, diag224_buf); 379 380 if (lpar_inf.cp.lpar_weight) { 381 sctns->par.infpwbcp = sctns->mac.infmscps * 0x10000 * 382 lpar_inf.cp.lpar_weight / lpar_inf.cp.all_weight; 383 } 384 385 if (lpar_inf.ifl.lpar_weight) { 386 sctns->par.infpwbif = sctns->mac.infmsifl * 0x10000 * 387 lpar_inf.ifl.lpar_weight / lpar_inf.ifl.all_weight; 388 } 389 sctns->par.infpval1 |= PAR_WGHT_VLD; 390 391 out: 392 free_page((unsigned long)diag224_buf); 393 vfree(diag204_buf); 394 } 395 396 static int sthyi(u64 vaddr, u64 *rc) 397 { 398 union register_pair r1 = { .even = 0, }; /* subcode */ 399 union register_pair r2 = { .even = vaddr, }; 400 int cc; 401 402 asm volatile( 403 ".insn rre,0xB2560000,%[r1],%[r2]\n" 404 "ipm %[cc]\n" 405 "srl %[cc],28\n" 406 : [cc] "=&d" (cc), [r2] "+&d" (r2.pair) 407 : [r1] "d" (r1.pair) 408 : "memory", "cc"); 409 *rc = r2.odd; 410 return cc; 411 } 412 413 static int fill_dst(void *dst, u64 *rc) 414 { 415 struct sthyi_sctns *sctns = (struct sthyi_sctns *)dst; 416 417 /* 418 * If the facility is on, we don't want to emulate the instruction. 419 * We ask the hypervisor to provide the data. 420 */ 421 if (test_facility(74)) 422 return sthyi((u64)dst, rc); 423 424 fill_hdr(sctns); 425 fill_stsi(sctns); 426 fill_diag(sctns); 427 *rc = 0; 428 return 0; 429 } 430 431 static int sthyi_init_cache(void) 432 { 433 if (sthyi_cache.info) 434 return 0; 435 sthyi_cache.info = (void *)get_zeroed_page(GFP_KERNEL); 436 if (!sthyi_cache.info) 437 return -ENOMEM; 438 sthyi_cache.end = jiffies - 1; /* expired */ 439 return 0; 440 } 441 442 static int sthyi_update_cache(u64 *rc) 443 { 444 int r; 445 446 memset(sthyi_cache.info, 0, PAGE_SIZE); 447 r = fill_dst(sthyi_cache.info, rc); 448 if (r) 449 return r; 450 sthyi_cache.end = jiffies + CACHE_VALID_JIFFIES; 451 return r; 452 } 453 454 /* 455 * sthyi_fill - Fill page with data returned by the STHYI instruction 456 * 457 * @dst: Pointer to zeroed page 458 * @rc: Pointer for storing the return code of the instruction 459 * 460 * Fills the destination with system information returned by the STHYI 461 * instruction. The data is generated by emulation or execution of STHYI, 462 * if available. The return value is the condition code that would be 463 * returned, the rc parameter is the return code which is passed in 464 * register R2 + 1. 465 */ 466 int sthyi_fill(void *dst, u64 *rc) 467 { 468 int r; 469 470 mutex_lock(&sthyi_mutex); 471 r = sthyi_init_cache(); 472 if (r) 473 goto out; 474 475 if (time_is_before_jiffies(sthyi_cache.end)) { 476 /* cache expired */ 477 r = sthyi_update_cache(rc); 478 if (r) 479 goto out; 480 } 481 *rc = 0; 482 memcpy(dst, sthyi_cache.info, PAGE_SIZE); 483 out: 484 mutex_unlock(&sthyi_mutex); 485 return r; 486 } 487 EXPORT_SYMBOL_GPL(sthyi_fill); 488 489 SYSCALL_DEFINE4(s390_sthyi, unsigned long, function_code, void __user *, buffer, 490 u64 __user *, return_code, unsigned long, flags) 491 { 492 u64 sthyi_rc; 493 void *info; 494 int r; 495 496 if (flags) 497 return -EINVAL; 498 if (function_code != STHYI_FC_CP_IFL_CAP) 499 return -EOPNOTSUPP; 500 info = (void *)get_zeroed_page(GFP_KERNEL); 501 if (!info) 502 return -ENOMEM; 503 r = sthyi_fill(info, &sthyi_rc); 504 if (r < 0) 505 goto out; 506 if (return_code && put_user(sthyi_rc, return_code)) { 507 r = -EFAULT; 508 goto out; 509 } 510 if (copy_to_user(buffer, info, PAGE_SIZE)) 511 r = -EFAULT; 512 out: 513 free_page((unsigned long)info); 514 return r; 515 } 516