URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [arch/] [s390/] [hypfs/] [hypfs_diag.c] - Blame information for rev 63

Details | Compare with Previous | View Log


/*
 *  arch/s390/hypfs/hypfs_diag.c
 *    Hypervisor filesystem for Linux on s390. Diag 204 and 224
 *    implementation.
 *
 *    Copyright (C) IBM Corp. 2006
 *    Author(s): Michael Holzheu <holzheu@de.ibm.com>
 */
 
#include <linux/types.h>
#include <linux/errno.h>
#include <linux/string.h>
#include <linux/vmalloc.h>
#include <asm/ebcdic.h>
#include "hypfs.h"
 
#define LPAR_NAME_LEN 8         /* lpar name len in diag 204 data */
#define CPU_NAME_LEN 16         /* type name len of cpus in diag224 name table */
#define TMP_SIZE 64             /* size of temporary buffers */
 
/* diag 204 subcodes */
enum diag204_sc {
        SUBC_STIB4 = 4,
        SUBC_RSI = 5,
        SUBC_STIB6 = 6,
        SUBC_STIB7 = 7
};
 
/* The two available diag 204 data formats */
enum diag204_format {
        INFO_SIMPLE = 0,
        INFO_EXT = 0x00010000
};
 
/* bit is set in flags, when physical cpu info is included in diag 204 data */
#define LPAR_PHYS_FLG  0x80
 
static char *diag224_cpu_names;                 /* diag 224 name table */
static enum diag204_sc diag204_store_sc;        /* used subcode for store */
static enum diag204_format diag204_info_type;   /* used diag 204 data format */
 
static void *diag204_buf;               /* 4K aligned buffer for diag204 data */
static void *diag204_buf_vmalloc;       /* vmalloc pointer for diag204 data */
static int diag204_buf_pages;           /* number of pages for diag204 data */
 
/*
 * DIAG 204 data structures and member access functions.
 *
 * Since we have two different diag 204 data formats for old and new s390
 * machines, we do not access the structs directly, but use getter functions for
 * each struct member instead. This should make the code more readable.
 */
 
/* Time information block */
 
struct info_blk_hdr {
        __u8  npar;
        __u8  flags;
        __u16 tslice;
        __u16 phys_cpus;
        __u16 this_part;
        __u64 curtod;
} __attribute__ ((packed));
 
struct x_info_blk_hdr {
        __u8  npar;
        __u8  flags;
        __u16 tslice;
        __u16 phys_cpus;
        __u16 this_part;
        __u64 curtod1;
        __u64 curtod2;
        char reserved[40];
} __attribute__ ((packed));
 
static inline int info_blk_hdr__size(enum diag204_format type)
{
        if (type == INFO_SIMPLE)
                return sizeof(struct info_blk_hdr);
        else /* INFO_EXT */
                return sizeof(struct x_info_blk_hdr);
}
 
static inline __u8 info_blk_hdr__npar(enum diag204_format type, void *hdr)
{
        if (type == INFO_SIMPLE)
                return ((struct info_blk_hdr *)hdr)->npar;
        else /* INFO_EXT */
                return ((struct x_info_blk_hdr *)hdr)->npar;
}
 
static inline __u8 info_blk_hdr__flags(enum diag204_format type, void *hdr)
{
        if (type == INFO_SIMPLE)
                return ((struct info_blk_hdr *)hdr)->flags;
        else /* INFO_EXT */
                return ((struct x_info_blk_hdr *)hdr)->flags;
}
 
static inline __u16 info_blk_hdr__pcpus(enum diag204_format type, void *hdr)
{
        if (type == INFO_SIMPLE)
                return ((struct info_blk_hdr *)hdr)->phys_cpus;
        else /* INFO_EXT */
                return ((struct x_info_blk_hdr *)hdr)->phys_cpus;
}
 
/* Partition header */
 
struct part_hdr {
        __u8 pn;
        __u8 cpus;
        char reserved[6];
        char part_name[LPAR_NAME_LEN];
} __attribute__ ((packed));
 
