1 /* 2 * arch/s390/hypfs/hypfs_diag.c 3 * Hypervisor filesystem for Linux on s390. Diag 204 and 224 4 * implementation. 5 * 6 * Copyright (C) IBM Corp. 2006 7 * Author(s): Michael Holzheu <holzheu@de.ibm.com> 8 */ 9 10 #include <linux/types.h> 11 #include <linux/errno.h> 12 #include <linux/string.h> 13 #include <linux/vmalloc.h> 14 #include <asm/ebcdic.h> 15 #include "hypfs.h" 16 17 #define LPAR_NAME_LEN 8 /* lpar name len in diag 204 data */ 18 #define CPU_NAME_LEN 16 /* type name len of cpus in diag224 name table */ 19 #define TMP_SIZE 64 /* size of temporary buffers */ 20 21 /* diag 204 subcodes */ 22 enum diag204_sc { 23 SUBC_STIB4 = 4, 24 SUBC_RSI = 5, 25 SUBC_STIB6 = 6, 26 SUBC_STIB7 = 7 27 }; 28 29 /* The two available diag 204 data formats */ 30 enum diag204_format { 31 INFO_SIMPLE = 0, 32 INFO_EXT = 0x00010000 33 }; 34 35 /* bit is set in flags, when physical cpu info is included in diag 204 data */ 36 #define LPAR_PHYS_FLG 0x80 37 38 static char *diag224_cpu_names; /* diag 224 name table */ 39 static enum diag204_sc diag204_store_sc; /* used subcode for store */ 40 static enum diag204_format diag204_info_type; /* used diag 204 data format */ 41 42 static void *diag204_buf; /* 4K aligned buffer for diag204 data */ 43 static void *diag204_buf_vmalloc; /* vmalloc pointer for diag204 data */ 44 static int diag204_buf_pages; /* number of pages for diag204 data */ 45 46 /* 47 * DIAG 204 data structures and member access functions. 48 * 49 * Since we have two different diag 204 data formats for old and new s390 50 * machines, we do not access the structs directly, but use getter functions for 51 * each struct member instead. This should make the code more readable. 52 */ 53 54 /* Time information block */ 55 56 struct info_blk_hdr { 57 __u8 npar; 58 __u8 flags; 59 __u16 tslice; 60 __u16 phys_cpus; 61 __u16 this_part; 62 __u64 curtod; 63 } __attribute__ ((packed)); 64 65 struct x_info_blk_hdr { 66 __u8 npar; 67 __u8 flags; 68 __u16 tslice; 69 __u16 phys_cpus; 70 __u16 this_part; 71 __u64 curtod1; 72 __u64 curtod2; 73 char reserved[40]; 74 } __attribute__ ((packed)); 75 76 static inline int info_blk_hdr__size(enum diag204_format type) 77 { 78 if (type == INFO_SIMPLE) 79 return sizeof(struct info_blk_hdr); 80 else /* INFO_EXT */ 81 return sizeof(struct x_info_blk_hdr); 82 } 83 84 static inline __u8 info_blk_hdr__npar(enum diag204_format type, void *hdr) 85 { 86 if (type == INFO_SIMPLE) 87 return ((struct info_blk_hdr *)hdr)->npar; 88 else /* INFO_EXT */ 89 return ((struct x_info_blk_hdr *)hdr)->npar; 90 } 91 92 static inline __u8 info_blk_hdr__flags(enum diag204_format type, void *hdr) 93 { 94 if (type == INFO_SIMPLE) 95 return ((struct info_blk_hdr *)hdr)->flags; 96 else /* INFO_EXT */ 97 return ((struct x_info_blk_hdr *)hdr)->flags; 98 } 99 100 static inline __u16 info_blk_hdr__pcpus(enum diag204_format type, void *hdr) 101 { 102 if (type == INFO_SIMPLE) 103 return ((struct info_blk_hdr *)hdr)->phys_cpus; 104 else /* INFO_EXT */ 105 return ((struct x_info_blk_hdr *)hdr)->phys_cpus; 106 } 107 108 /* Partition header */ 109 110 struct part_hdr { 111 __u8 pn; 112 __u8 cpus; 113 char reserved[6]; 114 char part_name[LPAR_NAME_LEN]; 115 } __attribute__ ((packed)); 116 117 struct x_part_hdr { 118 __u8 pn; 119 __u8 cpus; 120 __u8 rcpus; 121 __u8 pflag; 122 __u32 mlu; 123 char part_name[LPAR_NAME_LEN]; 124 char lpc_name[8]; 125 char os_name[8]; 126 __u64 online_cs; 127 __u64 online_es; 128 __u8 upid; 129 char reserved1[3]; 130 __u32 group_mlu; 131 char group_name[8]; 132 char reserved2[32]; 133 } __attribute__ ((packed)); 134 135 static inline int part_hdr__size(enum diag204_format type) 136 { 137 if (type == INFO_SIMPLE) 138 return sizeof(struct part_hdr); 139 else /* INFO_EXT */ 140 return sizeof(struct x_part_hdr); 141 } 142 143 static inline __u8 part_hdr__rcpus(enum diag204_format type, void *hdr) 144 { 145 if (type == INFO_SIMPLE) 146 return ((struct part_hdr *)hdr)->cpus; 147 else /* INFO_EXT */ 148 return ((struct x_part_hdr *)hdr)->rcpus; 149 } 150 151 static inline void part_hdr__part_name(enum diag204_format type, void *hdr, 152 char *name) 153 { 154 if (type == INFO_SIMPLE) 155 memcpy(name, ((struct part_hdr *)hdr)->part_name, 156 LPAR_NAME_LEN); 157 else /* INFO_EXT */ 158 memcpy(name, ((struct x_part_hdr *)hdr)->part_name, 159 LPAR_NAME_LEN); 160 EBCASC(name, LPAR_NAME_LEN); 161 name[LPAR_NAME_LEN] = 0; 162 strstrip(name); 163 } 164 165 struct cpu_info { 166 __u16 cpu_addr; 167 char reserved1[2]; 168 __u8 ctidx; 169 __u8 cflag; 170 __u16 weight; 171 __u64 acc_time; 172 __u64 lp_time; 173 } __attribute__ ((packed)); 174 175 struct x_cpu_info { 176 __u16 cpu_addr; 177 char reserved1[2]; 178 __u8 ctidx; 179 __u8 cflag; 180 __u16 weight; 181 __u64 acc_time; 182 __u64 lp_time; 183 __u16 min_weight; 184 __u16 cur_weight; 185 __u16 max_weight; 186 char reseved2[2]; 187 __u64 online_time; 188 __u64 wait_time; 189 __u32 pma_weight; 190 __u32 polar_weight; 191 char reserved3[40]; 192 } __attribute__ ((packed)); 193 194 /* CPU info block */ 195 196 static inline int cpu_info__size(enum diag204_format type) 197 { 198 if (type == INFO_SIMPLE) 199 return sizeof(struct cpu_info); 200 else /* INFO_EXT */ 201 return sizeof(struct x_cpu_info); 202 } 203 204 static inline __u8 cpu_info__ctidx(enum diag204_format type, void *hdr) 205 { 206 if (type == INFO_SIMPLE) 207 return ((struct cpu_info *)hdr)->ctidx; 208 else /* INFO_EXT */ 209 return ((struct x_cpu_info *)hdr)->ctidx; 210 } 211 212 static inline __u16 cpu_info__cpu_addr(enum diag204_format type, void *hdr) 213 { 214 if (type == INFO_SIMPLE) 215 return ((struct cpu_info *)hdr)->cpu_addr; 216 else /* INFO_EXT */ 217 return ((struct x_cpu_info *)hdr)->cpu_addr; 218 } 219 220 static inline __u64 cpu_info__acc_time(enum diag204_format type, void *hdr) 221 { 222 if (type == INFO_SIMPLE) 223 return ((struct cpu_info *)hdr)->acc_time; 224 else /* INFO_EXT */ 225 return ((struct x_cpu_info *)hdr)->acc_time; 226 } 227 228 static inline __u64 cpu_info__lp_time(enum diag204_format type, void *hdr) 229 { 230 if (type == INFO_SIMPLE) 231 return ((struct cpu_info *)hdr)->lp_time; 232 else /* INFO_EXT */ 233 return ((struct x_cpu_info *)hdr)->lp_time; 234 } 235 236 static inline __u64 cpu_info__online_time(enum diag204_format type, void *hdr) 237 { 238 if (type == INFO_SIMPLE) 239 return 0; /* online_time not available in simple info */ 240 else /* INFO_EXT */ 241 return ((struct x_cpu_info *)hdr)->online_time; 242 } 243 244 /* Physical header */ 245 246 struct phys_hdr { 247 char reserved1[1]; 248 __u8 cpus; 249 char reserved2[6]; 250 char mgm_name[8]; 251 } __attribute__ ((packed)); 252 253 struct x_phys_hdr { 254 char reserved1[1]; 255 __u8 cpus; 256 char reserved2[6]; 257 char mgm_name[8]; 258 char reserved3[80]; 259 } __attribute__ ((packed)); 260 261 static inline int phys_hdr__size(enum diag204_format type) 262 { 263 if (type == INFO_SIMPLE) 264 return sizeof(struct phys_hdr); 265 else /* INFO_EXT */ 266 return sizeof(struct x_phys_hdr); 267 } 268 269 static inline __u8 phys_hdr__cpus(enum diag204_format type, void *hdr) 270 { 271 if (type == INFO_SIMPLE) 272 return ((struct phys_hdr *)hdr)->cpus; 273 else /* INFO_EXT */ 274 return ((struct x_phys_hdr *)hdr)->cpus; 275 } 276 277 /* Physical CPU info block */ 278 279 struct phys_cpu { 280 __u16 cpu_addr; 281 char reserved1[2]; 282 __u8 ctidx; 283 char reserved2[3]; 284 __u64 mgm_time; 285 char reserved3[8]; 286 } __attribute__ ((packed)); 287 288 struct x_phys_cpu { 289 __u16 cpu_addr; 290 char reserved1[2]; 291 __u8 ctidx; 292 char reserved2[3]; 293 __u64 mgm_time; 294 char reserved3[80]; 295 } __attribute__ ((packed)); 296 297 static inline int phys_cpu__size(enum diag204_format type) 298 { 299 if (type == INFO_SIMPLE) 300 return sizeof(struct phys_cpu); 301 else /* INFO_EXT */ 302 return sizeof(struct x_phys_cpu); 303 } 304 305 static inline __u16 phys_cpu__cpu_addr(enum diag204_format type, void *hdr) 306 { 307 if (type == INFO_SIMPLE) 308 return ((struct phys_cpu *)hdr)->cpu_addr; 309 else /* INFO_EXT */ 310 return ((struct x_phys_cpu *)hdr)->cpu_addr; 311 } 312 313 static inline __u64 phys_cpu__mgm_time(enum diag204_format type, void *hdr) 314 { 315 if (type == INFO_SIMPLE) 316 return ((struct phys_cpu *)hdr)->mgm_time; 317 else /* INFO_EXT */ 318 return ((struct x_phys_cpu *)hdr)->mgm_time; 319 } 320 321 static inline __u64 phys_cpu__ctidx(enum diag204_format type, void *hdr) 322 { 323 if (type == INFO_SIMPLE) 324 return ((struct phys_cpu *)hdr)->ctidx; 325 else /* INFO_EXT */ 326 return ((struct x_phys_cpu *)hdr)->ctidx; 327 } 328 329 /* Diagnose 204 functions */ 330 331 static int diag204(unsigned long subcode, unsigned long size, void *addr) 332 { 333 register unsigned long _subcode asm("0") = subcode; 334 register unsigned long _size asm("1") = size; 335 336 asm volatile( 337 " diag %2,%0,0x204\n" 338 "0:\n" 339 EX_TABLE(0b,0b) 340 : "+d" (_subcode), "+d" (_size) : "d" (addr) : "memory"); 341 if (_subcode) 342 return -1; 343 return _size; 344 } 345 346 /* 347 * For the old diag subcode 4 with simple data format we have to use real 348 * memory. If we use subcode 6 or 7 with extended data format, we can (and 349 * should) use vmalloc, since we need a lot of memory in that case. Currently 350 * up to 93 pages! 351 */ 352 353 static void diag204_free_buffer(void) 354 { 355 if (!diag204_buf) 356 return; 357 if (diag204_buf_vmalloc) { 358 vfree(diag204_buf_vmalloc); 359 diag204_buf_vmalloc = NULL; 360 } else { 361 free_pages((unsigned long) diag204_buf, 0); 362 } 363 diag204_buf_pages = 0; 364 diag204_buf = NULL; 365 } 366 367 static void *diag204_alloc_vbuf(int pages) 368 { 369 /* The buffer has to be page aligned! */ 370 diag204_buf_vmalloc = vmalloc(PAGE_SIZE * (pages + 1)); 371 if (!diag204_buf_vmalloc) 372 return ERR_PTR(-ENOMEM); 373 diag204_buf = (void*)((unsigned long)diag204_buf_vmalloc 374 & ~0xfffUL) + 0x1000; 375 diag204_buf_pages = pages; 376 return diag204_buf; 377 } 378 379 static void *diag204_alloc_rbuf(void) 380 { 381 diag204_buf = (void*)__get_free_pages(GFP_KERNEL,0); 382 if (!diag204_buf) 383 return ERR_PTR(-ENOMEM); 384 diag204_buf_pages = 1; 385 return diag204_buf; 386 } 387 388 static void *diag204_get_buffer(enum diag204_format fmt, int *pages) 389 { 390 if (diag204_buf) { 391 *pages = diag204_buf_pages; 392 return diag204_buf; 393 } 394 if (fmt == INFO_SIMPLE) { 395 *pages = 1; 396 return diag204_alloc_rbuf(); 397 } else {/* INFO_EXT */ 398 *pages = diag204((unsigned long)SUBC_RSI | 399 (unsigned long)INFO_EXT, 0, NULL); 400 if (*pages <= 0) 401 return ERR_PTR(-ENOSYS); 402 else 403 return diag204_alloc_vbuf(*pages); 404 } 405 } 406 407 /* 408 * diag204_probe() has to find out, which type of diagnose 204 implementation 409 * we have on our machine. Currently there are three possible scanarios: 410 * - subcode 4 + simple data format (only one page) 411 * - subcode 4-6 + extended data format 412 * - subcode 4-7 + extended data format 413 * 414 * Subcode 5 is used to retrieve the size of the data, provided by subcodes 415 * 6 and 7. Subcode 7 basically has the same function as subcode 6. In addition 416 * to subcode 6 it provides also information about secondary cpus. 417 * In order to get as much information as possible, we first try 418 * subcode 7, then 6 and if both fail, we use subcode 4. 419 */ 420 421 static int diag204_probe(void) 422 { 423 void *buf; 424 int pages, rc; 425 426 buf = diag204_get_buffer(INFO_EXT, &pages); 427 if (!IS_ERR(buf)) { 428 if (diag204((unsigned long)SUBC_STIB7 | 429 (unsigned long)INFO_EXT, pages, buf) >= 0) { 430 diag204_store_sc = SUBC_STIB7; 431 diag204_info_type = INFO_EXT; 432 goto out; 433 } 434 if (diag204((unsigned long)SUBC_STIB6 | 435 (unsigned long)INFO_EXT, pages, buf) >= 0) { 436 diag204_store_sc = SUBC_STIB7; 437 diag204_info_type = INFO_EXT; 438 goto out; 439 } 440 diag204_free_buffer(); 441 } 442 443 /* subcodes 6 and 7 failed, now try subcode 4 */ 444 445 buf = diag204_get_buffer(INFO_SIMPLE, &pages); 446 if (IS_ERR(buf)) { 447 rc = PTR_ERR(buf); 448 goto fail_alloc; 449 } 450 if (diag204((unsigned long)SUBC_STIB4 | 451 (unsigned long)INFO_SIMPLE, pages, buf) >= 0) { 452 diag204_store_sc = SUBC_STIB4; 453 diag204_info_type = INFO_SIMPLE; 454 goto out; 455 } else { 456 rc = -ENOSYS; 457 goto fail_store; 458 } 459 out: 460 rc = 0; 461 fail_store: 462 diag204_free_buffer(); 463 fail_alloc: 464 return rc; 465 } 466 467 static void *diag204_store(void) 468 { 469 void *buf; 470 int pages; 471 472 buf = diag204_get_buffer(diag204_info_type, &pages); 473 if (IS_ERR(buf)) 474 goto out; 475 if (diag204((unsigned long)diag204_store_sc | 476 (unsigned long)diag204_info_type, pages, buf) < 0) 477 return ERR_PTR(-ENOSYS); 478 out: 479 return buf; 480 } 481 482 /* Diagnose 224 functions */ 483 484 static void diag224(void *ptr) 485 { 486 asm volatile("diag %0,%1,0x224" : :"d" (0), "d"(ptr) : "memory"); 487 } 488 489 static int diag224_get_name_table(void) 490 { 491 /* memory must be below 2GB */ 492 diag224_cpu_names = kmalloc(PAGE_SIZE, GFP_KERNEL | GFP_DMA); 493 if (!diag224_cpu_names) 494 return -ENOMEM; 495 diag224(diag224_cpu_names); 496 EBCASC(diag224_cpu_names + 16, (*diag224_cpu_names + 1) * 16); 497 return 0; 498 } 499 500 static void diag224_delete_name_table(void) 501 { 502 kfree(diag224_cpu_names); 503 } 504 505 static int diag224_idx2name(int index, char *name) 506 { 507 memcpy(name, diag224_cpu_names + ((index + 1) * CPU_NAME_LEN), 508 CPU_NAME_LEN); 509 name[CPU_NAME_LEN] = 0; 510 strstrip(name); 511 return 0; 512 } 513 514 __init int hypfs_diag_init(void) 515 { 516 int rc; 517 518 if (diag204_probe()) { 519 printk(KERN_ERR "hypfs: diag 204 not working."); 520 return -ENODATA; 521 } 522 rc = diag224_get_name_table(); 523 if (rc) { 524 diag204_free_buffer(); 525 printk(KERN_ERR "hypfs: could not get name table.\n"); 526 } 527 return rc; 528 } 529 530 void hypfs_diag_exit(void) 531 { 532 diag224_delete_name_table(); 533 diag204_free_buffer(); 534 } 535 536 /* 537 * Functions to create the directory structure 538 * ******************************************* 539 */ 540 541 static int hypfs_create_cpu_files(struct super_block *sb, 542 struct dentry *cpus_dir, void *cpu_info) 543 { 544 struct dentry *cpu_dir; 545 char buffer[TMP_SIZE]; 546 void *rc; 547 548 snprintf(buffer, TMP_SIZE, "%d", cpu_info__cpu_addr(diag204_info_type, 549 cpu_info)); 550 cpu_dir = hypfs_mkdir(sb, cpus_dir, buffer); 551 rc = hypfs_create_u64(sb, cpu_dir, "mgmtime", 552 cpu_info__acc_time(diag204_info_type, cpu_info) - 553 cpu_info__lp_time(diag204_info_type, cpu_info)); 554 if (IS_ERR(rc)) 555 return PTR_ERR(rc); 556 rc = hypfs_create_u64(sb, cpu_dir, "cputime", 557 cpu_info__lp_time(diag204_info_type, cpu_info)); 558 if (IS_ERR(rc)) 559 return PTR_ERR(rc); 560 if (diag204_info_type == INFO_EXT) { 561 rc = hypfs_create_u64(sb, cpu_dir, "onlinetime", 562 cpu_info__online_time(diag204_info_type, 563 cpu_info)); 564 if (IS_ERR(rc)) 565 return PTR_ERR(rc); 566 } 567 diag224_idx2name(cpu_info__ctidx(diag204_info_type, cpu_info), buffer); 568 rc = hypfs_create_str(sb, cpu_dir, "type", buffer); 569 if (IS_ERR(rc)) 570 return PTR_ERR(rc); 571 return 0; 572 } 573 574 static void *hypfs_create_lpar_files(struct super_block *sb, 575 struct dentry *systems_dir, void *part_hdr) 576 { 577 struct dentry *cpus_dir; 578 struct dentry *lpar_dir; 579 char lpar_name[LPAR_NAME_LEN + 1]; 580 void *cpu_info; 581 int i; 582 583 part_hdr__part_name(diag204_info_type, part_hdr, lpar_name); 584 lpar_name[LPAR_NAME_LEN] = 0; 585 lpar_dir = hypfs_mkdir(sb, systems_dir, lpar_name); 586 if (IS_ERR(lpar_dir)) 587 return lpar_dir; 588 cpus_dir = hypfs_mkdir(sb, lpar_dir, "cpus"); 589 if (IS_ERR(cpus_dir)) 590 return cpus_dir; 591 cpu_info = part_hdr + part_hdr__size(diag204_info_type); 592 for (i = 0; i < part_hdr__rcpus(diag204_info_type, part_hdr); i++) { 593 int rc; 594 rc = hypfs_create_cpu_files(sb, cpus_dir, cpu_info); 595 if (rc) 596 return ERR_PTR(rc); 597 cpu_info += cpu_info__size(diag204_info_type); 598 } 599 return cpu_info; 600 } 601 602 static int hypfs_create_phys_cpu_files(struct super_block *sb, 603 struct dentry *cpus_dir, void *cpu_info) 604 { 605 struct dentry *cpu_dir; 606 char buffer[TMP_SIZE]; 607 void *rc; 608 609 snprintf(buffer, TMP_SIZE, "%i", phys_cpu__cpu_addr(diag204_info_type, 610 cpu_info)); 611 cpu_dir = hypfs_mkdir(sb, cpus_dir, buffer); 612 if (IS_ERR(cpu_dir)) 613 return PTR_ERR(cpu_dir); 614 rc = hypfs_create_u64(sb, cpu_dir, "mgmtime", 615 phys_cpu__mgm_time(diag204_info_type, cpu_info)); 616 if (IS_ERR(rc)) 617 return PTR_ERR(rc); 618 diag224_idx2name(phys_cpu__ctidx(diag204_info_type, cpu_info), buffer); 619 rc = hypfs_create_str(sb, cpu_dir, "type", buffer); 620 if (IS_ERR(rc)) 621 return PTR_ERR(rc); 622 return 0; 623 } 624 625 static void *hypfs_create_phys_files(struct super_block *sb, 626 struct dentry *parent_dir, void *phys_hdr) 627 { 628 int i; 629 void *cpu_info; 630 struct dentry *cpus_dir; 631 632 cpus_dir = hypfs_mkdir(sb, parent_dir, "cpus"); 633 if (IS_ERR(cpus_dir)) 634 return cpus_dir; 635 cpu_info = phys_hdr + phys_hdr__size(diag204_info_type); 636 for (i = 0; i < phys_hdr__cpus(diag204_info_type, phys_hdr); i++) { 637 int rc; 638 rc = hypfs_create_phys_cpu_files(sb, cpus_dir, cpu_info); 639 if (rc) 640 return ERR_PTR(rc); 641 cpu_info += phys_cpu__size(diag204_info_type); 642 } 643 return cpu_info; 644 } 645 646 int hypfs_diag_create_files(struct super_block *sb, struct dentry *root) 647 { 648 struct dentry *systems_dir, *hyp_dir; 649 void *time_hdr, *part_hdr; 650 int i, rc; 651 void *buffer, *ptr; 652 653 buffer = diag204_store(); 654 if (IS_ERR(buffer)) 655 return PTR_ERR(buffer); 656 657 systems_dir = hypfs_mkdir(sb, root, "systems"); 658 if (IS_ERR(systems_dir)) { 659 rc = PTR_ERR(systems_dir); 660 goto err_out; 661 } 662 time_hdr = (struct x_info_blk_hdr *)buffer; 663 part_hdr = time_hdr + info_blk_hdr__size(diag204_info_type); 664 for (i = 0; i < info_blk_hdr__npar(diag204_info_type, time_hdr); i++) { 665 part_hdr = hypfs_create_lpar_files(sb, systems_dir, part_hdr); 666 if (IS_ERR(part_hdr)) { 667 rc = PTR_ERR(part_hdr); 668 goto err_out; 669 } 670 } 671 if (info_blk_hdr__flags(diag204_info_type, time_hdr) & LPAR_PHYS_FLG) { 672 ptr = hypfs_create_phys_files(sb, root, part_hdr); 673 if (IS_ERR(ptr)) { 674 rc = PTR_ERR(ptr); 675 goto err_out; 676 } 677 } 678 hyp_dir = hypfs_mkdir(sb, root, "hyp"); 679 if (IS_ERR(hyp_dir)) { 680 rc = PTR_ERR(hyp_dir); 681 goto err_out; 682 } 683 ptr = hypfs_create_str(sb, hyp_dir, "type", "LPAR Hypervisor"); 684 if (IS_ERR(ptr)) { 685 rc = PTR_ERR(ptr); 686 goto err_out; 687 } 688 rc = 0; 689 690 err_out: 691 return rc; 692 } 693