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