fadump: Remove the phyp assisted dump code.

                   Hypervisor-Assisted Dump

                   ------------------------

                       November 2007

The goal of hypervisor-assisted dump is to enable the dump of

a crashed system, and to do so from a fully-reset system, and

to minimize the total elapsed time until the system is back

in production use.

As compared to kdump or other strategies, hypervisor-assisted

dump offers several strong, practical advantages:

-- Unlike kdump, the system has been reset, and loaded

   with a fresh copy of the kernel.  In particular,

   PCI and I/O devices have been reinitialized and are

   in a clean, consistent state.

-- As the dump is performed, the dumped memory becomes

   immediately available to the system for normal use.

-- After the dump is completed, no further reboots are

   required; the system will be fully usable, and running

   in its normal, production mode on its normal kernel.

The above can only be accomplished by coordination with,

and assistance from the hypervisor. The procedure is

as follows:

-- When a system crashes, the hypervisor will save

   the low 256MB of RAM to a previously registered

   save region. It will also save system state, system

   registers, and hardware PTE's.

-- After the low 256MB area has been saved, the

   hypervisor will reset PCI and other hardware state.

   It will *not* clear RAM. It will then launch the

   bootloader, as normal.

-- The freshly booted kernel will notice that there

   is a new node (ibm,dump-kernel) in the device tree,

   indicating that there is crash data available from

   a previous boot. It will boot into only 256MB of RAM,

   reserving the rest of system memory.

-- Userspace tools will parse /sys/kernel/release_region

   and read /proc/vmcore to obtain the contents of memory,

   which holds the previous crashed kernel. The userspace

   tools may copy this info to disk, or network, nas, san,

   iscsi, etc. as desired.

   For Example: the values in /sys/kernel/release-region

   would look something like this (address-range pairs).

   CPU:0x177fee000-0x10000: HPTE:0x177ffe020-0x1000: /

   DUMP:0x177fff020-0x10000000, 0x10000000-0x16F1D370A

-- As the userspace tools complete saving a portion of

   dump, they echo an offset and size to

   /sys/kernel/release_region to release the reserved

   memory back to general use.

   An example of this is:

     "echo 0x40000000 0x10000000 > /sys/kernel/release_region"

   which will release 256MB at the 1GB boundary.

Please note that the hypervisor-assisted dump feature

is only available on Power6-based systems with recent

firmware versions.

Implementation details:

----------------------

During boot, a check is made to see if firmware supports

this feature on this particular machine. If it does, then

we check to see if a active dump is waiting for us. If yes

then everything but 256 MB of RAM is reserved during early

boot. This area is released once we collect a dump from user

land scripts that are run. If there is dump data, then

the /sys/kernel/release_region file is created, and

the reserved memory is held.

If there is no waiting dump data, then only the highest

256MB of the ram is reserved as a scratch area. This area

is *not* released: this region will be kept permanently

reserved, so that it can act as a receptacle for a copy

of the low 256MB in the case a crash does occur. See,

however, "open issues" below, as to whether

such a reserved region is really needed.

Currently the dump will be copied from /proc/vmcore to a

a new file upon user intervention. The starting address

to be read and the range for each data point in provided

in /sys/kernel/release_region.

The tools to examine the dump will be same as the ones

used for kdump.

General notes:

--------------

Security: please note that there are potential security issues

with any sort of dump mechanism. In particular, plaintext

(unencrypted) data, and possibly passwords, may be present in

the dump data. Userspace tools must take adequate precautions to

preserve security.

Open issues/ToDo:

------------

 o The various code paths that tell the hypervisor that a crash

   occurred, vs. it simply being a normal reboot, should be

   reviewed, and possibly clarified/fixed.

 o Instead of using /sys/kernel, should there be a /sys/dump

   instead? There is a dump_subsys being created by the s390 code,

   perhaps the pseries code should use a similar layout as well.

 o Is reserving a 256MB region really required? The goal of

   reserving a 256MB scratch area is to make sure that no

   important crash data is clobbered when the hypervisor

   save low mem to the scratch area. But, if one could assure

   that nothing important is located in some 256MB area, then

   it would not need to be reserved. Something that can be

   improved in subsequent versions.

 o Still working the kdump team to integrate this with kdump,

   some work remains but this would not affect the current

   patches.

 o Still need to write a shell script, to copy the dump away.

   Currently I am parsing it manually.

	  The same kernel binary can be used as production kernel and dump

	  capture kernel.

config PHYP_DUMP

	bool "Hypervisor-assisted dump (EXPERIMENTAL)"

	depends on PPC_PSERIES && EXPERIMENTAL

	help

	  Hypervisor-assisted dump is meant to be a kdump replacement

	  offering robustness and speed not possible without system

	  hypervisor assistance.

	  If unsure, say "N"

config FA_DUMP

	bool "Firmware-assisted dump"

	depends on PPC64 && PPC_RTAS && CRASH_DUMP

/*

 * Hypervisor-assisted dump

 *

 * Linas Vepstas, Manish Ahuja 2008

 * Copyright 2008 IBM Corp.

 *

 *      This program is free software; you can redistribute it and/or

 *      modify it under the terms of the GNU General Public License

 *      as published by the Free Software Foundation; either version

 *      2 of the License, or (at your option) any later version.

 */

#ifndef _PPC64_PHYP_DUMP_H

#define _PPC64_PHYP_DUMP_H

#ifdef CONFIG_PHYP_DUMP

