arch/s390/hypfs/hypfs_diag.c

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