struct x_part_hdr {
        __u8  pn;
        __u8  cpus;
        __u8  rcpus;
        __u8  pflag;
        __u32 mlu;
        char  part_name[LPAR_NAME_LEN];
        char  lpc_name[8];
        char  os_name[8];
        __u64 online_cs;
        __u64 online_es;
        __u8  upid;
        char  reserved1[3];
        __u32 group_mlu;
        char  group_name[8];
        char  reserved2[32];
} __attribute__ ((packed));
 
static inline int part_hdr__size(enum diag204_format type)
{
        if (type == INFO_SIMPLE)
                return sizeof(struct part_hdr);
        else /* INFO_EXT */
                return sizeof(struct x_part_hdr);
}
 
static inline __u8 part_hdr__rcpus(enum diag204_format type, void *hdr)
{
        if (type == INFO_SIMPLE)
                return ((struct part_hdr *)hdr)->cpus;
        else /* INFO_EXT */
                return ((struct x_part_hdr *)hdr)->rcpus;
}
 
static inline void part_hdr__part_name(enum diag204_format type, void *hdr,
                                       char *name)
{
        if (type == INFO_SIMPLE)
                memcpy(name, ((struct part_hdr *)hdr)->part_name,
                       LPAR_NAME_LEN);
        else /* INFO_EXT */
                memcpy(name, ((struct x_part_hdr *)hdr)->part_name,
                       LPAR_NAME_LEN);
        EBCASC(name, LPAR_NAME_LEN);
        name[LPAR_NAME_LEN] = 0;
        strstrip(name);
}
 
struct cpu_info {
        __u16 cpu_addr;
        char  reserved1[2];
        __u8  ctidx;
        __u8  cflag;
        __u16 weight;
        __u64 acc_time;
        __u64 lp_time;
} __attribute__ ((packed));
 
struct x_cpu_info {
        __u16 cpu_addr;
        char  reserved1[2];
        __u8  ctidx;
        __u8  cflag;
        __u16 weight;
        __u64 acc_time;
        __u64 lp_time;
        __u16 min_weight;
        __u16 cur_weight;
        __u16 max_weight;
        char  reseved2[2];
        __u64 online_time;
        __u64 wait_time;
        __u32 pma_weight;
        __u32 polar_weight;
        char  reserved3[40];
} __attribute__ ((packed));
 
/* CPU info block */
 
static inline int cpu_info__size(enum diag204_format type)
{
        if (type == INFO_SIMPLE)
                return sizeof(struct cpu_info);
        else /* INFO_EXT */
                return sizeof(struct x_cpu_info);
}
 
static inline __u8 cpu_info__ctidx(enum diag204_format type, void *hdr)
{
        if (type == INFO_SIMPLE)
                return ((struct cpu_info *)hdr)->ctidx;
        else /* INFO_EXT */
                return ((struct x_cpu_info *)hdr)->ctidx;
}
 
static inline __u16 cpu_info__cpu_addr(enum diag204_format type, void *hdr)
{
        if (type == INFO_SIMPLE)
                return ((struct cpu_info *)hdr)->cpu_addr;
        else /* INFO_EXT */
                return ((struct x_cpu_info *)hdr)->cpu_addr;
}
 
static inline __u64 cpu_info__acc_time(enum diag204_format type, void *hdr)
{
        if (type == INFO_SIMPLE)
                return ((struct cpu_info *)hdr)->acc_time;
        else /* INFO_EXT */
                return ((struct x_cpu_info *)hdr)->acc_time;
}
 
static inline __u64 cpu_info__lp_time(enum diag204_format type, void *hdr)
{
        if (type == INFO_SIMPLE)
                return ((struct cpu_info *)hdr)->lp_time;
        else /* INFO_EXT */
                return ((struct x_cpu_info *)hdr)->lp_time;
}
 
static inline __u64 cpu_info__online_time(enum diag204_format type, void *hdr)
{
        if (type == INFO_SIMPLE)
                return 0;        /* online_time not available in simple info */
        else /* INFO_EXT */
                return ((struct x_cpu_info *)hdr)->online_time;
}
 
/* Physical header */
 
struct phys_hdr {
        char reserved1[1];
        __u8 cpus;
        char reserved2[6];
        char mgm_name[8];
} __attribute__ ((packed));
 
struct x_phys_hdr {
        char reserved1[1];
        __u8 cpus;
        char reserved2[6];
        char mgm_name[8];
        char reserved3[80];
} __attribute__ ((packed));
 