/* The RMR region will be saved for later dumping

 * whenever the kernel crashes. Set this to 256MB. */

#define PHYP_DUMP_RMR_START 0x0

#define PHYP_DUMP_RMR_END   (1UL<<28)

struct phyp_dump {

	/* Memory that is reserved during very early boot. */

	unsigned long init_reserve_start;

	unsigned long init_reserve_size;

	/* cmd line options during boot */

	unsigned long reserve_bootvar;

	unsigned long phyp_dump_at_boot;

	/* Check status during boot if dump supported, active & present*/

	unsigned long phyp_dump_configured;

	unsigned long phyp_dump_is_active;

	/* store cpu & hpte size */

	unsigned long cpu_state_size;

	unsigned long hpte_region_size;

	/* previous scratch area values */

	unsigned long reserved_scratch_addr;

	unsigned long reserved_scratch_size;

};

extern struct phyp_dump *phyp_dump_info;

int early_init_dt_scan_phyp_dump(unsigned long node,

		const char *uname, int depth, void *data);

#endif /* CONFIG_PHYP_DUMP */

#endif /* _PPC64_PHYP_DUMP_H */

#include <asm/machdep.h>

#include <asm/pSeries_reconfig.h>

#include <asm/pci-bridge.h>

#include <asm/phyp_dump.h>

#include <asm/kexec.h>

#include <asm/opal.h>

#include <asm/fadump.h>

	}

}

#ifdef CONFIG_PHYP_DUMP

/**

 * phyp_dump_calculate_reserve_size() - reserve variable boot area 5% or arg

 *

 * Function to find the largest size we need to reserve

 * during early boot process.

 *

 * It either looks for boot param and returns that OR

 * returns larger of 256 or 5% rounded down to multiples of 256MB.

 *

 */

static inline unsigned long phyp_dump_calculate_reserve_size(void)

{

	unsigned long tmp;

	if (phyp_dump_info->reserve_bootvar)

		return phyp_dump_info->reserve_bootvar;

	/* divide by 20 to get 5% of value */

	tmp = memblock_end_of_DRAM();

	do_div(tmp, 20);

	/* round it down in multiples of 256 */

	tmp = tmp & ~0x0FFFFFFFUL;

	return (tmp > PHYP_DUMP_RMR_END ? tmp : PHYP_DUMP_RMR_END);

}

/**

 * phyp_dump_reserve_mem() - reserve all not-yet-dumped mmemory

 *

 * This routine may reserve memory regions in the kernel only

 * if the system is supported and a dump was taken in last

 * boot instance or if the hardware is supported and the

 * scratch area needs to be setup. In other instances it returns

 * without reserving anything. The memory in case of dump being

 * active is freed when the dump is collected (by userland tools).

 */

static void __init phyp_dump_reserve_mem(void)

{

	unsigned long base, size;

	unsigned long variable_reserve_size;

	if (!phyp_dump_info->phyp_dump_configured) {

		printk(KERN_ERR "Phyp-dump not supported on this hardware\n");

		return;

	}

	if (!phyp_dump_info->phyp_dump_at_boot) {

		printk(KERN_INFO "Phyp-dump disabled at boot time\n");

		return;

	}

	variable_reserve_size = phyp_dump_calculate_reserve_size();

	if (phyp_dump_info->phyp_dump_is_active) {

		/* Reserve *everything* above RMR.Area freed by userland tools*/

		base = variable_reserve_size;

		size = memblock_end_of_DRAM() - base;

		/* XXX crashed_ram_end is wrong, since it may be beyond

		 * the memory_limit, it will need to be adjusted. */

		memblock_reserve(base, size);

		phyp_dump_info->init_reserve_start = base;

		phyp_dump_info->init_reserve_size = size;

	} else {

		size = phyp_dump_info->cpu_state_size +

			phyp_dump_info->hpte_region_size +

			variable_reserve_size;

		base = memblock_end_of_DRAM() - size;

		memblock_reserve(base, size);

		phyp_dump_info->init_reserve_start = base;

		phyp_dump_info->init_reserve_size = size;

	}

}

#else

static inline void __init phyp_dump_reserve_mem(void) {}

#endif /* CONFIG_PHYP_DUMP  && CONFIG_PPC_RTAS */

void __init early_init_devtree(void *params)

{

	phys_addr_t limit;

	of_scan_flat_dt(early_init_dt_scan_opal, NULL);

#endif

#ifdef CONFIG_PHYP_DUMP

	/* scan tree to see if dump occurred during last boot */

	of_scan_flat_dt(early_init_dt_scan_phyp_dump, NULL);

#endif

#ifdef CONFIG_FA_DUMP

	/* scan tree to see if dump is active during last boot */

	of_scan_flat_dt(early_init_dt_scan_fw_dump, NULL);

#endif

		reserve_crashkernel();

	early_reserve_mem();

	phyp_dump_reserve_mem();

	/*

	 * Ensure that total memory size is page-aligned, because otherwise

obj-$(CONFIG_HVC_CONSOLE)	+= hvconsole.o

obj-$(CONFIG_HVCS)		+= hvcserver.o

obj-$(CONFIG_HCALL_STATS)	+= hvCall_inst.o

obj-$(CONFIG_PHYP_DUMP)		+= phyp_dump.o

obj-$(CONFIG_CMM)		+= cmm.o

obj-$(CONFIG_DTL)		+= dtl.o

obj-$(CONFIG_IO_EVENT_IRQ)	+= io_event_irq.o