[linux-2.6-block.git] / arch / s390 / hypfs / hypfs_diag.c

// SPDX-License-Identifier: GPL-2.0
/*
 *    Hypervisor filesystem for Linux on s390. Diag 204 and 224
 *    implementation.
 *
 *    Copyright IBM Corp. 2006, 2008
 *    Author(s): Michael Holzheu <holzheu@de.ibm.com>
 */

#define KMSG_COMPONENT "hypfs"
#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt

#include <linux/types.h>
#include <linux/errno.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/vmalloc.h>
#include <linux/mm.h>
#include <asm/diag.h>
#include <asm/ebcdic.h>
#include "hypfs.h"

#define TMP_SIZE 64		/* size of temporary buffers */

#define DBFS_D204_HDR_VERSION	0

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 */

static struct dentry *dbfs_d204_file;

/*
 * DIAG 204 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 */

static inline int info_blk_hdr__size(enum diag204_format type)
{
	if (type == DIAG204_INFO_SIMPLE)
		return sizeof(struct diag204_info_blk_hdr);
	else /* DIAG204_INFO_EXT */
		return sizeof(struct diag204_x_info_blk_hdr);
}

static inline __u8 info_blk_hdr__npar(enum diag204_format type, void *hdr)
{
	if (type == DIAG204_INFO_SIMPLE)
		return ((struct diag204_info_blk_hdr *)hdr)->npar;
	else /* DIAG204_INFO_EXT */
		return ((struct diag204_x_info_blk_hdr *)hdr)->npar;
}

static inline __u8 info_blk_hdr__flags(enum diag204_format type, void *hdr)
{
	if (type == DIAG204_INFO_SIMPLE)
		return ((struct diag204_info_blk_hdr *)hdr)->flags;
	else /* DIAG204_INFO_EXT */
		return ((struct diag204_x_info_blk_hdr *)hdr)->flags;
}

static inline __u16 info_blk_hdr__pcpus(enum diag204_format type, void *hdr)
{
	if (type == DIAG204_INFO_SIMPLE)
		return ((struct diag204_info_blk_hdr *)hdr)->phys_cpus;
	else /* DIAG204_INFO_EXT */
		return ((struct diag204_x_info_blk_hdr *)hdr)->phys_cpus;
}

/* Partition header */

static inline int part_hdr__size(enum diag204_format type)
{
	if (type == DIAG204_INFO_SIMPLE)
		return sizeof(struct diag204_part_hdr);
	else /* DIAG204_INFO_EXT */
		return sizeof(struct diag204_x_part_hdr);
}

static inline __u8 part_hdr__rcpus(enum diag204_format type, void *hdr)
{
	if (type == DIAG204_INFO_SIMPLE)
		return ((struct diag204_part_hdr *)hdr)->cpus;
	else /* DIAG204_INFO_EXT */
		return ((struct diag204_x_part_hdr *)hdr)->rcpus;
}

static inline void part_hdr__part_name(enum diag204_format type, void *hdr,
				       char *name)
{
	if (type == DIAG204_INFO_SIMPLE)
		memcpy(name, ((struct diag204_part_hdr *)hdr)->part_name,
		       DIAG204_LPAR_NAME_LEN);
	else /* DIAG204_INFO_EXT */
		memcpy(name, ((struct diag204_x_part_hdr *)hdr)->part_name,
		       DIAG204_LPAR_NAME_LEN);
	EBCASC(name, DIAG204_LPAR_NAME_LEN);
	name[DIAG204_LPAR_NAME_LEN] = 0;
	strim(name);
}

/* CPU info block */

static inline int cpu_info__size(enum diag204_format type)
{
	if (type == DIAG204_INFO_SIMPLE)
		return sizeof(struct diag204_cpu_info);
	else /* DIAG204_INFO_EXT */
		return sizeof(struct diag204_x_cpu_info);
}

static inline __u8 cpu_info__ctidx(enum diag204_format type, void *hdr)
{
	if (type == DIAG204_INFO_SIMPLE)
		return ((struct diag204_cpu_info *)hdr)->ctidx;
	else /* DIAG204_INFO_EXT */
		return ((struct diag204_x_cpu_info *)hdr)->ctidx;
}

static inline __u16 cpu_info__cpu_addr(enum diag204_format type, void *hdr)
{
	if (type == DIAG204_INFO_SIMPLE)
		return ((struct diag204_cpu_info *)hdr)->cpu_addr;
	else /* DIAG204_INFO_EXT */
		return ((struct diag204_x_cpu_info *)hdr)->cpu_addr;
}

static inline __u64 cpu_info__acc_time(enum diag204_format type, void *hdr)
{
	if (type == DIAG204_INFO_SIMPLE)
		return ((struct diag204_cpu_info *)hdr)->acc_time;
	else /* DIAG204_INFO_EXT */
		return ((struct diag204_x_cpu_info *)hdr)->acc_time;
}

static inline __u64 cpu_info__lp_time(enum diag204_format type, void *hdr)
{
	if (type == DIAG204_INFO_SIMPLE)
		return ((struct diag204_cpu_info *)hdr)->lp_time;
	else /* DIAG204_INFO_EXT */
		return ((struct diag204_x_cpu_info *)hdr)->lp_time;
}

static inline __u64 cpu_info__online_time(enum diag204_format type, void *hdr)
{
	if (type == DIAG204_INFO_SIMPLE)
		return 0;	/* online_time not available in simple info */
	else /* DIAG204_INFO_EXT */
		return ((struct diag204_x_cpu_info *)hdr)->online_time;
}

/* Physical header */

static inline int phys_hdr__size(enum diag204_format type)
{
	if (type == DIAG204_INFO_SIMPLE)
		return sizeof(struct diag204_phys_hdr);
	else /* DIAG204_INFO_EXT */
		return sizeof(struct diag204_x_phys_hdr);
}