static inline int phys_hdr__size(enum diag204_format type)
{
        if (type == INFO_SIMPLE)
                return sizeof(struct phys_hdr);
        else /* INFO_EXT */
                return sizeof(struct x_phys_hdr);
}
 
static inline __u8 phys_hdr__cpus(enum diag204_format type, void *hdr)
{
        if (type == INFO_SIMPLE)
                return ((struct phys_hdr *)hdr)->cpus;
        else /* INFO_EXT */
                return ((struct x_phys_hdr *)hdr)->cpus;
}
 
/* Physical CPU info block */
 
struct phys_cpu {
        __u16 cpu_addr;
        char  reserved1[2];
        __u8  ctidx;
        char  reserved2[3];
        __u64 mgm_time;
        char  reserved3[8];
} __attribute__ ((packed));
 
struct x_phys_cpu {
        __u16 cpu_addr;
        char  reserved1[2];
        __u8  ctidx;
        char  reserved2[3];
        __u64 mgm_time;
        char  reserved3[80];
} __attribute__ ((packed));
 
static inline int phys_cpu__size(enum diag204_format type)
{
        if (type == INFO_SIMPLE)
                return sizeof(struct phys_cpu);
        else /* INFO_EXT */
                return sizeof(struct x_phys_cpu);
}
 
static inline __u16 phys_cpu__cpu_addr(enum diag204_format type, void *hdr)
{
        if (type == INFO_SIMPLE)
                return ((struct phys_cpu *)hdr)->cpu_addr;
        else /* INFO_EXT */
                return ((struct x_phys_cpu *)hdr)->cpu_addr;
}
 
static inline __u64 phys_cpu__mgm_time(enum diag204_format type, void *hdr)
{
        if (type == INFO_SIMPLE)
                return ((struct phys_cpu *)hdr)->mgm_time;
        else /* INFO_EXT */
                return ((struct x_phys_cpu *)hdr)->mgm_time;
}
 
static inline __u64 phys_cpu__ctidx(enum diag204_format type, void *hdr)
{
        if (type == INFO_SIMPLE)
                return ((struct phys_cpu *)hdr)->ctidx;
        else /* INFO_EXT */
                return ((struct x_phys_cpu *)hdr)->ctidx;
}
 
/* Diagnose 204 functions */
 
static int diag204(unsigned long subcode, unsigned long size, void *addr)
{
        register unsigned long _subcode asm("0") = subcode;
        register unsigned long _size asm("1") = size;
 
        asm volatile(
                "       diag    %2,%0,0x204\n"
                "0:\n"
                EX_TABLE(0b,0b)
                : "+d" (_subcode), "+d" (_size) : "d" (addr) : "memory");
        if (_subcode)
                return -1;
        return _size;
}
 
/*
 * For the old diag subcode 4 with simple data format we have to use real
 * memory. If we use subcode 6 or 7 with extended data format, we can (and
 * should) use vmalloc, since we need a lot of memory in that case. Currently
 * up to 93 pages!
 */
 
static void diag204_free_buffer(void)
{
        if (!diag204_buf)
                return;
        if (diag204_buf_vmalloc) {
                vfree(diag204_buf_vmalloc);
                diag204_buf_vmalloc = NULL;
        } else {
                free_pages((unsigned long) diag204_buf, 0);
        }
        diag204_buf_pages = 0;
        diag204_buf = NULL;
}
 
static void *diag204_alloc_vbuf(int pages)
{
        /* The buffer has to be page aligned! */
        diag204_buf_vmalloc = vmalloc(PAGE_SIZE * (pages + 1));
        if (!diag204_buf_vmalloc)
                return ERR_PTR(-ENOMEM);
        diag204_buf = (void*)((unsigned long)diag204_buf_vmalloc
                                & ~0xfffUL) + 0x1000;
        diag204_buf_pages = pages;
        return diag204_buf;
}
 
static void *diag204_alloc_rbuf(void)
{
        diag204_buf = (void*)__get_free_pages(GFP_KERNEL,0);
        if (!diag204_buf)
                return ERR_PTR(-ENOMEM);
        diag204_buf_pages = 1;
        return diag204_buf;
}
 
