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(
 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                 diag224_delete_name_table();
 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 }