static inline __u8 phys_hdr__cpus(enum diag204_format type, void *hdr)
{
	if (type == DIAG204_INFO_SIMPLE)
		return ((struct diag204_phys_hdr *)hdr)->cpus;
	else /* DIAG204_INFO_EXT */
		return ((struct diag204_x_phys_hdr *)hdr)->cpus;
}

/* Physical CPU info block */

static inline int phys_cpu__size(enum diag204_format type)
{
	if (type == DIAG204_INFO_SIMPLE)
		return sizeof(struct diag204_phys_cpu);
	else /* DIAG204_INFO_EXT */
		return sizeof(struct diag204_x_phys_cpu);
}

static inline __u16 phys_cpu__cpu_addr(enum diag204_format type, void *hdr)
{
	if (type == DIAG204_INFO_SIMPLE)
		return ((struct diag204_phys_cpu *)hdr)->cpu_addr;
	else /* DIAG204_INFO_EXT */
		return ((struct diag204_x_phys_cpu *)hdr)->cpu_addr;
}

static inline __u64 phys_cpu__mgm_time(enum diag204_format type, void *hdr)
{
	if (type == DIAG204_INFO_SIMPLE)
		return ((struct diag204_phys_cpu *)hdr)->mgm_time;
	else /* DIAG204_INFO_EXT */
		return ((struct diag204_x_phys_cpu *)hdr)->mgm_time;
}

static inline __u64 phys_cpu__ctidx(enum diag204_format type, void *hdr)
{
	if (type == DIAG204_INFO_SIMPLE)
		return ((struct diag204_phys_cpu *)hdr)->ctidx;
	else /* DIAG204_INFO_EXT */
		return ((struct diag204_x_phys_cpu *)hdr)->ctidx;
}