static void *diag204_get_buffer(enum diag204_format fmt, int *pages)
{
        if (diag204_buf) {
                *pages = diag204_buf_pages;
                return diag204_buf;
        }
        if (fmt == INFO_SIMPLE) {
                *pages = 1;
                return diag204_alloc_rbuf();
        } else {/* INFO_EXT */
                *pages = diag204((unsigned long)SUBC_RSI |
                                 (unsigned long)INFO_EXT, 0, NULL);
                if (*pages <= 0)
                        return ERR_PTR(-ENOSYS);
                else
                        return diag204_alloc_vbuf(*pages);
        }
}
 
/*
 * diag204_probe() has to find out, which type of diagnose 204 implementation
 * we have on our machine. Currently there are three possible scanarios:
 *   - subcode 4   + simple data format (only one page)
 *   - subcode 4-6 + extended data format
 *   - subcode 4-7 + extended data format
 *
 * Subcode 5 is used to retrieve the size of the data, provided by subcodes
 * 6 and 7. Subcode 7 basically has the same function as subcode 6. In addition
 * to subcode 6 it provides also information about secondary cpus.
 * In order to get as much information as possible, we first try
 * subcode 7, then 6 and if both fail, we use subcode 4.
 */
 
static int diag204_probe(void)
{
        void *buf;
        int pages, rc;
 
        buf = diag204_get_buffer(INFO_EXT, &pages);
        if (!IS_ERR(buf)) {
                if (diag204((unsigned long)SUBC_STIB7 |
                            (unsigned long)INFO_EXT, pages, buf) >= 0) {
                        diag204_store_sc = SUBC_STIB7;
                        diag204_info_type = INFO_EXT;
                        goto out;
                }
                if (diag204((unsigned long)SUBC_STIB6 |
                            (unsigned long)INFO_EXT, pages, buf) >= 0) {
                        diag204_store_sc = SUBC_STIB7;
                        diag204_info_type = INFO_EXT;
                        goto out;
                }
                diag204_free_buffer();
        }
 
        /* subcodes 6 and 7 failed, now try subcode 4 */
 
        buf = diag204_get_buffer(INFO_SIMPLE, &pages);
        if (IS_ERR(buf)) {
                rc = PTR_ERR(buf);
                goto fail_alloc;
        }
        if (diag204((unsigned long)SUBC_STIB4 |
                    (unsigned long)INFO_SIMPLE, pages, buf) >= 0) {
                diag204_store_sc = SUBC_STIB4;
                diag204_info_type = INFO_SIMPLE;
                goto out;
        } else {
                rc = -ENOSYS;
                goto fail_store;
        }
out:
        rc = 0;
fail_store:
        diag204_free_buffer();
fail_alloc:
        return rc;
}
 
static void *diag204_store(void)
{
        void *buf;
        int pages;
 
        buf = diag204_get_buffer(diag204_info_type, &pages);
        if (IS_ERR(buf))
                goto out;
        if (diag204((unsigned long)diag204_store_sc |
                    (unsigned long)diag204_info_type, pages, buf) < 0)
                return ERR_PTR(-ENOSYS);
out:
        return buf;
}
 
/* Diagnose 224 functions */
 
static int diag224(void *ptr)
{
        int rc = -ENOTSUPP;
 
        asm volatile(
                "       diag    %1,%2,0x224\n"
                "0:     lhi     %0,0x0\n"
                "1:\n"
                EX_TABLE(0b,1b)
                : "+d" (rc) :"d" (0), "d" (ptr) : "memory");
        return rc;
}
 
static int diag224_get_name_table(void)
{
        /* memory must be below 2GB */
        diag224_cpu_names = kmalloc(PAGE_SIZE, GFP_KERNEL | GFP_DMA);
        if (!diag224_cpu_names)
                return -ENOMEM;
        if (diag224(diag224_cpu_names)) {
                kfree(diag224_cpu_names);
                return -ENOTSUPP;
        }
        EBCASC(diag224_cpu_names + 16, (*diag224_cpu_names + 1) * 16);
        return 0;
}
 
static void diag224_delete_name_table(void)
{
        kfree(diag224_cpu_names);
}
 
static int diag224_idx2name(int index, char *name)
{
        memcpy(name, diag224_cpu_names + ((index + 1) * CPU_NAME_LEN),
                CPU_NAME_LEN);
        name[CPU_NAME_LEN] = 0;
        strstrip(name);
        return 0;
}
 
