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 (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 ("   diag    %2,%0,0x204\n"
 337                       "0: \n" ".section __ex_table,\"a\"\n"
 338 #ifndef __s390x__
 339                       "    .align 4\n"
 340                       "    .long  0b,0b\n"
 341 #else
 342                       "    .align 8\n"
 343                       "    .quad  0b,0b\n"
 344 #endif
 345                       ".previous":"+d" (_subcode), "+d"(_size)
 346                       :"d"(addr)
 347                       :"memory");
 348         if (_subcode)
 349                 return -1;
 350         else
 351                 return _size;
 352 }
 353
 354 /*
 355  * For the old diag subcode 4 with simple data format we have to use real
 356  * memory. If we use subcode 6 or 7 with extended data format, we can (and
 357  * should) use vmalloc, since we need a lot of memory in that case. Currently
 358  * up to 93 pages!
 359  */
 360
 361 static void diag204_free_buffer(void)
 362 {
 363         if (!diag204_buf)
 364                 return;
 365         if (diag204_buf_vmalloc) {
 366                 vfree(diag204_buf_vmalloc);
 367                 diag204_buf_vmalloc = NULL;
 368         } else {
 369                 free_pages((unsigned long) diag204_buf, 0);
 370         }
 371         diag204_buf_pages = 0;
 372         diag204_buf = NULL;
 373 }
 374
 375 static void *diag204_alloc_vbuf(int pages)
 376 {
 377         /* The buffer has to be page aligned! */
 378         diag204_buf_vmalloc = vmalloc(PAGE_SIZE * (pages + 1));
 379         if (!diag204_buf_vmalloc)
 380                 return ERR_PTR(-ENOMEM);
 381         diag204_buf = (void*)((unsigned long)diag204_buf_vmalloc
 382                                 & ~0xfffUL) + 0x1000;
 383         diag204_buf_pages = pages;
 384         return diag204_buf;
 385 }
 386
 387 static void *diag204_alloc_rbuf(void)
 388 {
 389         diag204_buf = (void*)__get_free_pages(GFP_KERNEL,0);
 390         if (diag204_buf)
 391                 return ERR_PTR(-ENOMEM);
 392         diag204_buf_pages = 1;
 393         return diag204_buf;
 394 }
 395
 396 static void *diag204_get_buffer(enum diag204_format fmt, int *pages)
 397 {
 398         if (diag204_buf) {
 399                 *pages = diag204_buf_pages;
 400                 return diag204_buf;
 401         }
 402         if (fmt == INFO_SIMPLE) {
 403                 *pages = 1;
 404                 return diag204_alloc_rbuf();
 405         } else {/* INFO_EXT */
 406                 *pages = diag204(SUBC_RSI | INFO_EXT, 0, NULL);
 407                 if (*pages <= 0)
 408                         return ERR_PTR(-ENOSYS);
 409                 else
 410                         return diag204_alloc_vbuf(*pages);
 411         }
 412 }
 413
 414 /*
 415  * diag204_probe() has to find out, which type of diagnose 204 implementation
 416  * we have on our machine. Currently there are three possible scanarios:
 417  *   - subcode 4   + simple data format (only one page)
 418  *   - subcode 4-6 + extended data format
 419  *   - subcode 4-7 + extended data format
 420  *
 421  * Subcode 5 is used to retrieve the size of the data, provided by subcodes
 422  * 6 and 7. Subcode 7 basically has the same function as subcode 6. In addition
 423  * to subcode 6 it provides also information about secondary cpus.
 424  * In order to get as much information as possible, we first try
 425  * subcode 7, then 6 and if both fail, we use subcode 4.
 426  */
 427
 428 static int diag204_probe(void)
 429 {
 430         void *buf;
 431         int pages, rc;
 432
 433         buf = diag204_get_buffer(INFO_EXT, &pages);
 434         if (!IS_ERR(buf)) {
 435                 if (diag204(SUBC_STIB7 | INFO_EXT, pages, buf) >= 0) {
 436                         diag204_store_sc = SUBC_STIB7;
 437                         diag204_info_type = INFO_EXT;
 438                         goto out;
 439                 }
 440                 if (diag204(SUBC_STIB6 | INFO_EXT, pages, buf) >= 0) {
 441                         diag204_store_sc = SUBC_STIB7;
 442                         diag204_info_type = INFO_EXT;
 443                         goto out;
 444                 }
 445                 diag204_free_buffer();
 446         }
 447
 448         /* subcodes 6 and 7 failed, now try subcode 4 */
 449
 450         buf = diag204_get_buffer(INFO_SIMPLE, &pages);
 451         if (IS_ERR(buf)) {
 452                 rc = PTR_ERR(buf);
 453                 goto fail_alloc;
 454         }
 455         if (diag204(SUBC_STIB4 | INFO_SIMPLE, pages, buf) >= 0) {
 456                 diag204_store_sc = SUBC_STIB4;
 457                 diag204_info_type = INFO_SIMPLE;
 458                 goto out;
 459         } else {
 460                 rc = -ENOSYS;
 461                 goto fail_store;
 462         }
 463 out:
 464         rc = 0;
 465 fail_store:
 466         diag204_free_buffer();
 467 fail_alloc:
 468         return rc;
 469 }
 470
 471 static void *diag204_store(void)
 472 {
 473         void *buf;
 474         int pages;
 475
 476         buf = diag204_get_buffer(diag204_info_type, &pages);
 477         if (IS_ERR(buf))
 478                 goto out;
 479         if (diag204(diag204_store_sc | diag204_info_type, pages, buf) < 0)
 480                 return ERR_PTR(-ENOSYS);
 481 out:
 482         return buf;
 483 }
 484
 485 /* Diagnose 224 functions */
 486
 487 static void diag224(void *ptr)
 488 {
 489         asm volatile("   diag    %0,%1,0x224\n"
 490                      : :"d" (0), "d"(ptr) : "memory");
 491 }
 492
 493 static int diag224_get_name_table(void)
 494 {
 495         /* memory must be below 2GB */
 496         diag224_cpu_names = kmalloc(PAGE_SIZE, GFP_KERNEL | GFP_DMA);
 497         if (!diag224_cpu_names)
 498                 return -ENOMEM;
 499         diag224(diag224_cpu_names);
 500         EBCASC(diag224_cpu_names + 16, (*diag224_cpu_names + 1) * 16);
 501         return 0;
 502 }
 503
 504 static void diag224_delete_name_table(void)
 505 {
 506         kfree(diag224_cpu_names);
 507 }
 508
 509 static int diag224_idx2name(int index, char *name)
 510 {
 511         memcpy(name, diag224_cpu_names + ((index + 1) * CPU_NAME_LEN),
 512                 CPU_NAME_LEN);
 513         name[CPU_NAME_LEN] = 0;
 514         strstrip(name);
 515         return 0;
 516 }
 517
 518 __init int hypfs_diag_init(void)
 519 {
 520         int rc;
 521
 522         if (diag204_probe()) {
 523                 printk(KERN_ERR "hypfs: diag 204 not working.");
 524                 return -ENODATA;
 525         }
 526         rc = diag224_get_name_table();
 527         if (rc) {
 528                 diag224_delete_name_table();
 529                 printk(KERN_ERR "hypfs: could not get name table.\n");
 530         }
 531         return rc;
 532 }
 533
 534 __exit void hypfs_diag_exit(void)
 535 {
 536         diag224_delete_name_table();
 537         diag204_free_buffer();
 538 }
 539
 540 /*
 541  * Functions to create the directory structure
 542  * *******************************************
 543  */
 544
 545 static int hypfs_create_cpu_files(struct super_block *sb,
 546                                   struct dentry *cpus_dir, void *cpu_info)
 547 {
 548         struct dentry *cpu_dir;
 549         char buffer[TMP_SIZE];
 550         void *rc;
 551
 552         snprintf(buffer, TMP_SIZE, "%d", cpu_info__cpu_addr(diag204_info_type,
 553                                                             cpu_info));
 554         cpu_dir = hypfs_mkdir(sb, cpus_dir, buffer);
 555         rc = hypfs_create_u64(sb, cpu_dir, "mgmtime",
 556                               cpu_info__acc_time(diag204_info_type, cpu_info) -
 557                               cpu_info__lp_time(diag204_info_type, cpu_info));
 558         if (IS_ERR(rc))
 559                 return PTR_ERR(rc);
 560         rc = hypfs_create_u64(sb, cpu_dir, "cputime",
 561                               cpu_info__lp_time(diag204_info_type, cpu_info));
 562         if (IS_ERR(rc))
 563                 return PTR_ERR(rc);
 564         if (diag204_info_type == INFO_EXT) {
 565                 rc = hypfs_create_u64(sb, cpu_dir, "onlinetime",
 566                                       cpu_info__online_time(diag204_info_type,
 567                                                             cpu_info));
 568                 if (IS_ERR(rc))
 569                         return PTR_ERR(rc);
 570         }
 571         diag224_idx2name(cpu_info__ctidx(diag204_info_type, cpu_info), buffer);
 572         rc = hypfs_create_str(sb, cpu_dir, "type", buffer);
 573         if (IS_ERR(rc))
 574                 return PTR_ERR(rc);
 575         return 0;
 576 }
 577
 578 static void *hypfs_create_lpar_files(struct super_block *sb,
 579                                      struct dentry *systems_dir, void *part_hdr)
 580 {
 581         struct dentry *cpus_dir;
 582         struct dentry *lpar_dir;
 583         char lpar_name[LPAR_NAME_LEN + 1];
 584         void *cpu_info;
 585         int i;
 586
 587         part_hdr__part_name(diag204_info_type, part_hdr, lpar_name);
 588         lpar_name[LPAR_NAME_LEN] = 0;
 589         lpar_dir = hypfs_mkdir(sb, systems_dir, lpar_name);
 590         if (IS_ERR(lpar_dir))
 591                 return lpar_dir;
 592         cpus_dir = hypfs_mkdir(sb, lpar_dir, "cpus");
 593         if (IS_ERR(cpus_dir))
 594                 return cpus_dir;
 595         cpu_info = part_hdr + part_hdr__size(diag204_info_type);
 596         for (i = 0; i < part_hdr__rcpus(diag204_info_type, part_hdr); i++) {
 597                 int rc;
 598                 rc = hypfs_create_cpu_files(sb, cpus_dir, cpu_info);
 599                 if (rc)
 600                         return ERR_PTR(rc);
 601                 cpu_info += cpu_info__size(diag204_info_type);
 602         }
 603         return cpu_info;
 604 }
 605
 606 static int hypfs_create_phys_cpu_files(struct super_block *sb,
 607                                        struct dentry *cpus_dir, void *cpu_info)
 608 {
 609         struct dentry *cpu_dir;
 610         char buffer[TMP_SIZE];
 611         void *rc;
 612
 613         snprintf(buffer, TMP_SIZE, "%i", phys_cpu__cpu_addr(diag204_info_type,
 614                                                             cpu_info));
 615         cpu_dir = hypfs_mkdir(sb, cpus_dir, buffer);
 616         if (IS_ERR(cpu_dir))
 617                 return PTR_ERR(cpu_dir);
 618         rc = hypfs_create_u64(sb, cpu_dir, "mgmtime",
 619                               phys_cpu__mgm_time(diag204_info_type, cpu_info));
 620         if (IS_ERR(rc))
 621                 return PTR_ERR(rc);
 622         diag224_idx2name(phys_cpu__ctidx(diag204_info_type, cpu_info), buffer);
 623         rc = hypfs_create_str(sb, cpu_dir, "type", buffer);
 624         if (IS_ERR(rc))
 625                 return PTR_ERR(rc);
 626         return 0;
 627 }
 628
 629 static void *hypfs_create_phys_files(struct super_block *sb,
 630                                      struct dentry *parent_dir, void *phys_hdr)
 631 {
 632         int i;
 633         void *cpu_info;
 634         struct dentry *cpus_dir;
 635
 636         cpus_dir = hypfs_mkdir(sb, parent_dir, "cpus");
 637         if (IS_ERR(cpus_dir))
 638                 return cpus_dir;
 639         cpu_info = phys_hdr + phys_hdr__size(diag204_info_type);
 640         for (i = 0; i < phys_hdr__cpus(diag204_info_type, phys_hdr); i++) {
 641                 int rc;
 642                 rc = hypfs_create_phys_cpu_files(sb, cpus_dir, cpu_info);
 643                 if (rc)
 644                         return ERR_PTR(rc);
 645                 cpu_info += phys_cpu__size(diag204_info_type);
 646         }
 647         return cpu_info;
 648 }
 649
 650 int hypfs_diag_create_files(struct super_block *sb, struct dentry *root)
 651 {
 652         struct dentry *systems_dir, *hyp_dir;
 653         void *time_hdr, *part_hdr;
 654         int i, rc;
 655         void *buffer, *ptr;
 656
 657         buffer = diag204_store();
 658         if (IS_ERR(buffer))
 659                 return PTR_ERR(buffer);
 660
 661         systems_dir = hypfs_mkdir(sb, root, "systems");
 662         if (IS_ERR(systems_dir)) {
 663                 rc = PTR_ERR(systems_dir);
 664                 goto err_out;
 665         }
 666         time_hdr = (struct x_info_blk_hdr *)buffer;
 667         part_hdr = time_hdr + info_blk_hdr__size(diag204_info_type);
 668         for (i = 0; i < info_blk_hdr__npar(diag204_info_type, time_hdr); i++) {
 669                 part_hdr = hypfs_create_lpar_files(sb, systems_dir, part_hdr);
 670                 if (IS_ERR(part_hdr)) {
 671                         rc = PTR_ERR(part_hdr);
 672                         goto err_out;
 673                 }
 674         }
 675         if (info_blk_hdr__flags(diag204_info_type, time_hdr) & LPAR_PHYS_FLG) {
 676                 ptr = hypfs_create_phys_files(sb, root, part_hdr);
 677                 if (IS_ERR(ptr)) {
 678                         rc = PTR_ERR(ptr);
 679                         goto err_out;
 680                 }
 681         }
 682         hyp_dir = hypfs_mkdir(sb, root, "hyp");
 683         if (IS_ERR(hyp_dir)) {
 684                 rc = PTR_ERR(hyp_dir);
 685                 goto err_out;
 686         }
 687         ptr = hypfs_create_str(sb, hyp_dir, "type", "LPAR Hypervisor");
 688         if (IS_ERR(ptr)) {
 689                 rc = PTR_ERR(ptr);
 690                 goto err_out;
 691         }
 692         rc = 0;
 693
 694 err_out:
 695         return rc;
 696 }