/* Diagnose 204 functions */
/*
 * 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 = NULL;
}

static void *page_align_ptr(void *ptr)
{
	return (void *) PAGE_ALIGN((unsigned long) ptr);
}

static void *diag204_alloc_vbuf(int pages)
{
	/* The buffer has to be page aligned! */
	diag204_buf_vmalloc = vmalloc(array_size(PAGE_SIZE, (pages + 1)));
	if (!diag204_buf_vmalloc)
		return ERR_PTR(-ENOMEM);
	diag204_buf = page_align_ptr(diag204_buf_vmalloc);
	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 == DIAG204_INFO_SIMPLE) {
		*pages = 1;
		return diag204_alloc_rbuf();
	} else {/* DIAG204_INFO_EXT */
		*pages = diag204((unsigned long)DIAG204_SUBC_RSI |
				 (unsigned long)DIAG204_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(DIAG204_INFO_EXT, &pages);
	if (!IS_ERR(buf)) {
		if (diag204((unsigned long)DIAG204_SUBC_STIB7 |
			    (unsigned long)DIAG204_INFO_EXT, pages, buf) >= 0) {
			diag204_store_sc = DIAG204_SUBC_STIB7;
			diag204_info_type = DIAG204_INFO_EXT;
			goto out;
		}
		if (diag204((unsigned long)DIAG204_SUBC_STIB6 |
			    (unsigned long)DIAG204_INFO_EXT, pages, buf) >= 0) {
			diag204_store_sc = DIAG204_SUBC_STIB6;
			diag204_info_type = DIAG204_INFO_EXT;
			goto out;
		}
		diag204_free_buffer();
	}

	/* subcodes 6 and 7 failed, now try subcode 4 */

	buf = diag204_get_buffer(DIAG204_INFO_SIMPLE, &pages);
	if (IS_ERR(buf)) {
		rc = PTR_ERR(buf);
		goto fail_alloc;
	}
	if (diag204((unsigned long)DIAG204_SUBC_STIB4 |
		    (unsigned long)DIAG204_INFO_SIMPLE, pages, buf) >= 0) {
		diag204_store_sc = DIAG204_SUBC_STIB4;
		diag204_info_type = DIAG204_INFO_SIMPLE;
		goto out;
	} else {
		rc = -ENOSYS;
		goto fail_store;
	}
out:
	rc = 0;
fail_store:
	diag204_free_buffer();
fail_alloc:
	return rc;
}

static int diag204_do_store(void *buf, int pages)
{
	int rc;

	rc = diag204((unsigned long) diag204_store_sc |
		     (unsigned long) diag204_info_type, pages, buf);
	return rc < 0 ? -ENOSYS : 0;
}

static void *diag204_store(void)
{
	void *buf;
	int pages, rc;

	buf = diag204_get_buffer(diag204_info_type, &pages);
	if (IS_ERR(buf))
		goto out;
	rc = diag204_do_store(buf, pages);
	if (rc)
		return ERR_PTR(rc);
out:
	return buf;
}

/* Diagnose 224 functions */

static int diag224_get_name_table(void)
{
	/* memory must be below 2GB */
	diag224_cpu_names = (char *) __get_free_page(GFP_KERNEL | GFP_DMA);
	if (!diag224_cpu_names)
		return -ENOMEM;
	if (diag224(diag224_cpu_names)) {
		free_page((unsigned long) diag224_cpu_names);
		return -EOPNOTSUPP;
	}
	EBCASC(diag224_cpu_names + 16, (*diag224_cpu_names + 1) * 16);
	return 0;
}

static void diag224_delete_name_table(void)
{
	free_page((unsigned long) diag224_cpu_names);
}

static int diag224_idx2name(int index, char *name)
{
	memcpy(name, diag224_cpu_names + ((index + 1) * DIAG204_CPU_NAME_LEN),
	       DIAG204_CPU_NAME_LEN);
	name[DIAG204_CPU_NAME_LEN] = 0;
	strim(name);
	return 0;
}

struct dbfs_d204_hdr {
	u64	len;		/* Length of d204 buffer without header */
	u16	version;	/* Version of header */
	u8	sc;		/* Used subcode */
	char	reserved[53];
} __attribute__ ((packed));

struct dbfs_d204 {
	struct dbfs_d204_hdr	hdr;	/* 64 byte header */
	char			buf[];	/* d204 buffer */
} __attribute__ ((packed));

static int dbfs_d204_create(void **data, void **data_free_ptr, size_t *size)
{
	struct dbfs_d204 *d204;
	int rc, buf_size;
	void *base;

	buf_size = PAGE_SIZE * (diag204_buf_pages + 1) + sizeof(d204->hdr);
	base = vzalloc(buf_size);
	if (!base)
		return -ENOMEM;
	d204 = page_align_ptr(base + sizeof(d204->hdr)) - sizeof(d204->hdr);
	rc = diag204_do_store(d204->buf, diag204_buf_pages);
	if (rc) {
		vfree(base);
		return rc;
	}
	d204->hdr.version = DBFS_D204_HDR_VERSION;
	d204->hdr.len = PAGE_SIZE * diag204_buf_pages;
	d204->hdr.sc = diag204_store_sc;
	*data = d204;
	*data_free_ptr = base;
	*size = d204->hdr.len + sizeof(struct dbfs_d204_hdr);
	return 0;
}

static struct hypfs_dbfs_file dbfs_file_d204 = {
	.name		= "diag_204",
	.data_create	= dbfs_d204_create,
	.data_free	= vfree,
};

__init int hypfs_diag_init(void)
{
	int rc;

	if (diag204_probe()) {
		pr_err("The hardware system does not support hypfs\n");
		return -ENODATA;
	}

	if (diag204_info_type == DIAG204_INFO_EXT)
		hypfs_dbfs_create_file(&dbfs_file_d204);

	if (MACHINE_IS_LPAR) {
		rc = diag224_get_name_table();
		if (rc) {
			pr_err("The hardware system does not provide all "
			       "functions required by hypfs\n");
			debugfs_remove(dbfs_d204_file);
			return rc;
		}
	}
	return 0;
}

void hypfs_diag_exit(void)
{
	debugfs_remove(dbfs_d204_file);
	diag224_delete_name_table();
	diag204_free_buffer();
	hypfs_dbfs_remove_file(&dbfs_file_d204);
}

/*
 * Functions to create the directory structure
 * *******************************************
 */

static int hypfs_create_cpu_files(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(cpus_dir, buffer);
	rc = hypfs_create_u64(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(cpu_dir, "cputime",
			      cpu_info__lp_time(diag204_info_type, cpu_info));
	if (IS_ERR(rc))
		return PTR_ERR(rc);
	if (diag204_info_type == DIAG204_INFO_EXT) {
		rc = hypfs_create_u64(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(cpu_dir, "type", buffer);
	return PTR_ERR_OR_ZERO(rc);
}

static void *hypfs_create_lpar_files(struct dentry *systems_dir, void *part_hdr)
{
	struct dentry *cpus_dir;
	struct dentry *lpar_dir;
	char lpar_name[DIAG204_LPAR_NAME_LEN + 1];
	void *cpu_info;
	int i;

	part_hdr__part_name(diag204_info_type, part_hdr, lpar_name);
	lpar_name[DIAG204_LPAR_NAME_LEN] = 0;
	lpar_dir = hypfs_mkdir(systems_dir, lpar_name);
	if (IS_ERR(lpar_dir))
		return lpar_dir;
	cpus_dir = hypfs_mkdir(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(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 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(cpus_dir, buffer);
	if (IS_ERR(cpu_dir))
		return PTR_ERR(cpu_dir);
	rc = hypfs_create_u64(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(cpu_dir, "type", buffer);
	return PTR_ERR_OR_ZERO(rc);
}

static void *hypfs_create_phys_files(struct dentry *parent_dir, void *phys_hdr)
{
	int i;
	void *cpu_info;
	struct dentry *cpus_dir;

	cpus_dir = hypfs_mkdir(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(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 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(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(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) &
	    DIAG204_LPAR_PHYS_FLG) {
		ptr = hypfs_create_phys_files(root, part_hdr);
		if (IS_ERR(ptr)) {
			rc = PTR_ERR(ptr);
			goto err_out;
		}
	}
	hyp_dir = hypfs_mkdir(root, "hyp");
	if (IS_ERR(hyp_dir)) {
		rc = PTR_ERR(hyp_dir);
		goto err_out;
	}
	ptr = hypfs_create_str(hyp_dir, "type", "LPAR Hypervisor");
	if (IS_ERR(ptr)) {
		rc = PTR_ERR(ptr);
		goto err_out;
	}
	rc = 0;

err_out:
	return rc;
}
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
24bbb1fa	2	/*
24bbb1fa MH	3	* Hypervisor filesystem for Linux on s390. Diag 204 and 224
	4	* implementation.
	5	*
f55495ba	6	* Copyright IBM Corp. 2006, 2008
24bbb1fa MH	7	* Author(s): Michael Holzheu <holzheu@de.ibm.com>
	8	*/
	9
f55495ba MH	10	#define KMSG_COMPONENT "hypfs"
	11	#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
	12
24bbb1fa MH	13	#include <linux/types.h>
24bbb1fa MH	14	#include <linux/errno.h>
33b26d79	15	#include <linux/slab.h>
24bbb1fa MH	16	#include <linux/string.h>
24bbb1fa MH	17	#include <linux/vmalloc.h>
57b28f66	18	#include <linux/mm.h>
1ec2772e	19	#include <asm/diag.h>
24bbb1fa MH	20	#include <asm/ebcdic.h>
	21	#include "hypfs.h"
	22
24bbb1fa MH	23	#define TMP_SIZE 64 /* size of temporary buffers */
24bbb1fa MH	24
57b28f66 MH	25	#define DBFS_D204_HDR_VERSION 0
57b28f66 MH	26
24bbb1fa MH	27	static char diag224_cpu_names; / diag 224 name table */
	28	static enum diag204_sc diag204_store_sc; /* used subcode for store */
	29	static enum diag204_format diag204_info_type; /* used diag 204 data format */
	30
	31	static void diag204_buf; / 4K aligned buffer for diag204 data */
	32	static void diag204_buf_vmalloc; / vmalloc pointer for diag204 data */
	33	static int diag204_buf_pages; /* number of pages for diag204 data */
	34
57b28f66 MH	35	static struct dentry *dbfs_d204_file;
57b28f66 MH	36
24bbb1fa	37	/*
e65f30e0	38	* DIAG 204 member access functions.
24bbb1fa MH	39	*
	40	* Since we have two different diag 204 data formats for old and new s390
	41	* machines, we do not access the structs directly, but use getter functions for
	42	* each struct member instead. This should make the code more readable.
	43	*/
	44
	45	/* Time information block */
	46
24bbb1fa MH	47	static inline int info_blk_hdr__size(enum diag204_format type)
24bbb1fa MH	48	{
e65f30e0 JF	49	if (type == DIAG204_INFO_SIMPLE)
	50	return sizeof(struct diag204_info_blk_hdr);
	51	else /* DIAG204_INFO_EXT */
	52	return sizeof(struct diag204_x_info_blk_hdr);
24bbb1fa MH	53	}
	54
	55	static inline __u8 info_blk_hdr__npar(enum diag204_format type, void *hdr)
	56	{
e65f30e0 JF	57	if (type == DIAG204_INFO_SIMPLE)
	58	return ((struct diag204_info_blk_hdr *)hdr)->npar;
	59	else /* DIAG204_INFO_EXT */
	60	return ((struct diag204_x_info_blk_hdr *)hdr)->npar;
24bbb1fa MH	61	}
	62
	63	static inline __u8 info_blk_hdr__flags(enum diag204_format type, void *hdr)
	64	{
e65f30e0 JF	65	if (type == DIAG204_INFO_SIMPLE)
	66	return ((struct diag204_info_blk_hdr *)hdr)->flags;
	67	else /* DIAG204_INFO_EXT */
	68	return ((struct diag204_x_info_blk_hdr *)hdr)->flags;
24bbb1fa MH	69	}
	70
	71	static inline __u16 info_blk_hdr__pcpus(enum diag204_format type, void *hdr)
	72	{
e65f30e0 JF	73	if (type == DIAG204_INFO_SIMPLE)
	74	return ((struct diag204_info_blk_hdr *)hdr)->phys_cpus;
	75	else /* DIAG204_INFO_EXT */
	76	return ((struct diag204_x_info_blk_hdr *)hdr)->phys_cpus;
24bbb1fa MH	77	}
	78
	79	/* Partition header */
	80
24bbb1fa MH	81	static inline int part_hdr__size(enum diag204_format type)
24bbb1fa MH	82	{
e65f30e0 JF	83	if (type == DIAG204_INFO_SIMPLE)
	84	return sizeof(struct diag204_part_hdr);
	85	else /* DIAG204_INFO_EXT */
	86	return sizeof(struct diag204_x_part_hdr);
24bbb1fa MH	87	}
	88
	89	static inline __u8 part_hdr__rcpus(enum diag204_format type, void *hdr)
	90	{
e65f30e0 JF	91	if (type == DIAG204_INFO_SIMPLE)
	92	return ((struct diag204_part_hdr *)hdr)->cpus;
	93	else /* DIAG204_INFO_EXT */
	94	return ((struct diag204_x_part_hdr *)hdr)->rcpus;
24bbb1fa MH	95	}
	96
	97	static inline void part_hdr__part_name(enum diag204_format type, void *hdr,
	98	char *name)
	99	{
e65f30e0 JF	100	if (type == DIAG204_INFO_SIMPLE)
	101	memcpy(name, ((struct diag204_part_hdr *)hdr)->part_name,
	102	DIAG204_LPAR_NAME_LEN);
	103	else /* DIAG204_INFO_EXT */
	104	memcpy(name, ((struct diag204_x_part_hdr *)hdr)->part_name,
	105	DIAG204_LPAR_NAME_LEN);
	106	EBCASC(name, DIAG204_LPAR_NAME_LEN);
	107	name[DIAG204_LPAR_NAME_LEN] = 0;
1d802e24	108	strim(name);
24bbb1fa MH	109	}
24bbb1fa MH	110
24bbb1fa MH	111	/* CPU info block */
	112
	113	static inline int cpu_info__size(enum diag204_format type)
	114	{
e65f30e0 JF	115	if (type == DIAG204_INFO_SIMPLE)
	116	return sizeof(struct diag204_cpu_info);
	117	else /* DIAG204_INFO_EXT */
	118	return sizeof(struct diag204_x_cpu_info);
24bbb1fa MH	119	}
	120
	121	static inline __u8 cpu_info__ctidx(enum diag204_format type, void *hdr)
	122	{
e65f30e0 JF	123	if (type == DIAG204_INFO_SIMPLE)
	124	return ((struct diag204_cpu_info *)hdr)->ctidx;
	125	else /* DIAG204_INFO_EXT */
	126	return ((struct diag204_x_cpu_info *)hdr)->ctidx;
24bbb1fa MH	127	}
	128
	129	static inline __u16 cpu_info__cpu_addr(enum diag204_format type, void *hdr)
	130	{
e65f30e0 JF	131	if (type == DIAG204_INFO_SIMPLE)
	132	return ((struct diag204_cpu_info *)hdr)->cpu_addr;
	133	else /* DIAG204_INFO_EXT */
	134	return ((struct diag204_x_cpu_info *)hdr)->cpu_addr;
24bbb1fa MH	135	}
	136
	137	static inline __u64 cpu_info__acc_time(enum diag204_format type, void *hdr)
	138	{
e65f30e0 JF	139	if (type == DIAG204_INFO_SIMPLE)
	140	return ((struct diag204_cpu_info *)hdr)->acc_time;
	141	else /* DIAG204_INFO_EXT */
	142	return ((struct diag204_x_cpu_info *)hdr)->acc_time;
24bbb1fa MH	143	}
	144
	145	static inline __u64 cpu_info__lp_time(enum diag204_format type, void *hdr)
	146	{
e65f30e0 JF	147	if (type == DIAG204_INFO_SIMPLE)
	148	return ((struct diag204_cpu_info *)hdr)->lp_time;
	149	else /* DIAG204_INFO_EXT */
	150	return ((struct diag204_x_cpu_info *)hdr)->lp_time;
24bbb1fa MH	151	}
	152
	153	static inline __u64 cpu_info__online_time(enum diag204_format type, void *hdr)
	154	{
e65f30e0	155	if (type == DIAG204_INFO_SIMPLE)
24bbb1fa	156	return 0; /* online_time not available in simple info */
e65f30e0 JF	157	else /* DIAG204_INFO_EXT */
e65f30e0 JF	158	return ((struct diag204_x_cpu_info *)hdr)->online_time;
24bbb1fa MH	159	}
	160
	161	/* Physical header */
	162
24bbb1fa MH	163	static inline int phys_hdr__size(enum diag204_format type)
24bbb1fa MH	164	{
e65f30e0 JF	165	if (type == DIAG204_INFO_SIMPLE)
	166	return sizeof(struct diag204_phys_hdr);
	167	else /* DIAG204_INFO_EXT */
	168	return sizeof(struct diag204_x_phys_hdr);
24bbb1fa MH	169	}
	170
	171	static inline __u8 phys_hdr__cpus(enum diag204_format type, void *hdr)
	172	{
e65f30e0 JF	173	if (type == DIAG204_INFO_SIMPLE)
	174	return ((struct diag204_phys_hdr *)hdr)->cpus;
	175	else /* DIAG204_INFO_EXT */
	176	return ((struct diag204_x_phys_hdr *)hdr)->cpus;
24bbb1fa MH	177	}
	178
	179	/* Physical CPU info block */
	180
24bbb1fa MH	181	static inline int phys_cpu__size(enum diag204_format type)
24bbb1fa MH	182	{
e65f30e0 JF	183	if (type == DIAG204_INFO_SIMPLE)
	184	return sizeof(struct diag204_phys_cpu);
	185	else /* DIAG204_INFO_EXT */
	186	return sizeof(struct diag204_x_phys_cpu);
24bbb1fa MH	187	}
	188
	189	static inline __u16 phys_cpu__cpu_addr(enum diag204_format type, void *hdr)
	190	{
e65f30e0 JF	191	if (type == DIAG204_INFO_SIMPLE)
	192	return ((struct diag204_phys_cpu *)hdr)->cpu_addr;
	193	else /* DIAG204_INFO_EXT */
	194	return ((struct diag204_x_phys_cpu *)hdr)->cpu_addr;
24bbb1fa MH	195	}
	196
	197	static inline __u64 phys_cpu__mgm_time(enum diag204_format type, void *hdr)
	198	{
e65f30e0 JF	199	if (type == DIAG204_INFO_SIMPLE)
	200	return ((struct diag204_phys_cpu *)hdr)->mgm_time;
	201	else /* DIAG204_INFO_EXT */
	202	return ((struct diag204_x_phys_cpu *)hdr)->mgm_time;
24bbb1fa MH	203	}
	204
	205	static inline __u64 phys_cpu__ctidx(enum diag204_format type, void *hdr)
	206	{
e65f30e0 JF	207	if (type == DIAG204_INFO_SIMPLE)
	208	return ((struct diag204_phys_cpu *)hdr)->ctidx;
	209	else /* DIAG204_INFO_EXT */
	210	return ((struct diag204_x_phys_cpu *)hdr)->ctidx;
24bbb1fa MH	211	}
	212
	213	/* Diagnose 204 functions */
24bbb1fa MH	214	/*
	215	* For the old diag subcode 4 with simple data format we have to use real
	216	* memory. If we use subcode 6 or 7 with extended data format, we can (and
	217	* should) use vmalloc, since we need a lot of memory in that case. Currently
	218	* up to 93 pages!
	219	*/
	220
	221	static void diag204_free_buffer(void)
	222	{
	223	if (!diag204_buf)
	224	return;
	225	if (diag204_buf_vmalloc) {
	226	vfree(diag204_buf_vmalloc);
	227	diag204_buf_vmalloc = NULL;
	228	} else {
	229	free_pages((unsigned long) diag204_buf, 0);
	230	}
24bbb1fa MH	231	diag204_buf = NULL;
	232	}
	233
57b28f66 MH	234	static void page_align_ptr(void ptr)
	235	{
	236	return (void *) PAGE_ALIGN((unsigned long) ptr);
	237	}
	238
24bbb1fa MH	239	static void *diag204_alloc_vbuf(int pages)
	240	{
	241	/* The buffer has to be page aligned! */
42bc47b3	242	diag204_buf_vmalloc = vmalloc(array_size(PAGE_SIZE, (pages + 1)));
24bbb1fa MH	243	if (!diag204_buf_vmalloc)
24bbb1fa MH	244	return ERR_PTR(-ENOMEM);
57b28f66	245	diag204_buf = page_align_ptr(diag204_buf_vmalloc);
24bbb1fa MH	246	diag204_buf_pages = pages;
	247	return diag204_buf;
	248	}
	249
	250	static void *diag204_alloc_rbuf(void)
	251	{
	252	diag204_buf = (void*)__get_free_pages(GFP_KERNEL,0);
86b22470	253	if (!diag204_buf)
24bbb1fa MH	254	return ERR_PTR(-ENOMEM);
	255	diag204_buf_pages = 1;
	256	return diag204_buf;
	257	}
	258
	259	static void diag204_get_buffer(enum diag204_format fmt, int pages)
	260	{
	261	if (diag204_buf) {
	262	*pages = diag204_buf_pages;
	263	return diag204_buf;
	264	}
e65f30e0	265	if (fmt == DIAG204_INFO_SIMPLE) {
24bbb1fa MH	266	*pages = 1;
24bbb1fa MH	267	return diag204_alloc_rbuf();
e65f30e0 JF	268	} else {/* DIAG204_INFO_EXT */
	269	*pages = diag204((unsigned long)DIAG204_SUBC_RSI \|
	270	(unsigned long)DIAG204_INFO_EXT, 0, NULL);
24bbb1fa MH	271	if (*pages <= 0)
	272	return ERR_PTR(-ENOSYS);
	273	else
	274	return diag204_alloc_vbuf(*pages);
	275	}
	276	}
	277
	278	/*
	279	* diag204_probe() has to find out, which type of diagnose 204 implementation
	280	* we have on our machine. Currently there are three possible scanarios:
	281	* - subcode 4 + simple data format (only one page)
	282	* - subcode 4-6 + extended data format
	283	* - subcode 4-7 + extended data format
	284	*
	285	* Subcode 5 is used to retrieve the size of the data, provided by subcodes
	286	* 6 and 7. Subcode 7 basically has the same function as subcode 6. In addition
	287	* to subcode 6 it provides also information about secondary cpus.
	288	* In order to get as much information as possible, we first try
	289	* subcode 7, then 6 and if both fail, we use subcode 4.
	290	*/
	291
	292	static int diag204_probe(void)
	293	{
	294	void *buf;
	295	int pages, rc;
	296
e65f30e0	297	buf = diag204_get_buffer(DIAG204_INFO_EXT, &pages);
24bbb1fa	298	if (!IS_ERR(buf)) {
e65f30e0 JF	299	if (diag204((unsigned long)DIAG204_SUBC_STIB7 \|
	300	(unsigned long)DIAG204_INFO_EXT, pages, buf) >= 0) {
	301	diag204_store_sc = DIAG204_SUBC_STIB7;
	302	diag204_info_type = DIAG204_INFO_EXT;
24bbb1fa MH	303	goto out;
24bbb1fa MH	304	}
e65f30e0 JF	305	if (diag204((unsigned long)DIAG204_SUBC_STIB6 \|
	306	(unsigned long)DIAG204_INFO_EXT, pages, buf) >= 0) {
	307	diag204_store_sc = DIAG204_SUBC_STIB6;
	308	diag204_info_type = DIAG204_INFO_EXT;
24bbb1fa MH	309	goto out;
	310	}
	311	diag204_free_buffer();
	312	}
	313
	314	/* subcodes 6 and 7 failed, now try subcode 4 */
	315
e65f30e0	316	buf = diag204_get_buffer(DIAG204_INFO_SIMPLE, &pages);
24bbb1fa MH	317	if (IS_ERR(buf)) {
	318	rc = PTR_ERR(buf);
	319	goto fail_alloc;
	320	}
e65f30e0 JF	321	if (diag204((unsigned long)DIAG204_SUBC_STIB4 \|
	322	(unsigned long)DIAG204_INFO_SIMPLE, pages, buf) >= 0) {
	323	diag204_store_sc = DIAG204_SUBC_STIB4;
	324	diag204_info_type = DIAG204_INFO_SIMPLE;
24bbb1fa MH	325	goto out;
	326	} else {
	327	rc = -ENOSYS;
	328	goto fail_store;
	329	}
	330	out:
	331	rc = 0;
	332	fail_store:
	333	diag204_free_buffer();
	334	fail_alloc:
	335	return rc;
	336	}
	337
57b28f66 MH	338	static int diag204_do_store(void *buf, int pages)
	339	{
	340	int rc;
	341
	342	rc = diag204((unsigned long) diag204_store_sc \|
	343	(unsigned long) diag204_info_type, pages, buf);
	344	return rc < 0 ? -ENOSYS : 0;
	345	}
	346
24bbb1fa MH	347	static void *diag204_store(void)
	348	{
	349	void *buf;
57b28f66	350	int pages, rc;
24bbb1fa MH	351
	352	buf = diag204_get_buffer(diag204_info_type, &pages);
	353	if (IS_ERR(buf))
	354	goto out;
57b28f66 MH	355	rc = diag204_do_store(buf, pages);
	356	if (rc)
	357	return ERR_PTR(rc);
24bbb1fa MH	358	out:
	359	return buf;
	360	}
	361
	362	/* Diagnose 224 functions */
	363
24bbb1fa MH	364	static int diag224_get_name_table(void)
	365	{
	366	/* memory must be below 2GB */
237d6e68	367	diag224_cpu_names = (char *) __get_free_page(GFP_KERNEL \| GFP_DMA);
24bbb1fa MH	368	if (!diag224_cpu_names)
24bbb1fa MH	369	return -ENOMEM;
c41d4e3e	370	if (diag224(diag224_cpu_names)) {
237d6e68	371	free_page((unsigned long) diag224_cpu_names);
b8e660b8	372	return -EOPNOTSUPP;
c41d4e3e	373	}
24bbb1fa MH	374	EBCASC(diag224_cpu_names + 16, (diag224_cpu_names + 1) 16);
	375	return 0;
	376	}
	377
	378	static void diag224_delete_name_table(void)
	379	{
237d6e68	380	free_page((unsigned long) diag224_cpu_names);
24bbb1fa MH	381	}
	382
	383	static int diag224_idx2name(int index, char *name)
	384	{
e65f30e0 JF	385	memcpy(name, diag224_cpu_names + ((index + 1) * DIAG204_CPU_NAME_LEN),
	386	DIAG204_CPU_NAME_LEN);
	387	name[DIAG204_CPU_NAME_LEN] = 0;
1d802e24	388	strim(name);
24bbb1fa MH	389	return 0;
	390	}
	391
57b28f66 MH	392	struct dbfs_d204_hdr {
	393	u64 len; /* Length of d204 buffer without header */
	394	u16 version; /* Version of header */
	395	u8 sc; /* Used subcode */
	396	char reserved[53];
	397	} __attribute__ ((packed));
	398
	399	struct dbfs_d204 {
	400	struct dbfs_d204_hdr hdr; /* 64 byte header */
	401	char buf[]; /* d204 buffer */
	402	} __attribute__ ((packed));
	403
2fcb3686	404	static int dbfs_d204_create(void data, void data_free_ptr, size_t *size)
57b28f66	405	{
57b28f66 MH	406	struct dbfs_d204 *d204;
57b28f66 MH	407	int rc, buf_size;
2fcb3686	408	void *base;
57b28f66	409
57b28f66	410	buf_size = PAGE_SIZE * (diag204_buf_pages + 1) + sizeof(d204->hdr);
dc8a5c99	411	base = vzalloc(buf_size);
2fcb3686 MH	412	if (!base)
2fcb3686 MH	413	return -ENOMEM;
2fcb3686 MH	414	d204 = page_align_ptr(base + sizeof(d204->hdr)) - sizeof(d204->hdr);
	415	rc = diag204_do_store(d204->buf, diag204_buf_pages);
	416	if (rc) {
	417	vfree(base);
	418	return rc;
57b28f66	419	}
57b28f66 MH	420	d204->hdr.version = DBFS_D204_HDR_VERSION;
	421	d204->hdr.len = PAGE_SIZE * diag204_buf_pages;
	422	d204->hdr.sc = diag204_store_sc;
2fcb3686 MH	423	*data = d204;
	424	*data_free_ptr = base;
	425	*size = d204->hdr.len + sizeof(struct dbfs_d204_hdr);
57b28f66 MH	426	return 0;
	427	}
	428
2fcb3686 MH	429	static struct hypfs_dbfs_file dbfs_file_d204 = {
	430	.name = "diag_204",
	431	.data_create = dbfs_d204_create,
	432	.data_free = vfree,
57b28f66 MH	433	};
57b28f66 MH	434
24bbb1fa MH	435	__init int hypfs_diag_init(void)
	436	{
	437	int rc;
	438
	439	if (diag204_probe()) {
f55495ba	440	pr_err("The hardware system does not support hypfs\n");
24bbb1fa MH	441	return -ENODATA;
24bbb1fa MH	442	}
f36108c4 GKH	443
	444	if (diag204_info_type == DIAG204_INFO_EXT)
	445	hypfs_dbfs_create_file(&dbfs_file_d204);
	446
3c8ebca0 MH	447	if (MACHINE_IS_LPAR) {
	448	rc = diag224_get_name_table();
	449	if (rc) {
	450	pr_err("The hardware system does not provide all "
	451	"functions required by hypfs\n");
	452	debugfs_remove(dbfs_d204_file);
	453	return rc;
	454	}
	455	}
	456	return 0;
24bbb1fa MH	457	}
24bbb1fa MH	458
1375fc1f	459	void hypfs_diag_exit(void)
24bbb1fa	460	{
57b28f66	461	debugfs_remove(dbfs_d204_file);
24bbb1fa MH	462	diag224_delete_name_table();
24bbb1fa MH	463	diag204_free_buffer();
2fcb3686	464	hypfs_dbfs_remove_file(&dbfs_file_d204);
24bbb1fa MH	465	}
	466
	467	/*
	468	* Functions to create the directory structure
	469	* *******************************************
	470	*/
	471
e334cf4f	472	static int hypfs_create_cpu_files(struct dentry cpus_dir, void cpu_info)
24bbb1fa MH	473	{
	474	struct dentry *cpu_dir;
	475	char buffer[TMP_SIZE];
	476	void *rc;
	477
	478	snprintf(buffer, TMP_SIZE, "%d", cpu_info__cpu_addr(diag204_info_type,
	479	cpu_info));
a118cfdf AV	480	cpu_dir = hypfs_mkdir(cpus_dir, buffer);
a118cfdf AV	481	rc = hypfs_create_u64(cpu_dir, "mgmtime",
24bbb1fa MH	482	cpu_info__acc_time(diag204_info_type, cpu_info) -
	483	cpu_info__lp_time(diag204_info_type, cpu_info));
	484	if (IS_ERR(rc))
	485	return PTR_ERR(rc);
a118cfdf	486	rc = hypfs_create_u64(cpu_dir, "cputime",
24bbb1fa MH	487	cpu_info__lp_time(diag204_info_type, cpu_info));
	488	if (IS_ERR(rc))
	489	return PTR_ERR(rc);
e65f30e0	490	if (diag204_info_type == DIAG204_INFO_EXT) {
a118cfdf	491	rc = hypfs_create_u64(cpu_dir, "onlinetime",
24bbb1fa MH	492	cpu_info__online_time(diag204_info_type,
	493	cpu_info));
	494	if (IS_ERR(rc))
	495	return PTR_ERR(rc);
	496	}
	497	diag224_idx2name(cpu_info__ctidx(diag204_info_type, cpu_info), buffer);
a118cfdf	498	rc = hypfs_create_str(cpu_dir, "type", buffer);
9fa6a659	499	return PTR_ERR_OR_ZERO(rc);
24bbb1fa MH	500	}
24bbb1fa MH	501
e334cf4f	502	static void hypfs_create_lpar_files(struct dentry systems_dir, void *part_hdr)
24bbb1fa MH	503	{
	504	struct dentry *cpus_dir;
	505	struct dentry *lpar_dir;
e65f30e0	506	char lpar_name[DIAG204_LPAR_NAME_LEN + 1];
24bbb1fa MH	507	void *cpu_info;
	508	int i;
	509
	510	part_hdr__part_name(diag204_info_type, part_hdr, lpar_name);
e65f30e0	511	lpar_name[DIAG204_LPAR_NAME_LEN] = 0;
a118cfdf	512	lpar_dir = hypfs_mkdir(systems_dir, lpar_name);
24bbb1fa MH	513	if (IS_ERR(lpar_dir))
24bbb1fa MH	514	return lpar_dir;
a118cfdf	515	cpus_dir = hypfs_mkdir(lpar_dir, "cpus");
24bbb1fa MH	516	if (IS_ERR(cpus_dir))
	517	return cpus_dir;
	518	cpu_info = part_hdr + part_hdr__size(diag204_info_type);
	519	for (i = 0; i < part_hdr__rcpus(diag204_info_type, part_hdr); i++) {
	520	int rc;
e334cf4f	521	rc = hypfs_create_cpu_files(cpus_dir, cpu_info);
24bbb1fa MH	522	if (rc)
	523	return ERR_PTR(rc);
	524	cpu_info += cpu_info__size(diag204_info_type);
	525	}
	526	return cpu_info;
	527	}
	528
e334cf4f	529	static int hypfs_create_phys_cpu_files(struct dentry cpus_dir, void cpu_info)
24bbb1fa MH	530	{
	531	struct dentry *cpu_dir;
	532	char buffer[TMP_SIZE];
	533	void *rc;
	534
	535	snprintf(buffer, TMP_SIZE, "%i", phys_cpu__cpu_addr(diag204_info_type,
	536	cpu_info));
a118cfdf	537	cpu_dir = hypfs_mkdir(cpus_dir, buffer);
24bbb1fa MH	538	if (IS_ERR(cpu_dir))
24bbb1fa MH	539	return PTR_ERR(cpu_dir);
a118cfdf	540	rc = hypfs_create_u64(cpu_dir, "mgmtime",
24bbb1fa MH	541	phys_cpu__mgm_time(diag204_info_type, cpu_info));
	542	if (IS_ERR(rc))
	543	return PTR_ERR(rc);
	544	diag224_idx2name(phys_cpu__ctidx(diag204_info_type, cpu_info), buffer);
a118cfdf	545	rc = hypfs_create_str(cpu_dir, "type", buffer);
9fa6a659	546	return PTR_ERR_OR_ZERO(rc);
24bbb1fa MH	547	}
24bbb1fa MH	548
e334cf4f	549	static void hypfs_create_phys_files(struct dentry parent_dir, void *phys_hdr)
24bbb1fa MH	550	{
	551	int i;
	552	void *cpu_info;
	553	struct dentry *cpus_dir;
	554
a118cfdf	555	cpus_dir = hypfs_mkdir(parent_dir, "cpus");
24bbb1fa MH	556	if (IS_ERR(cpus_dir))
	557	return cpus_dir;
	558	cpu_info = phys_hdr + phys_hdr__size(diag204_info_type);
	559	for (i = 0; i < phys_hdr__cpus(diag204_info_type, phys_hdr); i++) {
	560	int rc;
e334cf4f	561	rc = hypfs_create_phys_cpu_files(cpus_dir, cpu_info);
24bbb1fa MH	562	if (rc)
	563	return ERR_PTR(rc);
	564	cpu_info += phys_cpu__size(diag204_info_type);
	565	}
	566	return cpu_info;
	567	}
	568
e334cf4f	569	int hypfs_diag_create_files(struct dentry *root)
24bbb1fa MH	570	{
	571	struct dentry systems_dir, hyp_dir;
	572	void time_hdr, part_hdr;
	573	int i, rc;
	574	void buffer, ptr;
	575
	576	buffer = diag204_store();
	577	if (IS_ERR(buffer))
	578	return PTR_ERR(buffer);
	579
a118cfdf	580	systems_dir = hypfs_mkdir(root, "systems");
24bbb1fa MH	581	if (IS_ERR(systems_dir)) {
	582	rc = PTR_ERR(systems_dir);
	583	goto err_out;
	584	}
	585	time_hdr = (struct x_info_blk_hdr *)buffer;
	586	part_hdr = time_hdr + info_blk_hdr__size(diag204_info_type);
	587	for (i = 0; i < info_blk_hdr__npar(diag204_info_type, time_hdr); i++) {
e334cf4f	588	part_hdr = hypfs_create_lpar_files(systems_dir, part_hdr);
24bbb1fa MH	589	if (IS_ERR(part_hdr)) {
	590	rc = PTR_ERR(part_hdr);
	591	goto err_out;
	592	}
	593	}
e65f30e0 JF	594	if (info_blk_hdr__flags(diag204_info_type, time_hdr) &
e65f30e0 JF	595	DIAG204_LPAR_PHYS_FLG) {
e334cf4f	596	ptr = hypfs_create_phys_files(root, part_hdr);
24bbb1fa MH	597	if (IS_ERR(ptr)) {
	598	rc = PTR_ERR(ptr);
	599	goto err_out;
	600	}
	601	}
a118cfdf	602	hyp_dir = hypfs_mkdir(root, "hyp");
24bbb1fa MH	603	if (IS_ERR(hyp_dir)) {
	604	rc = PTR_ERR(hyp_dir);
	605	goto err_out;
	606	}
a118cfdf	607	ptr = hypfs_create_str(hyp_dir, "type", "LPAR Hypervisor");
24bbb1fa MH	608	if (IS_ERR(ptr)) {
	609	rc = PTR_ERR(ptr);
	610	goto err_out;
	611	}
	612	rc = 0;
	613
	614	err_out:
	615	return rc;
	616	}