__init int hypfs_diag_init(void)
{
        int rc;
 
        if (diag204_probe()) {
                printk(KERN_ERR "hypfs: diag 204 not working.");
                return -ENODATA;
        }
        rc = diag224_get_name_table();
        if (rc) {
                diag204_free_buffer();
                printk(KERN_ERR "hypfs: could not get name table.\n");
        }
        return rc;
}
 
void hypfs_diag_exit(void)
{
        diag224_delete_name_table();
        diag204_free_buffer();
}
 
/*
 * Functions to create the directory structure
 * *******************************************
 */
 
static int hypfs_create_cpu_files(struct super_block *sb,
                                  struct dentry *cpus_dir, void *cpu_info)
{
        struct dentry *cpu_dir;
        char buffer[TMP_SIZE];
        void *rc;
 
        snprintf(buffer, TMP_SIZE, "%d", cpu_info__cpu_addr(diag204_info_type,
                                                            cpu_info));
        cpu_dir = hypfs_mkdir(sb, cpus_dir, buffer);
        rc = hypfs_create_u64(sb, cpu_dir, "mgmtime",
                              cpu_info__acc_time(diag204_info_type, cpu_info) -
                              cpu_info__lp_time(diag204_info_type, cpu_info));
        if (IS_ERR(rc))
                return PTR_ERR(rc);
        rc = hypfs_create_u64(sb, cpu_dir, "cputime",
                              cpu_info__lp_time(diag204_info_type, cpu_info));
        if (IS_ERR(rc))
                return PTR_ERR(rc);
        if (diag204_info_type == INFO_EXT) {
                rc = hypfs_create_u64(sb, cpu_dir, "onlinetime",
                                      cpu_info__online_time(diag204_info_type,
                                                            cpu_info));
                if (IS_ERR(rc))
                        return PTR_ERR(rc);
        }
        diag224_idx2name(cpu_info__ctidx(diag204_info_type, cpu_info), buffer);
        rc = hypfs_create_str(sb, cpu_dir, "type", buffer);
        if (IS_ERR(rc))
                return PTR_ERR(rc);
        return 0;
}
 
static void *hypfs_create_lpar_files(struct super_block *sb,
                                     struct dentry *systems_dir, void *part_hdr)
{
        struct dentry *cpus_dir;
        struct dentry *lpar_dir;
        char lpar_name[LPAR_NAME_LEN + 1];
        void *cpu_info;
        int i;
 
        part_hdr__part_name(diag204_info_type, part_hdr, lpar_name);
        lpar_name[LPAR_NAME_LEN] = 0;
        lpar_dir = hypfs_mkdir(sb, systems_dir, lpar_name);
        if (IS_ERR(lpar_dir))
                return lpar_dir;
        cpus_dir = hypfs_mkdir(sb, lpar_dir, "cpus");
        if (IS_ERR(cpus_dir))
                return cpus_dir;
        cpu_info = part_hdr + part_hdr__size(diag204_info_type);
        for (i = 0; i < part_hdr__rcpus(diag204_info_type, part_hdr); i++) {
                int rc;
                rc = hypfs_create_cpu_files(sb, cpus_dir, cpu_info);
                if (rc)
                        return ERR_PTR(rc);
                cpu_info += cpu_info__size(diag204_info_type);
        }
        return cpu_info;
}
 
static int hypfs_create_phys_cpu_files(struct super_block *sb,
                                       struct dentry *cpus_dir, void *cpu_info)
{
        struct dentry *cpu_dir;
        char buffer[TMP_SIZE];
        void *rc;
 
        snprintf(buffer, TMP_SIZE, "%i", phys_cpu__cpu_addr(diag204_info_type,
                                                            cpu_info));
        cpu_dir = hypfs_mkdir(sb, cpus_dir, buffer);
        if (IS_ERR(cpu_dir))
                return PTR_ERR(cpu_dir);
        rc = hypfs_create_u64(sb, cpu_dir, "mgmtime",
                              phys_cpu__mgm_time(diag204_info_type, cpu_info));
        if (IS_ERR(rc))
                return PTR_ERR(rc);
        diag224_idx2name(phys_cpu__ctidx(diag204_info_type, cpu_info), buffer);
        rc = hypfs_create_str(sb, cpu_dir, "type", buffer);
        if (IS_ERR(rc))
                return PTR_ERR(rc);
        return 0;
}
 
static void *hypfs_create_phys_files(struct super_block *sb,
                                     struct dentry *parent_dir, void *phys_hdr)
{
        int i;
        void *cpu_info;
        struct dentry *cpus_dir;
 
        cpus_dir = hypfs_mkdir(sb, parent_dir, "cpus");
        if (IS_ERR(cpus_dir))
                return cpus_dir;
        cpu_info = phys_hdr + phys_hdr__size(diag204_info_type);
        for (i = 0; i < phys_hdr__cpus(diag204_info_type, phys_hdr); i++) {
                int rc;
                rc = hypfs_create_phys_cpu_files(sb, cpus_dir, cpu_info);
                if (rc)
                        return ERR_PTR(rc);
                cpu_info += phys_cpu__size(diag204_info_type);
        }
        return cpu_info;
}
 
int hypfs_diag_create_files(struct super_block *sb, struct dentry *root)
{
        struct dentry *systems_dir, *hyp_dir;
        void *time_hdr, *part_hdr;
        int i, rc;
        void *buffer, *ptr;
 
        buffer = diag204_store();
        if (IS_ERR(buffer))
                return PTR_ERR(buffer);
 
        systems_dir = hypfs_mkdir(sb, root, "systems");
        if (IS_ERR(systems_dir)) {
                rc = PTR_ERR(systems_dir);
                goto err_out;
        }
        time_hdr = (struct x_info_blk_hdr *)buffer;
        part_hdr = time_hdr + info_blk_hdr__size(diag204_info_type);
        for (i = 0; i < info_blk_hdr__npar(diag204_info_type, time_hdr); i++) {
                part_hdr = hypfs_create_lpar_files(sb, systems_dir, part_hdr);
                if (IS_ERR(part_hdr)) {
                        rc = PTR_ERR(part_hdr);
                        goto err_out;
                }
        }
        if (info_blk_hdr__flags(diag204_info_type, time_hdr) & LPAR_PHYS_FLG) {
                ptr = hypfs_create_phys_files(sb, root, part_hdr);
                if (IS_ERR(ptr)) {
                        rc = PTR_ERR(ptr);
                        goto err_out;
                }
        }
        hyp_dir = hypfs_mkdir(sb, root, "hyp");
        if (IS_ERR(hyp_dir)) {
                rc = PTR_ERR(hyp_dir);
                goto err_out;
        }
        ptr = hypfs_create_str(sb, hyp_dir, "type", "LPAR Hypervisor");
        if (IS_ERR(ptr)) {
                rc = PTR_ERR(ptr);
                goto err_out;
        }
        rc = 0;
 
err_out:
        return rc;
}

Browse

Tools

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [arch/] [s390/] [hypfs/] [hypfs_diag.c] - Blame information for rev 63

Line No.	Rev	Author	Line
1	63	marcus.erl	`/*`
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 int diag224(void *ptr)`
485			`{`
486			`int rc = -ENOTSUPP;`
487
488			`asm volatile(`
489			`" diag %1,%2,0x224\n"`
490			`"0: lhi %0,0x0\n"`
491			`"1:\n"`
492			`EX_TABLE(0b,1b)`
493			`: "+d" (rc) :"d" (0), "d" (ptr) : "memory");`
494			`return rc;`
495			`}`
496
497			`static int diag224_get_name_table(void)`
498			`{`
499			`/* memory must be below 2GB */`
500			`diag224_cpu_names = kmalloc(PAGE_SIZE, GFP_KERNEL \| GFP_DMA);`
501			`if (!diag224_cpu_names)`
502			`return -ENOMEM;`
503			`if (diag224(diag224_cpu_names)) {`
504			`kfree(diag224_cpu_names);`
505			`return -ENOTSUPP;`
506			`}`
507			`EBCASC(diag224_cpu_names + 16, (diag224_cpu_names + 1) 16);`
508			`return 0;`
509			`}`
510
511			`static void diag224_delete_name_table(void)`
512			`{`
513			`kfree(diag224_cpu_names);`
514			`}`
515
516			`static int diag224_idx2name(int index, char *name)`
517			`{`
518			`memcpy(name, diag224_cpu_names + ((index + 1) * CPU_NAME_LEN),`
519			`CPU_NAME_LEN);`
520			`name[CPU_NAME_LEN] = 0;`
521			`strstrip(name);`
522			`return 0;`
523			`}`
524
525			`__init int hypfs_diag_init(void)`
526			`{`
527			`int rc;`
528
529			`if (diag204_probe()) {`
530			`printk(KERN_ERR "hypfs: diag 204 not working.");`
531			`return -ENODATA;`
532			`}`
533			`rc = diag224_get_name_table();`
534			`if (rc) {`
535			`diag204_free_buffer();`
536			`printk(KERN_ERR "hypfs: could not get name table.\n");`
537			`}`
538			`return rc;`
539			`}`
540
541			`void hypfs_diag_exit(void)`
542			`{`
543			`diag224_delete_name_table();`
544			`diag204_free_buffer();`
545			`}`
546
547			`/*`
548			`* Functions to create the directory structure`
549			`* *******************************************`
550			`*/`
551
552			`static int hypfs_create_cpu_files(struct super_block *sb,`
553			`struct dentry cpus_dir, void cpu_info)`
554			`{`
555			`struct dentry *cpu_dir;`
556			`char buffer[TMP_SIZE];`
557			`void *rc;`
558
559			`snprintf(buffer, TMP_SIZE, "%d", cpu_info__cpu_addr(diag204_info_type,`
560			`cpu_info));`
561			`cpu_dir = hypfs_mkdir(sb, cpus_dir, buffer);`
562			`rc = hypfs_create_u64(sb, cpu_dir, "mgmtime",`
563			`cpu_info__acc_time(diag204_info_type, cpu_info) -`
564			`cpu_info__lp_time(diag204_info_type, cpu_info));`
565			`if (IS_ERR(rc))`
566			`return PTR_ERR(rc);`
567			`rc = hypfs_create_u64(sb, cpu_dir, "cputime",`
568			`cpu_info__lp_time(diag204_info_type, cpu_info));`
569			`if (IS_ERR(rc))`
570			`return PTR_ERR(rc);`
571			`if (diag204_info_type == INFO_EXT) {`
572			`rc = hypfs_create_u64(sb, cpu_dir, "onlinetime",`
573			`cpu_info__online_time(diag204_info_type,`
574			`cpu_info));`
575			`if (IS_ERR(rc))`
576			`return PTR_ERR(rc);`
577			`}`
578			`diag224_idx2name(cpu_info__ctidx(diag204_info_type, cpu_info), buffer);`
579			`rc = hypfs_create_str(sb, cpu_dir, "type", buffer);`
580			`if (IS_ERR(rc))`
581			`return PTR_ERR(rc);`
582			`return 0;`
583			`}`
584
585			`static void hypfs_create_lpar_files(struct super_block sb,`
586			`struct dentry systems_dir, void part_hdr)`
587			`{`
588			`struct dentry *cpus_dir;`
589			`struct dentry *lpar_dir;`
590			`char lpar_name[LPAR_NAME_LEN + 1];`
591			`void *cpu_info;`
592			`int i;`
593
594			`part_hdr__part_name(diag204_info_type, part_hdr, lpar_name);`
595			`lpar_name[LPAR_NAME_LEN] = 0;`
596			`lpar_dir = hypfs_mkdir(sb, systems_dir, lpar_name);`
597			`if (IS_ERR(lpar_dir))`
598			`return lpar_dir;`
599			`cpus_dir = hypfs_mkdir(sb, lpar_dir, "cpus");`
600			`if (IS_ERR(cpus_dir))`
601			`return cpus_dir;`
602			`cpu_info = part_hdr + part_hdr__size(diag204_info_type);`
603			`for (i = 0; i < part_hdr__rcpus(diag204_info_type, part_hdr); i++) {`
604			`int rc;`
605			`rc = hypfs_create_cpu_files(sb, cpus_dir, cpu_info);`
606			`if (rc)`
607			`return ERR_PTR(rc);`
608			`cpu_info += cpu_info__size(diag204_info_type);`
609			`}`
610			`return cpu_info;`
611			`}`
612
613			`static int hypfs_create_phys_cpu_files(struct super_block *sb,`
614			`struct dentry cpus_dir, void cpu_info)`
615			`{`
616			`struct dentry *cpu_dir;`
617			`char buffer[TMP_SIZE];`
618			`void *rc;`
619
620			`snprintf(buffer, TMP_SIZE, "%i", phys_cpu__cpu_addr(diag204_info_type,`
621			`cpu_info));`
622			`cpu_dir = hypfs_mkdir(sb, cpus_dir, buffer);`
623			`if (IS_ERR(cpu_dir))`
624			`return PTR_ERR(cpu_dir);`
625			`rc = hypfs_create_u64(sb, cpu_dir, "mgmtime",`
626			`phys_cpu__mgm_time(diag204_info_type, cpu_info));`
627			`if (IS_ERR(rc))`
628			`return PTR_ERR(rc);`
629			`diag224_idx2name(phys_cpu__ctidx(diag204_info_type, cpu_info), buffer);`
630			`rc = hypfs_create_str(sb, cpu_dir, "type", buffer);`
631			`if (IS_ERR(rc))`
632			`return PTR_ERR(rc);`
633			`return 0;`
634			`}`
635
636			`static void hypfs_create_phys_files(struct super_block sb,`
637			`struct dentry parent_dir, void phys_hdr)`
638			`{`
639			`int i;`
640			`void *cpu_info;`
641			`struct dentry *cpus_dir;`
642
643			`cpus_dir = hypfs_mkdir(sb, parent_dir, "cpus");`
644			`if (IS_ERR(cpus_dir))`
645			`return cpus_dir;`
646			`cpu_info = phys_hdr + phys_hdr__size(diag204_info_type);`
647			`for (i = 0; i < phys_hdr__cpus(diag204_info_type, phys_hdr); i++) {`
648			`int rc;`
649			`rc = hypfs_create_phys_cpu_files(sb, cpus_dir, cpu_info);`
650			`if (rc)`
651			`return ERR_PTR(rc);`
652			`cpu_info += phys_cpu__size(diag204_info_type);`
653			`}`
654			`return cpu_info;`
655			`}`
656
657			`int hypfs_diag_create_files(struct super_block sb, struct dentry root)`
658			`{`
659			`struct dentry systems_dir, hyp_dir;`
660			`void time_hdr, part_hdr;`
661			`int i, rc;`
662			`void buffer, ptr;`
663
664			`buffer = diag204_store();`
665			`if (IS_ERR(buffer))`
666			`return PTR_ERR(buffer);`
667
668			`systems_dir = hypfs_mkdir(sb, root, "systems");`
669			`if (IS_ERR(systems_dir)) {`
670			`rc = PTR_ERR(systems_dir);`
671			`goto err_out;`
672			`}`
673			`time_hdr = (struct x_info_blk_hdr *)buffer;`
674			`part_hdr = time_hdr + info_blk_hdr__size(diag204_info_type);`
675			`for (i = 0; i < info_blk_hdr__npar(diag204_info_type, time_hdr); i++) {`
676			`part_hdr = hypfs_create_lpar_files(sb, systems_dir, part_hdr);`
677			`if (IS_ERR(part_hdr)) {`
678			`rc = PTR_ERR(part_hdr);`
679			`goto err_out;`
680			`}`
681			`}`
682			`if (info_blk_hdr__flags(diag204_info_type, time_hdr) & LPAR_PHYS_FLG) {`
683			`ptr = hypfs_create_phys_files(sb, root, part_hdr);`
684			`if (IS_ERR(ptr)) {`
685			`rc = PTR_ERR(ptr);`
686			`goto err_out;`
687			`}`
688			`}`
689			`hyp_dir = hypfs_mkdir(sb, root, "hyp");`
690			`if (IS_ERR(hyp_dir)) {`
691			`rc = PTR_ERR(hyp_dir);`
692			`goto err_out;`
693			`}`
694			`ptr = hypfs_create_str(sb, hyp_dir, "type", "LPAR Hypervisor");`
695			`if (IS_ERR(ptr)) {`
696			`rc = PTR_ERR(ptr);`
697			`goto err_out;`
698			`}`
699			`rc = 0;`
700
701			`err_out:`
702			`return rc;`
703			`}`