Eric Lee / smarc-fsl-linux-kernel

Commit a3dd3323058d281abd584b15ad4c5b65064d7a61

Authored by WANG Cong 2012-01-13 09:20:11 +0800

Committed by Linus Torvalds 2012-01-13 12:13:11 +0800

Exists in master and in 38 other branches

kexec: remove KMSG_DUMP_KEXEC

KMSG_DUMP_KEXEC is useless because we already save kernel messages inside
/proc/vmcore, and it is unsafe to allow modules to do other stuffs in a
crash dump scenario.

[akpm@linux-foundation.org: fix powerpc build]
Signed-off-by: WANG Cong <xiyou.wangcong@gmail.com>
Reported-by: Vivek Goyal <vgoyal@redhat.com>
Acked-by: Vivek Goyal <vgoyal@redhat.com>
Acked-by: Jarod Wilson <jarod@redhat.com>
Cc: "Eric W. Biederman" <ebiederm@xmission.com>
Cc: KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

Showing 5 changed files with 2 additions and 9 deletions Inline Diff

arch/powerpc/platforms/pseries/nvram.c
drivers/char/ramoops.c
drivers/mtd/mtdoops.c
include/linux/kmsg_dump.h
kernel/kexec.c

arch/powerpc/platforms/pseries/nvram.c

Diff comments View file @ a3dd332

 /*
  *  c 2001 PPC 64 Team, 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.
  *
  * /dev/nvram driver for PPC64
  *
  * This perhaps should live in drivers/char
  */
 #include <linux/types.h>
 #include <linux/errno.h>
 #include <linux/init.h>
 #include <linux/spinlock.h>
 #include <linux/slab.h>
 #include <linux/kmsg_dump.h>
 #include <linux/ctype.h>
 #include <linux/zlib.h>
 #include <asm/uaccess.h>
 #include <asm/nvram.h>
 #include <asm/rtas.h>
 #include <asm/prom.h>
 #include <asm/machdep.h>
 /* Max bytes to read/write in one go */
 #define NVRW_CNT 0x20
 static unsigned int nvram_size;
 static int nvram_fetch, nvram_store;
 static char nvram_buf[NVRW_CNT];	/* assume this is in the first 4GB */
 static DEFINE_SPINLOCK(nvram_lock);
 struct err_log_info {
 	int error_type;
 	unsigned int seq_num;
 };
 struct nvram_os_partition {
 	const char *name;
 	int req_size;	/* desired size, in bytes */
 	int min_size;	/* minimum acceptable size (0 means req_size) */
 	long size;	/* size of data portion (excluding err_log_info) */
 	long index;	/* offset of data portion of partition */
 };
 static struct nvram_os_partition rtas_log_partition = {
 	.name = "ibm,rtas-log",
 	.req_size = 2079,
 	.min_size = 1055,
 	.index = -1
 };
 static struct nvram_os_partition oops_log_partition = {
 	.name = "lnx,oops-log",
 	.req_size = 4000,
 	.min_size = 2000,
 	.index = -1
 };
 static const char *pseries_nvram_os_partitions[] = {
 	"ibm,rtas-log",
 	"lnx,oops-log",
 	NULL
 };
 static void oops_to_nvram(struct kmsg_dumper *dumper,
 		enum kmsg_dump_reason reason,
 		const char *old_msgs, unsigned long old_len,
 		const char *new_msgs, unsigned long new_len);
 static struct kmsg_dumper nvram_kmsg_dumper = {
 	.dump = oops_to_nvram
 };
 /* See clobbering_unread_rtas_event() */
 #define NVRAM_RTAS_READ_TIMEOUT 5		/* seconds */
 static unsigned long last_unread_rtas_event;	/* timestamp */
 /*
  * For capturing and compressing an oops or panic report...
  * big_oops_buf[] holds the uncompressed text we're capturing.
  *
  * oops_buf[] holds the compressed text, preceded by a prefix.
  * The prefix is just a u16 holding the length of the compressed* text.
  * (*Or uncompressed, if compression fails.)  oops_buf[] gets written
  * to NVRAM.
  *
  * oops_len points to the prefix.  oops_data points to the compressed text.
  *
  * +- oops_buf
  * |		+- oops_data
  * v		v
  * +------------+-----------------------------------------------+
  * | length	| text                                          |
  * | (2 bytes)	| (oops_data_sz bytes)                          |
  * +------------+-----------------------------------------------+
  * ^
  * +- oops_len
  *
  * We preallocate these buffers during init to avoid kmalloc during oops/panic.
  */
 static size_t big_oops_buf_sz;
 static char *big_oops_buf, *oops_buf;
 static u16 *oops_len;
 static char *oops_data;
 static size_t oops_data_sz;
 /* Compression parameters */
 #define COMPR_LEVEL 6
 #define WINDOW_BITS 12
 #define MEM_LEVEL 4
 static struct z_stream_s stream;
 static ssize_t pSeries_nvram_read(char *buf, size_t count, loff_t *index)
 {
 	unsigned int i;
 	unsigned long len;
 	int done;
 	unsigned long flags;
 	char *p = buf;
 	if (nvram_size == 0 || nvram_fetch == RTAS_UNKNOWN_SERVICE)
 		return -ENODEV;
 	if (*index >= nvram_size)
 		return 0;
 	i = *index;
 	if (i + count > nvram_size)
 		count = nvram_size - i;
 	spin_lock_irqsave(&nvram_lock, flags);
 	for (; count != 0; count -= len) {
 		len = count;
 		if (len > NVRW_CNT)
 			len = NVRW_CNT;
 		if ((rtas_call(nvram_fetch, 3, 2, &done, i, __pa(nvram_buf),
 			       len) != 0) || len != done) {
 			spin_unlock_irqrestore(&nvram_lock, flags);
 			return -EIO;
 		}
 		memcpy(p, nvram_buf, len);
 		p += len;
 		i += len;
 	}
 	spin_unlock_irqrestore(&nvram_lock, flags);
 	*index = i;
 	return p - buf;
 }
 static ssize_t pSeries_nvram_write(char *buf, size_t count, loff_t *index)
 {
 	unsigned int i;
 	unsigned long len;
 	int done;
 	unsigned long flags;
 	const char *p = buf;
 	if (nvram_size == 0 || nvram_store == RTAS_UNKNOWN_SERVICE)
 		return -ENODEV;
 	if (*index >= nvram_size)
 		return 0;
 	i = *index;
 	if (i + count > nvram_size)
 		count = nvram_size - i;
 	spin_lock_irqsave(&nvram_lock, flags);
 	for (; count != 0; count -= len) {
 		len = count;
 		if (len > NVRW_CNT)
 			len = NVRW_CNT;
 		memcpy(nvram_buf, p, len);
 		if ((rtas_call(nvram_store, 3, 2, &done, i, __pa(nvram_buf),
 			       len) != 0) || len != done) {
 			spin_unlock_irqrestore(&nvram_lock, flags);
 			return -EIO;
 		}
 		p += len;
 		i += len;
 	}
 	spin_unlock_irqrestore(&nvram_lock, flags);
 	*index = i;
 	return p - buf;
 }
 static ssize_t pSeries_nvram_get_size(void)
 {
 	return nvram_size ? nvram_size : -ENODEV;
 }
 /* nvram_write_os_partition, nvram_write_error_log
  *
  * We need to buffer the error logs into nvram to ensure that we have
  * the failure information to decode.  If we have a severe error there
  * is no way to guarantee that the OS or the machine is in a state to
  * get back to user land and write the error to disk.  For example if
  * the SCSI device driver causes a Machine Check by writing to a bad
  * IO address, there is no way of guaranteeing that the device driver
  * is in any state that is would also be able to write the error data
  * captured to disk, thus we buffer it in NVRAM for analysis on the
  * next boot.
  *
  * In NVRAM the partition containing the error log buffer will looks like:
  * Header (in bytes):
  * +-----------+----------+--------+------------+------------------+
  * | signature | checksum | length | name       | data             |
  * |0          |1         |2      3|4         15|16        length-1|
  * +-----------+----------+--------+------------+------------------+
  *
  * The 'data' section would look like (in bytes):
  * +--------------+------------+-----------------------------------+
  * | event_logged | sequence # | error log                         |
  * |0            3|4          7|8                  error_log_size-1|
  * +--------------+------------+-----------------------------------+
  *
  * event_logged: 0 if event has not been logged to syslog, 1 if it has
  * sequence #: The unique sequence # for each event. (until it wraps)
  * error log: The error log from event_scan
  */
 int nvram_write_os_partition(struct nvram_os_partition *part, char * buff,
 		int length, unsigned int err_type, unsigned int error_log_cnt)
 {
 	int rc;
 	loff_t tmp_index;
 	struct err_log_info info;
 	if (part->index == -1) {
 		return -ESPIPE;
 	}
 	if (length > part->size) {
 		length = part->size;
 	}
 	info.error_type = err_type;
 	info.seq_num = error_log_cnt;
 	tmp_index = part->index;
 	rc = ppc_md.nvram_write((char *)&info, sizeof(struct err_log_info), &tmp_index);
 	if (rc <= 0) {
 		pr_err("%s: Failed nvram_write (%d)\n", __FUNCTION__, rc);
 		return rc;
 	}
 	rc = ppc_md.nvram_write(buff, length, &tmp_index);
 	if (rc <= 0) {
 		pr_err("%s: Failed nvram_write (%d)\n", __FUNCTION__, rc);
 		return rc;
 	}
 	return 0;
 }
 int nvram_write_error_log(char * buff, int length,
                           unsigned int err_type, unsigned int error_log_cnt)
 {
 	int rc = nvram_write_os_partition(&rtas_log_partition, buff, length,
 						err_type, error_log_cnt);
 	if (!rc)
 		last_unread_rtas_event = get_seconds();
 	return rc;
 }
 /* nvram_read_error_log
  *
  * Reads nvram for error log for at most 'length'
  */
 int nvram_read_error_log(char * buff, int length,
                          unsigned int * err_type, unsigned int * error_log_cnt)
 {
 	int rc;
 	loff_t tmp_index;
 	struct err_log_info info;
 	if (rtas_log_partition.index == -1)
 		return -1;
 	if (length > rtas_log_partition.size)
 		length = rtas_log_partition.size;
 	tmp_index = rtas_log_partition.index;
 	rc = ppc_md.nvram_read((char *)&info, sizeof(struct err_log_info), &tmp_index);
 	if (rc <= 0) {
 		printk(KERN_ERR "nvram_read_error_log: Failed nvram_read (%d)\n", rc);
 		return rc;
 	}
 	rc = ppc_md.nvram_read(buff, length, &tmp_index);
 	if (rc <= 0) {
 		printk(KERN_ERR "nvram_read_error_log: Failed nvram_read (%d)\n", rc);
 		return rc;
 	}
 	*error_log_cnt = info.seq_num;
 	*err_type = info.error_type;
 	return 0;
 }
 /* This doesn't actually zero anything, but it sets the event_logged
  * word to tell that this event is safely in syslog.
  */
 int nvram_clear_error_log(void)
 {
 	loff_t tmp_index;
 	int clear_word = ERR_FLAG_ALREADY_LOGGED;
 	int rc;
 	if (rtas_log_partition.index == -1)
 		return -1;
 	tmp_index = rtas_log_partition.index;
 	rc = ppc_md.nvram_write((char *)&clear_word, sizeof(int), &tmp_index);
 	if (rc <= 0) {
 		printk(KERN_ERR "nvram_clear_error_log: Failed nvram_write (%d)\n", rc);
 		return rc;
 	}
 	last_unread_rtas_event = 0;
 	return 0;
 }
 /* pseries_nvram_init_os_partition
  *
  * This sets up a partition with an "OS" signature.
  *
  * The general strategy is the following:
  * 1.) If a partition with the indicated name already exists...
  *	- If it's large enough, use it.
  *	- Otherwise, recycle it and keep going.
  * 2.) Search for a free partition that is large enough.
  * 3.) If there's not a free partition large enough, recycle any obsolete
  * OS partitions and try again.
  * 4.) Will first try getting a chunk that will satisfy the requested size.
  * 5.) If a chunk of the requested size cannot be allocated, then try finding
  * a chunk that will satisfy the minum needed.
  *
  * Returns 0 on success, else -1.
  */
 static int __init pseries_nvram_init_os_partition(struct nvram_os_partition
 									*part)
 {
 	loff_t p;
 	int size;
 	/* Scan nvram for partitions */
 	nvram_scan_partitions();
 	/* Look for ours */
 	p = nvram_find_partition(part->name, NVRAM_SIG_OS, &size);
 	/* Found one but too small, remove it */
 	if (p && size < part->min_size) {
 		pr_info("nvram: Found too small %s partition,"
 					" removing it...\n", part->name);
 		nvram_remove_partition(part->name, NVRAM_SIG_OS, NULL);
 		p = 0;
 	}
 	/* Create one if we didn't find */
 	if (!p) {
 		p = nvram_create_partition(part->name, NVRAM_SIG_OS,
 					part->req_size, part->min_size);
 		if (p == -ENOSPC) {
 			pr_info("nvram: No room to create %s partition, "
 				"deleting any obsolete OS partitions...\n",
 				part->name);
 			nvram_remove_partition(NULL, NVRAM_SIG_OS,
 						pseries_nvram_os_partitions);
 			p = nvram_create_partition(part->name, NVRAM_SIG_OS,
 					part->req_size, part->min_size);
 		}
 	}
 	if (p <= 0) {
 		pr_err("nvram: Failed to find or create %s"
 		       " partition, err %d\n", part->name, (int)p);
 		return -1;
 	}
 	part->index = p;
 	part->size = nvram_get_partition_size(p) - sizeof(struct err_log_info);
 	return 0;
 }
 static void __init nvram_init_oops_partition(int rtas_partition_exists)
 {
 	int rc;
 	rc = pseries_nvram_init_os_partition(&oops_log_partition);
 	if (rc != 0) {
 		if (!rtas_partition_exists)
 			return;
 		pr_notice("nvram: Using %s partition to log both"
 			" RTAS errors and oops/panic reports\n",
 			rtas_log_partition.name);
 		memcpy(&oops_log_partition, &rtas_log_partition,
 						sizeof(rtas_log_partition));
 	}
 	oops_buf = kmalloc(oops_log_partition.size, GFP_KERNEL);
 	if (!oops_buf) {
 		pr_err("nvram: No memory for %s partition\n",
 						oops_log_partition.name);
 		return;
 	}
 	oops_len = (u16*) oops_buf;
 	oops_data = oops_buf + sizeof(u16);
 	oops_data_sz = oops_log_partition.size - sizeof(u16);
 	/*
 	 * Figure compression (preceded by elimination of each line's <n>
 	 * severity prefix) will reduce the oops/panic report to at most
 	 * 45% of its original size.
 	 */
 	big_oops_buf_sz = (oops_data_sz * 100) / 45;
 	big_oops_buf = kmalloc(big_oops_buf_sz, GFP_KERNEL);
 	if (big_oops_buf) {
 		stream.workspace = kmalloc(zlib_deflate_workspacesize(
 				WINDOW_BITS, MEM_LEVEL), GFP_KERNEL);
 		if (!stream.workspace) {
 			pr_err("nvram: No memory for compression workspace; "
 				"skipping compression of %s partition data\n",
 				oops_log_partition.name);
 			kfree(big_oops_buf);
 			big_oops_buf = NULL;
 		}
 	} else {
 		pr_err("No memory for uncompressed %s data; "
 			"skipping compression\n", oops_log_partition.name);
 		stream.workspace = NULL;
 	}
 	rc = kmsg_dump_register(&nvram_kmsg_dumper);
 	if (rc != 0) {
 		pr_err("nvram: kmsg_dump_register() failed; returned %d\n", rc);
 		kfree(oops_buf);
 		kfree(big_oops_buf);
 		kfree(stream.workspace);
 	}
 }
 static int __init pseries_nvram_init_log_partitions(void)
 {
 	int rc;
 	rc = pseries_nvram_init_os_partition(&rtas_log_partition);
 	nvram_init_oops_partition(rc == 0);
 	return 0;
 }
 machine_arch_initcall(pseries, pseries_nvram_init_log_partitions);
 int __init pSeries_nvram_init(void)
 {
 	struct device_node *nvram;
 	const unsigned int *nbytes_p;
 	unsigned int proplen;
 	nvram = of_find_node_by_type(NULL, "nvram");
 	if (nvram == NULL)
 		return -ENODEV;
 	nbytes_p = of_get_property(nvram, "#bytes", &proplen);
 	if (nbytes_p == NULL || proplen != sizeof(unsigned int)) {
 		of_node_put(nvram);
 		return -EIO;
 	}
 	nvram_size = *nbytes_p;
 	nvram_fetch = rtas_token("nvram-fetch");
 	nvram_store = rtas_token("nvram-store");
 	printk(KERN_INFO "PPC64 nvram contains %d bytes\n", nvram_size);
 	of_node_put(nvram);
 	ppc_md.nvram_read	= pSeries_nvram_read;
 	ppc_md.nvram_write	= pSeries_nvram_write;
 	ppc_md.nvram_size	= pSeries_nvram_get_size;
 	return 0;
 }
 /*
  * Try to capture the last capture_len bytes of the printk buffer.  Return
  * the amount actually captured.
  */
 static size_t capture_last_msgs(const char *old_msgs, size_t old_len,
 				const char *new_msgs, size_t new_len,
 				char *captured, size_t capture_len)
 {
 	if (new_len >= capture_len) {
 		memcpy(captured, new_msgs + (new_len - capture_len),
 								capture_len);
 		return capture_len;
 	} else {
 		/* Grab the end of old_msgs. */
 		size_t old_tail_len = min(old_len, capture_len - new_len);
 		memcpy(captured, old_msgs + (old_len - old_tail_len),
 								old_tail_len);
 		memcpy(captured + old_tail_len, new_msgs, new_len);
 		return old_tail_len + new_len;
 	}
 }
 /*
  * Are we using the ibm,rtas-log for oops/panic reports?  And if so,
  * would logging this oops/panic overwrite an RTAS event that rtas_errd
  * hasn't had a chance to read and process?  Return 1 if so, else 0.
  *
  * We assume that if rtas_errd hasn't read the RTAS event in
  * NVRAM_RTAS_READ_TIMEOUT seconds, it's probably not going to.
  */
 static int clobbering_unread_rtas_event(void)
 {
 	return (oops_log_partition.index == rtas_log_partition.index
 		&& last_unread_rtas_event
 		&& get_seconds() - last_unread_rtas_event <=
 						NVRAM_RTAS_READ_TIMEOUT);
 }
 /* Squeeze out each line's <n> severity prefix. */
 static size_t elide_severities(char *buf, size_t len)
 {
 	char *in, *out, *buf_end = buf + len;
 	/* Assume a <n> at the very beginning marks the start of a line. */
 	int newline = 1;
 	in = out = buf;
 	while (in < buf_end) {
 		if (newline && in+3 <= buf_end &&
 				*in == '<' && isdigit(in[1]) && in[2] == '>') {
 			in += 3;
 			newline = 0;
 		} else {
 			newline = (*in == '\n');
 			*out++ = *in++;
 		}
 	}
 	return out - buf;
 }
 /* Derived from logfs_compress() */
 static int nvram_compress(const void *in, void *out, size_t inlen,
 							size_t outlen)
 {
 	int err, ret;
 	ret = -EIO;
 	err = zlib_deflateInit2(&stream, COMPR_LEVEL, Z_DEFLATED, WINDOW_BITS,
 						MEM_LEVEL, Z_DEFAULT_STRATEGY);
 	if (err != Z_OK)
 		goto error;
 	stream.next_in = in;
 	stream.avail_in = inlen;
 	stream.total_in = 0;
 	stream.next_out = out;
 	stream.avail_out = outlen;
 	stream.total_out = 0;
 	err = zlib_deflate(&stream, Z_FINISH);
 	if (err != Z_STREAM_END)
 		goto error;
 	err = zlib_deflateEnd(&stream);
 	if (err != Z_OK)
 		goto error;
 	if (stream.total_out >= stream.total_in)
 		goto error;
 	ret = stream.total_out;
 error:
 	return ret;
 }
 /* Compress the text from big_oops_buf into oops_buf. */
 static int zip_oops(size_t text_len)
 {
 	int zipped_len = nvram_compress(big_oops_buf, oops_data, text_len,
 								oops_data_sz);
 	if (zipped_len < 0) {
 		pr_err("nvram: compression failed; returned %d\n", zipped_len);
 		pr_err("nvram: logging uncompressed oops/panic report\n");
 		return -1;
 	}
 	*oops_len = (u16) zipped_len;
 	return 0;
 }
 /*
  * This is our kmsg_dump callback, called after an oops or panic report
  * has been written to the printk buffer.  We want to capture as much
  * of the printk buffer as possible.  First, capture as much as we can
  * that we think will compress sufficiently to fit in the lnx,oops-log
  * partition.  If that's too much, go back and capture uncompressed text.
  */
 static void oops_to_nvram(struct kmsg_dumper *dumper,
 		enum kmsg_dump_reason reason,
 		const char *old_msgs, unsigned long old_len,
 		const char *new_msgs, unsigned long new_len)
 {
 	static unsigned int oops_count = 0;
 	static bool panicking = false;
 	static DEFINE_SPINLOCK(lock);
 	unsigned long flags;
 	size_t text_len;
 	unsigned int err_type = ERR_TYPE_KERNEL_PANIC_GZ;
 	int rc = -1;
 	switch (reason) {
 	case KMSG_DUMP_RESTART:
 	case KMSG_DUMP_HALT:
 	case KMSG_DUMP_POWEROFF:
 		/* These are almost always orderly shutdowns. */
 		return;
 	case KMSG_DUMP_OOPS:
-	case KMSG_DUMP_KEXEC:
 		break;
 	case KMSG_DUMP_PANIC:
 		panicking = true;
 		break;
 	case KMSG_DUMP_EMERG:
 		if (panicking)
 			/* Panic report already captured. */
 			return;
 		break;
 	default:
 		pr_err("%s: ignoring unrecognized KMSG_DUMP_* reason %d\n",
 						__FUNCTION__, (int) reason);
 		return;
 	}
 	if (clobbering_unread_rtas_event())
 		return;
 	if (!spin_trylock_irqsave(&lock, flags))
 		return;
 	if (big_oops_buf) {
 		text_len = capture_last_msgs(old_msgs, old_len,
 			new_msgs, new_len, big_oops_buf, big_oops_buf_sz);
 		text_len = elide_severities(big_oops_buf, text_len);
 		rc = zip_oops(text_len);
 	}
 	if (rc != 0) {
 		text_len = capture_last_msgs(old_msgs, old_len,
 				new_msgs, new_len, oops_data, oops_data_sz);
 		err_type = ERR_TYPE_KERNEL_PANIC;
 		*oops_len = (u16) text_len;
 	}
 	(void) nvram_write_os_partition(&oops_log_partition, oops_buf,
 		(int) (sizeof(*oops_len) + *oops_len), err_type, ++oops_count);
 	spin_unlock_irqrestore(&lock, flags);
 }

drivers/char/ramoops.c

Diff comments View file @ a3dd332

 /*
  * RAM Oops/Panic logger
  *
  * Copyright (C) 2010 Marco Stornelli <marco.stornelli@gmail.com>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * version 2 as published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  * 02110-1301 USA
  *
  */
 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 #include <linux/kernel.h>
 #include <linux/err.h>
 #include <linux/module.h>
 #include <linux/kmsg_dump.h>
 #include <linux/time.h>
 #include <linux/err.h>
 #include <linux/io.h>
 #include <linux/ioport.h>
 #include <linux/platform_device.h>
 #include <linux/slab.h>
 #include <linux/ramoops.h>
 #define RAMOOPS_KERNMSG_HDR "===="
 #define MIN_MEM_SIZE 4096UL
 static ulong record_size = MIN_MEM_SIZE;
 module_param(record_size, ulong, 0400);
 MODULE_PARM_DESC(record_size,
 		"size of each dump done on oops/panic");
 static ulong mem_address;
 module_param(mem_address, ulong, 0400);
 MODULE_PARM_DESC(mem_address,
 		"start of reserved RAM used to store oops/panic logs");
 static ulong mem_size;
 module_param(mem_size, ulong, 0400);
 MODULE_PARM_DESC(mem_size,
 		"size of reserved RAM used to store oops/panic logs");
 static int dump_oops = 1;
 module_param(dump_oops, int, 0600);
 MODULE_PARM_DESC(dump_oops,
 		"set to 1 to dump oopses, 0 to only dump panics (default 1)");
 static struct ramoops_context {
 	struct kmsg_dumper dump;
 	void *virt_addr;
 	phys_addr_t phys_addr;
 	unsigned long size;
 	unsigned long record_size;
 	int dump_oops;
 	int count;
 	int max_count;
 } oops_cxt;
 static struct platform_device *dummy;
 static struct ramoops_platform_data *dummy_data;
 static void ramoops_do_dump(struct kmsg_dumper *dumper,
 		enum kmsg_dump_reason reason, const char *s1, unsigned long l1,
 		const char *s2, unsigned long l2)
 {
 	struct ramoops_context *cxt = container_of(dumper,
 			struct ramoops_context, dump);
 	unsigned long s1_start, s2_start;
 	unsigned long l1_cpy, l2_cpy;
 	int res, hdr_size;
 	char *buf, *buf_orig;
 	struct timeval timestamp;
 	if (reason != KMSG_DUMP_OOPS &&
-	    reason != KMSG_DUMP_PANIC &&
+	    reason != KMSG_DUMP_PANIC)
-	    reason != KMSG_DUMP_KEXEC)
 		return;
 	/* Only dump oopses if dump_oops is set */
 	if (reason == KMSG_DUMP_OOPS && !cxt->dump_oops)
 		return;
 	buf = cxt->virt_addr + (cxt->count * cxt->record_size);
 	buf_orig = buf;
 	memset(buf, '\0', cxt->record_size);
 	res = sprintf(buf, "%s", RAMOOPS_KERNMSG_HDR);
 	buf += res;
 	do_gettimeofday(&timestamp);
 	res = sprintf(buf, "%lu.%lu\n", (long)timestamp.tv_sec, (long)timestamp.tv_usec);
 	buf += res;
 	hdr_size = buf - buf_orig;
 	l2_cpy = min(l2, cxt->record_size - hdr_size);
 	l1_cpy = min(l1, cxt->record_size - hdr_size - l2_cpy);
 	s2_start = l2 - l2_cpy;
 	s1_start = l1 - l1_cpy;
 	memcpy(buf, s1 + s1_start, l1_cpy);
 	memcpy(buf + l1_cpy, s2 + s2_start, l2_cpy);
 	cxt->count = (cxt->count + 1) % cxt->max_count;
 }
 static int __init ramoops_probe(struct platform_device *pdev)
 {
 	struct ramoops_platform_data *pdata = pdev->dev.platform_data;
 	struct ramoops_context *cxt = &oops_cxt;
 	int err = -EINVAL;
 	if (!pdata->mem_size || !pdata->record_size) {
 		pr_err("The memory size and the record size must be "
 			"non-zero\n");
 		goto fail3;
 	}
 	rounddown_pow_of_two(pdata->mem_size);
 	rounddown_pow_of_two(pdata->record_size);
 	/* Check for the minimum memory size */
 	if (pdata->mem_size < MIN_MEM_SIZE &&
 			pdata->record_size < MIN_MEM_SIZE) {
 		pr_err("memory size too small, minium is %lu\n", MIN_MEM_SIZE);
 		goto fail3;
 	}
 	if (pdata->mem_size < pdata->record_size) {
 		pr_err("The memory size must be larger than the "
 			"records size\n");
 		goto fail3;
 	}
 	cxt->max_count = pdata->mem_size / pdata->record_size;
 	cxt->count = 0;
 	cxt->size = pdata->mem_size;
 	cxt->phys_addr = pdata->mem_address;
 	cxt->record_size = pdata->record_size;
 	cxt->dump_oops = pdata->dump_oops;
 	/*
 	 * Update the module parameter variables as well so they are visible
 	 * through /sys/module/ramoops/parameters/
 	 */
 	mem_size = pdata->mem_size;
 	mem_address = pdata->mem_address;
 	record_size = pdata->record_size;
 	dump_oops = pdata->dump_oops;
 	if (!request_mem_region(cxt->phys_addr, cxt->size, "ramoops")) {
 		pr_err("request mem region failed\n");
 		err = -EINVAL;
 		goto fail3;
 	}
 	cxt->virt_addr = ioremap(cxt->phys_addr,  cxt->size);
 	if (!cxt->virt_addr) {
 		pr_err("ioremap failed\n");
 		goto fail2;
 	}
 	cxt->dump.dump = ramoops_do_dump;
 	err = kmsg_dump_register(&cxt->dump);
 	if (err) {
 		pr_err("registering kmsg dumper failed\n");
 		goto fail1;
 	}
 	return 0;
 fail1:
 	iounmap(cxt->virt_addr);
 fail2:
 	release_mem_region(cxt->phys_addr, cxt->size);
 fail3:
 	return err;
 }
 static int __exit ramoops_remove(struct platform_device *pdev)
 {
 	struct ramoops_context *cxt = &oops_cxt;
 	if (kmsg_dump_unregister(&cxt->dump) < 0)
 		pr_warn("could not unregister kmsg_dumper\n");
 	iounmap(cxt->virt_addr);
 	release_mem_region(cxt->phys_addr, cxt->size);
 	return 0;
 }
 static struct platform_driver ramoops_driver = {
 	.remove		= __exit_p(ramoops_remove),
 	.driver		= {
 		.name	= "ramoops",
 		.owner	= THIS_MODULE,
 	},
 };
 static int __init ramoops_init(void)
 {
 	int ret;
 	ret = platform_driver_probe(&ramoops_driver, ramoops_probe);
 	if (ret == -ENODEV) {
 		/*
 		 * If we didn't find a platform device, we use module parameters
 		 * building platform data on the fly.
 		 */
 		pr_info("platform device not found, using module parameters\n");
 		dummy_data = kzalloc(sizeof(struct ramoops_platform_data),
 				     GFP_KERNEL);
 		if (!dummy_data)
 			return -ENOMEM;
 		dummy_data->mem_size = mem_size;
 		dummy_data->mem_address = mem_address;
 		dummy_data->record_size = record_size;
 		dummy_data->dump_oops = dump_oops;
 		dummy = platform_create_bundle(&ramoops_driver, ramoops_probe,
 			NULL, 0, dummy_data,
 			sizeof(struct ramoops_platform_data));
 		if (IS_ERR(dummy))
 			ret = PTR_ERR(dummy);
 		else
 			ret = 0;
 	}
 	return ret;
 }
 static void __exit ramoops_exit(void)
 {
 	platform_driver_unregister(&ramoops_driver);
 	kfree(dummy_data);
 }
 module_init(ramoops_init);
 module_exit(ramoops_exit);
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Marco Stornelli <marco.stornelli@gmail.com>");
 MODULE_DESCRIPTION("RAM Oops/Panic logger/driver");

drivers/mtd/mtdoops.c

Diff comments View file @ a3dd332

 /*
  * MTD Oops/Panic logger
  *
  * Copyright © 2007 Nokia Corporation. All rights reserved.
  *
  * Author: Richard Purdie <rpurdie@openedhand.com>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * version 2 as published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  * 02110-1301 USA
  *
  */
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/console.h>
 #include <linux/vmalloc.h>
 #include <linux/workqueue.h>
 #include <linux/sched.h>
 #include <linux/wait.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/mtd/mtd.h>
 #include <linux/kmsg_dump.h>
 /* Maximum MTD partition size */
 #define MTDOOPS_MAX_MTD_SIZE (8 * 1024 * 1024)
 #define MTDOOPS_KERNMSG_MAGIC 0x5d005d00
 #define MTDOOPS_HEADER_SIZE   8
 static unsigned long record_size = 4096;
 module_param(record_size, ulong, 0400);
 MODULE_PARM_DESC(record_size,
 		"record size for MTD OOPS pages in bytes (default 4096)");
 static char mtddev[80];
 module_param_string(mtddev, mtddev, 80, 0400);
 MODULE_PARM_DESC(mtddev,
 		"name or index number of the MTD device to use");
 static int dump_oops = 1;
 module_param(dump_oops, int, 0600);
 MODULE_PARM_DESC(dump_oops,
 		"set to 1 to dump oopses, 0 to only dump panics (default 1)");
 static struct mtdoops_context {
 	struct kmsg_dumper dump;
 	int mtd_index;
 	struct work_struct work_erase;
 	struct work_struct work_write;
 	struct mtd_info *mtd;
 	int oops_pages;
 	int nextpage;
 	int nextcount;
 	unsigned long *oops_page_used;
 	void *oops_buf;
 } oops_cxt;
 static void mark_page_used(struct mtdoops_context *cxt, int page)
 {
 	set_bit(page, cxt->oops_page_used);
 }
 static void mark_page_unused(struct mtdoops_context *cxt, int page)
 {
 	clear_bit(page, cxt->oops_page_used);
 }
 static int page_is_used(struct mtdoops_context *cxt, int page)
 {
 	return test_bit(page, cxt->oops_page_used);
 }
 static void mtdoops_erase_callback(struct erase_info *done)
 {
 	wait_queue_head_t *wait_q = (wait_queue_head_t *)done->priv;
 	wake_up(wait_q);
 }
 static int mtdoops_erase_block(struct mtdoops_context *cxt, int offset)
 {
 	struct mtd_info *mtd = cxt->mtd;
 	u32 start_page_offset = mtd_div_by_eb(offset, mtd) * mtd->erasesize;
 	u32 start_page = start_page_offset / record_size;
 	u32 erase_pages = mtd->erasesize / record_size;
 	struct erase_info erase;
 	DECLARE_WAITQUEUE(wait, current);
 	wait_queue_head_t wait_q;
 	int ret;
 	int page;
 	init_waitqueue_head(&wait_q);
 	erase.mtd = mtd;
 	erase.callback = mtdoops_erase_callback;
 	erase.addr = offset;
 	erase.len = mtd->erasesize;
 	erase.priv = (u_long)&wait_q;
 	set_current_state(TASK_INTERRUPTIBLE);
 	add_wait_queue(&wait_q, &wait);
 	ret = mtd_erase(mtd, &erase);
 	if (ret) {
 		set_current_state(TASK_RUNNING);
 		remove_wait_queue(&wait_q, &wait);
 		printk(KERN_WARNING "mtdoops: erase of region [0x%llx, 0x%llx] on \"%s\" failed\n",
 		       (unsigned long long)erase.addr,
 		       (unsigned long long)erase.len, mtddev);
 		return ret;
 	}
 	schedule();  /* Wait for erase to finish. */
 	remove_wait_queue(&wait_q, &wait);
 	/* Mark pages as unused */
 	for (page = start_page; page < start_page + erase_pages; page++)
 		mark_page_unused(cxt, page);
 	return 0;
 }
 static void mtdoops_inc_counter(struct mtdoops_context *cxt)
 {
 	cxt->nextpage++;
 	if (cxt->nextpage >= cxt->oops_pages)
 		cxt->nextpage = 0;
 	cxt->nextcount++;
 	if (cxt->nextcount == 0xffffffff)
 		cxt->nextcount = 0;
 	if (page_is_used(cxt, cxt->nextpage)) {
 		schedule_work(&cxt->work_erase);
 		return;
 	}
 	printk(KERN_DEBUG "mtdoops: ready %d, %d (no erase)\n",
 	       cxt->nextpage, cxt->nextcount);
 }
 /* Scheduled work - when we can't proceed without erasing a block */
 static void mtdoops_workfunc_erase(struct work_struct *work)
 {
 	struct mtdoops_context *cxt =
 			container_of(work, struct mtdoops_context, work_erase);
 	struct mtd_info *mtd = cxt->mtd;
 	int i = 0, j, ret, mod;
 	/* We were unregistered */
 	if (!mtd)
 		return;
 	mod = (cxt->nextpage * record_size) % mtd->erasesize;
 	if (mod != 0) {
 		cxt->nextpage = cxt->nextpage + ((mtd->erasesize - mod) / record_size);
 		if (cxt->nextpage >= cxt->oops_pages)
 			cxt->nextpage = 0;
 	}
 	while (mtd_can_have_bb(mtd)) {
 		ret = mtd_block_isbad(mtd, cxt->nextpage * record_size);
 		if (!ret)
 			break;
 		if (ret < 0) {
 			printk(KERN_ERR "mtdoops: block_isbad failed, aborting\n");
 			return;
 		}
 badblock:
 		printk(KERN_WARNING "mtdoops: bad block at %08lx\n",
 		       cxt->nextpage * record_size);
 		i++;
 		cxt->nextpage = cxt->nextpage + (mtd->erasesize / record_size);
 		if (cxt->nextpage >= cxt->oops_pages)
 			cxt->nextpage = 0;
 		if (i == cxt->oops_pages / (mtd->erasesize / record_size)) {
 			printk(KERN_ERR "mtdoops: all blocks bad!\n");
 			return;
 		}
 	}
 	for (j = 0, ret = -1; (j < 3) && (ret < 0); j++)
 		ret = mtdoops_erase_block(cxt, cxt->nextpage * record_size);
 	if (ret >= 0) {
 		printk(KERN_DEBUG "mtdoops: ready %d, %d\n",
 		       cxt->nextpage, cxt->nextcount);
 		return;
 	}
 	if (mtd_can_have_bb(mtd) && ret == -EIO) {
 		ret = mtd_block_markbad(mtd, cxt->nextpage * record_size);
 		if (ret < 0) {
 			printk(KERN_ERR "mtdoops: block_markbad failed, aborting\n");
 			return;
 		}
 	}
 	goto badblock;
 }
 static void mtdoops_write(struct mtdoops_context *cxt, int panic)
 {
 	struct mtd_info *mtd = cxt->mtd;
 	size_t retlen;
 	u32 *hdr;
 	int ret;
 	/* Add mtdoops header to the buffer */
 	hdr = cxt->oops_buf;
 	hdr[0] = cxt->nextcount;
 	hdr[1] = MTDOOPS_KERNMSG_MAGIC;
 	if (panic) {
 		ret = mtd_panic_write(mtd, cxt->nextpage * record_size,
 				      record_size, &retlen, cxt->oops_buf);
 		if (ret == -EOPNOTSUPP) {
 			printk(KERN_ERR "mtdoops: Cannot write from panic without panic_write\n");
 			return;
 		}
 	} else
 		ret = mtd_write(mtd, cxt->nextpage * record_size,
 				record_size, &retlen, cxt->oops_buf);
 	if (retlen != record_size || ret < 0)
 		printk(KERN_ERR "mtdoops: write failure at %ld (%td of %ld written), error %d\n",
 		       cxt->nextpage * record_size, retlen, record_size, ret);
 	mark_page_used(cxt, cxt->nextpage);
 	memset(cxt->oops_buf, 0xff, record_size);
 	mtdoops_inc_counter(cxt);
 }
 static void mtdoops_workfunc_write(struct work_struct *work)
 {
 	struct mtdoops_context *cxt =
 			container_of(work, struct mtdoops_context, work_write);
 	mtdoops_write(cxt, 0);
 }
 static void find_next_position(struct mtdoops_context *cxt)
 {
 	struct mtd_info *mtd = cxt->mtd;
 	int ret, page, maxpos = 0;
 	u32 count[2], maxcount = 0xffffffff;
 	size_t retlen;
 	for (page = 0; page < cxt->oops_pages; page++) {
 		if (mtd_can_have_bb(mtd) &&
 		    mtd_block_isbad(mtd, page * record_size))
 			continue;
 		/* Assume the page is used */
 		mark_page_used(cxt, page);
 		ret = mtd_read(mtd, page * record_size, MTDOOPS_HEADER_SIZE,
 			       &retlen, (u_char *)&count[0]);
 		if (retlen != MTDOOPS_HEADER_SIZE ||
 				(ret < 0 && !mtd_is_bitflip(ret))) {
 			printk(KERN_ERR "mtdoops: read failure at %ld (%td of %d read), err %d\n",
 			       page * record_size, retlen,
 			       MTDOOPS_HEADER_SIZE, ret);
 			continue;
 		}
 		if (count[0] == 0xffffffff && count[1] == 0xffffffff)
 			mark_page_unused(cxt, page);
 		if (count[0] == 0xffffffff)
 			continue;
 		if (maxcount == 0xffffffff) {
 			maxcount = count[0];
 			maxpos = page;
 		} else if (count[0] < 0x40000000 && maxcount > 0xc0000000) {
 			maxcount = count[0];
 			maxpos = page;
 		} else if (count[0] > maxcount && count[0] < 0xc0000000) {
 			maxcount = count[0];
 			maxpos = page;
 		} else if (count[0] > maxcount && count[0] > 0xc0000000
 					&& maxcount > 0x80000000) {
 			maxcount = count[0];
 			maxpos = page;
 		}
 	}
 	if (maxcount == 0xffffffff) {
 		cxt->nextpage = 0;
 		cxt->nextcount = 1;
 		schedule_work(&cxt->work_erase);
 		return;
 	}
 	cxt->nextpage = maxpos;
 	cxt->nextcount = maxcount;
 	mtdoops_inc_counter(cxt);
 }
 static void mtdoops_do_dump(struct kmsg_dumper *dumper,
 		enum kmsg_dump_reason reason, const char *s1, unsigned long l1,
 		const char *s2, unsigned long l2)
 {
 	struct mtdoops_context *cxt = container_of(dumper,
 			struct mtdoops_context, dump);
 	unsigned long s1_start, s2_start;
 	unsigned long l1_cpy, l2_cpy;
 	char *dst;
 	if (reason != KMSG_DUMP_OOPS &&
-	    reason != KMSG_DUMP_PANIC &&
+	    reason != KMSG_DUMP_PANIC)
-	    reason != KMSG_DUMP_KEXEC)
 		return;
 	/* Only dump oopses if dump_oops is set */
 	if (reason == KMSG_DUMP_OOPS && !dump_oops)
 		return;
 	dst = cxt->oops_buf + MTDOOPS_HEADER_SIZE; /* Skip the header */
 	l2_cpy = min(l2, record_size - MTDOOPS_HEADER_SIZE);
 	l1_cpy = min(l1, record_size - MTDOOPS_HEADER_SIZE - l2_cpy);
 	s2_start = l2 - l2_cpy;
 	s1_start = l1 - l1_cpy;
 	memcpy(dst, s1 + s1_start, l1_cpy);
 	memcpy(dst + l1_cpy, s2 + s2_start, l2_cpy);
 	/* Panics must be written immediately */
 	if (reason != KMSG_DUMP_OOPS)
 		mtdoops_write(cxt, 1);
 	/* For other cases, schedule work to write it "nicely" */
 	schedule_work(&cxt->work_write);
 }
 static void mtdoops_notify_add(struct mtd_info *mtd)
 {
 	struct mtdoops_context *cxt = &oops_cxt;
 	u64 mtdoops_pages = div_u64(mtd->size, record_size);
 	int err;
 	if (!strcmp(mtd->name, mtddev))
 		cxt->mtd_index = mtd->index;
 	if (mtd->index != cxt->mtd_index || cxt->mtd_index < 0)
 		return;
 	if (mtd->size < mtd->erasesize * 2) {
 		printk(KERN_ERR "mtdoops: MTD partition %d not big enough for mtdoops\n",
 		       mtd->index);
 		return;
 	}
 	if (mtd->erasesize < record_size) {
 		printk(KERN_ERR "mtdoops: eraseblock size of MTD partition %d too small\n",
 		       mtd->index);
 		return;
 	}
 	if (mtd->size > MTDOOPS_MAX_MTD_SIZE) {
 		printk(KERN_ERR "mtdoops: mtd%d is too large (limit is %d MiB)\n",
 		       mtd->index, MTDOOPS_MAX_MTD_SIZE / 1024 / 1024);
 		return;
 	}
 	/* oops_page_used is a bit field */
 	cxt->oops_page_used = vmalloc(DIV_ROUND_UP(mtdoops_pages,
 			BITS_PER_LONG) * sizeof(unsigned long));
 	if (!cxt->oops_page_used) {
 		printk(KERN_ERR "mtdoops: could not allocate page array\n");
 		return;
 	}
 	cxt->dump.dump = mtdoops_do_dump;
 	err = kmsg_dump_register(&cxt->dump);
 	if (err) {
 		printk(KERN_ERR "mtdoops: registering kmsg dumper failed, error %d\n", err);
 		vfree(cxt->oops_page_used);
 		cxt->oops_page_used = NULL;
 		return;
 	}
 	cxt->mtd = mtd;
 	cxt->oops_pages = (int)mtd->size / record_size;
 	find_next_position(cxt);
 	printk(KERN_INFO "mtdoops: Attached to MTD device %d\n", mtd->index);
 }
 static void mtdoops_notify_remove(struct mtd_info *mtd)
 {
 	struct mtdoops_context *cxt = &oops_cxt;
 	if (mtd->index != cxt->mtd_index || cxt->mtd_index < 0)
 		return;
 	if (kmsg_dump_unregister(&cxt->dump) < 0)
 		printk(KERN_WARNING "mtdoops: could not unregister kmsg_dumper\n");
 	cxt->mtd = NULL;
 	flush_work_sync(&cxt->work_erase);
 	flush_work_sync(&cxt->work_write);
 }
 static struct mtd_notifier mtdoops_notifier = {
 	.add	= mtdoops_notify_add,
 	.remove	= mtdoops_notify_remove,
 };
 static int __init mtdoops_init(void)
 {
 	struct mtdoops_context *cxt = &oops_cxt;
 	int mtd_index;
 	char *endp;
 	if (strlen(mtddev) == 0) {
 		printk(KERN_ERR "mtdoops: mtd device (mtddev=name/number) must be supplied\n");
 		return -EINVAL;
 	}
 	if ((record_size & 4095) != 0) {
 		printk(KERN_ERR "mtdoops: record_size must be a multiple of 4096\n");
 		return -EINVAL;
 	}
 	if (record_size < 4096) {
 		printk(KERN_ERR "mtdoops: record_size must be over 4096 bytes\n");
 		return -EINVAL;
 	}
 	/* Setup the MTD device to use */
 	cxt->mtd_index = -1;
 	mtd_index = simple_strtoul(mtddev, &endp, 0);
 	if (*endp == '\0')
 		cxt->mtd_index = mtd_index;
 	cxt->oops_buf = vmalloc(record_size);
 	if (!cxt->oops_buf) {
 		printk(KERN_ERR "mtdoops: failed to allocate buffer workspace\n");
 		return -ENOMEM;
 	}
 	memset(cxt->oops_buf, 0xff, record_size);
 	INIT_WORK(&cxt->work_erase, mtdoops_workfunc_erase);
 	INIT_WORK(&cxt->work_write, mtdoops_workfunc_write);
 	register_mtd_user(&mtdoops_notifier);
 	return 0;
 }
 static void __exit mtdoops_exit(void)
 {
 	struct mtdoops_context *cxt = &oops_cxt;
 	unregister_mtd_user(&mtdoops_notifier);
 	vfree(cxt->oops_buf);
 	vfree(cxt->oops_page_used);
 }
 module_init(mtdoops_init);
 module_exit(mtdoops_exit);
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Richard Purdie <rpurdie@openedhand.com>");
 MODULE_DESCRIPTION("MTD Oops/Panic console logger/driver");

include/linux/kmsg_dump.h

Diff comments View file @ a3dd332

 /*
  * linux/include/kmsg_dump.h
  *
  * Copyright (C) 2009 Net Insight AB
  *
  * Author: Simon Kagstrom <simon.kagstrom@netinsight.net>
  *
  * This file is subject to the terms and conditions of the GNU General Public
  * License.  See the file COPYING in the main directory of this archive
  * for more details.
  */
 #ifndef _LINUX_KMSG_DUMP_H
 #define _LINUX_KMSG_DUMP_H
 #include <linux/errno.h>
 #include <linux/list.h>
 enum kmsg_dump_reason {
 	KMSG_DUMP_OOPS,
 	KMSG_DUMP_PANIC,
-	KMSG_DUMP_KEXEC,
 	KMSG_DUMP_RESTART,
 	KMSG_DUMP_HALT,
 	KMSG_DUMP_POWEROFF,
 	KMSG_DUMP_EMERG,
 };
 /**
  * struct kmsg_dumper - kernel crash message dumper structure
  * @dump:	The callback which gets called on crashes. The buffer is passed
  * 		as two sections, where s1 (length l1) contains the older
  * 		messages and s2 (length l2) contains the newer.
  * @list:	Entry in the dumper list (private)
  * @registered:	Flag that specifies if this is already registered
  */
 struct kmsg_dumper {
 	void (*dump)(struct kmsg_dumper *dumper, enum kmsg_dump_reason reason,
 			const char *s1, unsigned long l1,
 			const char *s2, unsigned long l2);
 	struct list_head list;
 	int registered;
 };
 #ifdef CONFIG_PRINTK
 void kmsg_dump(enum kmsg_dump_reason reason);
 int kmsg_dump_register(struct kmsg_dumper *dumper);
 int kmsg_dump_unregister(struct kmsg_dumper *dumper);
 #else
 static inline void kmsg_dump(enum kmsg_dump_reason reason)
 {
 }
 static inline int kmsg_dump_register(struct kmsg_dumper *dumper)
 {
 	return -EINVAL;
 }
 static inline int kmsg_dump_unregister(struct kmsg_dumper *dumper)
 {
 	return -EINVAL;
 }
 #endif
 #endif /* _LINUX_KMSG_DUMP_H */

kernel/kexec.c

Diff comments View file @ a3dd332

 /*
  * kexec.c - kexec system call
  * Copyright (C) 2002-2004 Eric Biederman  <ebiederm@xmission.com>
  *
  * This source code is licensed under the GNU General Public License,
  * Version 2.  See the file COPYING for more details.
  */
 #include <linux/capability.h>
 #include <linux/mm.h>
 #include <linux/file.h>
 #include <linux/slab.h>
 #include <linux/fs.h>
 #include <linux/kexec.h>
 #include <linux/mutex.h>
 #include <linux/list.h>
 #include <linux/highmem.h>
 #include <linux/syscalls.h>
 #include <linux/reboot.h>
 #include <linux/ioport.h>
 #include <linux/hardirq.h>
 #include <linux/elf.h>
 #include <linux/elfcore.h>
 #include <generated/utsrelease.h>
 #include <linux/utsname.h>
 #include <linux/numa.h>
 #include <linux/suspend.h>
 #include <linux/device.h>
 #include <linux/freezer.h>
 #include <linux/pm.h>
 #include <linux/cpu.h>
 #include <linux/console.h>
 #include <linux/vmalloc.h>
 #include <linux/swap.h>
-#include <linux/kmsg_dump.h>
 #include <linux/syscore_ops.h>
 #include <asm/page.h>
 #include <asm/uaccess.h>
 #include <asm/io.h>
 #include <asm/system.h>
 #include <asm/sections.h>
 /* Per cpu memory for storing cpu states in case of system crash. */
 note_buf_t __percpu *crash_notes;
 /* vmcoreinfo stuff */
 static unsigned char vmcoreinfo_data[VMCOREINFO_BYTES];
 u32 vmcoreinfo_note[VMCOREINFO_NOTE_SIZE/4];
 size_t vmcoreinfo_size;
 size_t vmcoreinfo_max_size = sizeof(vmcoreinfo_data);
 /* Location of the reserved area for the crash kernel */
 struct resource crashk_res = {
 	.name  = "Crash kernel",
 	.start = 0,
 	.end   = 0,
 	.flags = IORESOURCE_BUSY | IORESOURCE_MEM
 };
 int kexec_should_crash(struct task_struct *p)
 {
 	if (in_interrupt() || !p->pid || is_global_init(p) || panic_on_oops)
 		return 1;
 	return 0;
 }
 /*
  * When kexec transitions to the new kernel there is a one-to-one
  * mapping between physical and virtual addresses.  On processors
  * where you can disable the MMU this is trivial, and easy.  For
  * others it is still a simple predictable page table to setup.
  *
  * In that environment kexec copies the new kernel to its final
  * resting place.  This means I can only support memory whose
  * physical address can fit in an unsigned long.  In particular
  * addresses where (pfn << PAGE_SHIFT) > ULONG_MAX cannot be handled.
  * If the assembly stub has more restrictive requirements
  * KEXEC_SOURCE_MEMORY_LIMIT and KEXEC_DEST_MEMORY_LIMIT can be
  * defined more restrictively in <asm/kexec.h>.
  *
  * The code for the transition from the current kernel to the
  * the new kernel is placed in the control_code_buffer, whose size
  * is given by KEXEC_CONTROL_PAGE_SIZE.  In the best case only a single
  * page of memory is necessary, but some architectures require more.
  * Because this memory must be identity mapped in the transition from
  * virtual to physical addresses it must live in the range
  * 0 - TASK_SIZE, as only the user space mappings are arbitrarily
  * modifiable.
  *
  * The assembly stub in the control code buffer is passed a linked list
  * of descriptor pages detailing the source pages of the new kernel,
  * and the destination addresses of those source pages.  As this data
  * structure is not used in the context of the current OS, it must
  * be self-contained.
  *
  * The code has been made to work with highmem pages and will use a
  * destination page in its final resting place (if it happens
  * to allocate it).  The end product of this is that most of the
  * physical address space, and most of RAM can be used.
  *
  * Future directions include:
  *  - allocating a page table with the control code buffer identity
  *    mapped, to simplify machine_kexec and make kexec_on_panic more
  *    reliable.
  */
 /*
  * KIMAGE_NO_DEST is an impossible destination address..., for
  * allocating pages whose destination address we do not care about.
  */
 #define KIMAGE_NO_DEST (-1UL)
 static int kimage_is_destination_range(struct kimage *image,
 				       unsigned long start, unsigned long end);
 static struct page *kimage_alloc_page(struct kimage *image,
 				       gfp_t gfp_mask,
 				       unsigned long dest);
 static int do_kimage_alloc(struct kimage **rimage, unsigned long entry,
 	                    unsigned long nr_segments,
                             struct kexec_segment __user *segments)
 {
 	size_t segment_bytes;
 	struct kimage *image;
 	unsigned long i;
 	int result;
 	/* Allocate a controlling structure */
 	result = -ENOMEM;
 	image = kzalloc(sizeof(*image), GFP_KERNEL);
 	if (!image)
 		goto out;
 	image->head = 0;
 	image->entry = &image->head;
 	image->last_entry = &image->head;
 	image->control_page = ~0; /* By default this does not apply */
 	image->start = entry;
 	image->type = KEXEC_TYPE_DEFAULT;
 	/* Initialize the list of control pages */
 	INIT_LIST_HEAD(&image->control_pages);
 	/* Initialize the list of destination pages */
 	INIT_LIST_HEAD(&image->dest_pages);
 	/* Initialize the list of unusable pages */
 	INIT_LIST_HEAD(&image->unuseable_pages);
 	/* Read in the segments */
 	image->nr_segments = nr_segments;
 	segment_bytes = nr_segments * sizeof(*segments);
 	result = copy_from_user(image->segment, segments, segment_bytes);
 	if (result) {
 		result = -EFAULT;
 		goto out;
 	}
 	/*
 	 * Verify we have good destination addresses.  The caller is
 	 * responsible for making certain we don't attempt to load
 	 * the new image into invalid or reserved areas of RAM.  This
 	 * just verifies it is an address we can use.
 	 *
 	 * Since the kernel does everything in page size chunks ensure
 	 * the destination addresses are page aligned.  Too many
 	 * special cases crop of when we don't do this.  The most
 	 * insidious is getting overlapping destination addresses
 	 * simply because addresses are changed to page size
 	 * granularity.
 	 */
 	result = -EADDRNOTAVAIL;
 	for (i = 0; i < nr_segments; i++) {
 		unsigned long mstart, mend;
 		mstart = image->segment[i].mem;
 		mend   = mstart + image->segment[i].memsz;
 		if ((mstart & ~PAGE_MASK) || (mend & ~PAGE_MASK))
 			goto out;
 		if (mend >= KEXEC_DESTINATION_MEMORY_LIMIT)
 			goto out;
 	}
 	/* Verify our destination addresses do not overlap.
 	 * If we alloed overlapping destination addresses
 	 * through very weird things can happen with no
 	 * easy explanation as one segment stops on another.
 	 */
 	result = -EINVAL;
 	for (i = 0; i < nr_segments; i++) {
 		unsigned long mstart, mend;
 		unsigned long j;
 		mstart = image->segment[i].mem;
 		mend   = mstart + image->segment[i].memsz;
 		for (j = 0; j < i; j++) {
 			unsigned long pstart, pend;
 			pstart = image->segment[j].mem;
 			pend   = pstart + image->segment[j].memsz;
 			/* Do the segments overlap ? */
 			if ((mend > pstart) && (mstart < pend))
 				goto out;
 		}
 	}
 	/* Ensure our buffer sizes are strictly less than
 	 * our memory sizes.  This should always be the case,
 	 * and it is easier to check up front than to be surprised
 	 * later on.
 	 */
 	result = -EINVAL;
 	for (i = 0; i < nr_segments; i++) {
 		if (image->segment[i].bufsz > image->segment[i].memsz)
 			goto out;
 	}
 	result = 0;
 out:
 	if (result == 0)
 		*rimage = image;
 	else
 		kfree(image);
 	return result;
 }
 static int kimage_normal_alloc(struct kimage **rimage, unsigned long entry,
 				unsigned long nr_segments,
 				struct kexec_segment __user *segments)
 {
 	int result;
 	struct kimage *image;
 	/* Allocate and initialize a controlling structure */
 	image = NULL;
 	result = do_kimage_alloc(&image, entry, nr_segments, segments);
 	if (result)
 		goto out;
 	*rimage = image;
 	/*
 	 * Find a location for the control code buffer, and add it
 	 * the vector of segments so that it's pages will also be
 	 * counted as destination pages.
 	 */
 	result = -ENOMEM;
 	image->control_code_page = kimage_alloc_control_pages(image,
 					   get_order(KEXEC_CONTROL_PAGE_SIZE));
 	if (!image->control_code_page) {
 		printk(KERN_ERR "Could not allocate control_code_buffer\n");
 		goto out;
 	}
 	image->swap_page = kimage_alloc_control_pages(image, 0);
 	if (!image->swap_page) {
 		printk(KERN_ERR "Could not allocate swap buffer\n");
 		goto out;
 	}
 	result = 0;
  out:
 	if (result == 0)
 		*rimage = image;
 	else
 		kfree(image);
 	return result;
 }
 static int kimage_crash_alloc(struct kimage **rimage, unsigned long entry,
 				unsigned long nr_segments,
 				struct kexec_segment __user *segments)
 {
 	int result;
 	struct kimage *image;
 	unsigned long i;
 	image = NULL;
 	/* Verify we have a valid entry point */
 	if ((entry < crashk_res.start) || (entry > crashk_res.end)) {
 		result = -EADDRNOTAVAIL;
 		goto out;
 	}
 	/* Allocate and initialize a controlling structure */
 	result = do_kimage_alloc(&image, entry, nr_segments, segments);
 	if (result)
 		goto out;
 	/* Enable the special crash kernel control page
 	 * allocation policy.
 	 */
 	image->control_page = crashk_res.start;
 	image->type = KEXEC_TYPE_CRASH;
 	/*
 	 * Verify we have good destination addresses.  Normally
 	 * the caller is responsible for making certain we don't
 	 * attempt to load the new image into invalid or reserved
 	 * areas of RAM.  But crash kernels are preloaded into a
 	 * reserved area of ram.  We must ensure the addresses
 	 * are in the reserved area otherwise preloading the
 	 * kernel could corrupt things.
 	 */
 	result = -EADDRNOTAVAIL;
 	for (i = 0; i < nr_segments; i++) {
 		unsigned long mstart, mend;
 		mstart = image->segment[i].mem;
 		mend = mstart + image->segment[i].memsz - 1;
 		/* Ensure we are within the crash kernel limits */
 		if ((mstart < crashk_res.start) || (mend > crashk_res.end))
 			goto out;
 	}
 	/*
 	 * Find a location for the control code buffer, and add
 	 * the vector of segments so that it's pages will also be
 	 * counted as destination pages.
 	 */
 	result = -ENOMEM;
 	image->control_code_page = kimage_alloc_control_pages(image,
 					   get_order(KEXEC_CONTROL_PAGE_SIZE));
 	if (!image->control_code_page) {
 		printk(KERN_ERR "Could not allocate control_code_buffer\n");
 		goto out;
 	}
 	result = 0;
 out:
 	if (result == 0)
 		*rimage = image;
 	else
 		kfree(image);
 	return result;
 }
 static int kimage_is_destination_range(struct kimage *image,
 					unsigned long start,
 					unsigned long end)
 {
 	unsigned long i;
 	for (i = 0; i < image->nr_segments; i++) {
 		unsigned long mstart, mend;
 		mstart = image->segment[i].mem;
 		mend = mstart + image->segment[i].memsz;
 		if ((end > mstart) && (start < mend))
 			return 1;
 	}
 	return 0;
 }
 static struct page *kimage_alloc_pages(gfp_t gfp_mask, unsigned int order)
 {
 	struct page *pages;
 	pages = alloc_pages(gfp_mask, order);
 	if (pages) {
 		unsigned int count, i;
 		pages->mapping = NULL;
 		set_page_private(pages, order);
 		count = 1 << order;
 		for (i = 0; i < count; i++)
 			SetPageReserved(pages + i);
 	}
 	return pages;
 }
 static void kimage_free_pages(struct page *page)
 {
 	unsigned int order, count, i;
 	order = page_private(page);
 	count = 1 << order;
 	for (i = 0; i < count; i++)
 		ClearPageReserved(page + i);
 	__free_pages(page, order);
 }
 static void kimage_free_page_list(struct list_head *list)
 {
 	struct list_head *pos, *next;
 	list_for_each_safe(pos, next, list) {
 		struct page *page;
 		page = list_entry(pos, struct page, lru);
 		list_del(&page->lru);
 		kimage_free_pages(page);
 	}
 }
 static struct page *kimage_alloc_normal_control_pages(struct kimage *image,
 							unsigned int order)
 {
 	/* Control pages are special, they are the intermediaries
 	 * that are needed while we copy the rest of the pages
 	 * to their final resting place.  As such they must
 	 * not conflict with either the destination addresses
 	 * or memory the kernel is already using.
 	 *
 	 * The only case where we really need more than one of
 	 * these are for architectures where we cannot disable
 	 * the MMU and must instead generate an identity mapped
 	 * page table for all of the memory.
 	 *
 	 * At worst this runs in O(N) of the image size.
 	 */
 	struct list_head extra_pages;
 	struct page *pages;
 	unsigned int count;
 	count = 1 << order;
 	INIT_LIST_HEAD(&extra_pages);
 	/* Loop while I can allocate a page and the page allocated
 	 * is a destination page.
 	 */
 	do {
 		unsigned long pfn, epfn, addr, eaddr;
 		pages = kimage_alloc_pages(GFP_KERNEL, order);
 		if (!pages)
 			break;
 		pfn   = page_to_pfn(pages);
 		epfn  = pfn + count;
 		addr  = pfn << PAGE_SHIFT;
 		eaddr = epfn << PAGE_SHIFT;
 		if ((epfn >= (KEXEC_CONTROL_MEMORY_LIMIT >> PAGE_SHIFT)) ||
 			      kimage_is_destination_range(image, addr, eaddr)) {
 			list_add(&pages->lru, &extra_pages);
 			pages = NULL;
 		}
 	} while (!pages);
 	if (pages) {
 		/* Remember the allocated page... */
 		list_add(&pages->lru, &image->control_pages);
 		/* Because the page is already in it's destination
 		 * location we will never allocate another page at
 		 * that address.  Therefore kimage_alloc_pages
 		 * will not return it (again) and we don't need
 		 * to give it an entry in image->segment[].
 		 */
 	}
 	/* Deal with the destination pages I have inadvertently allocated.
 	 *
 	 * Ideally I would convert multi-page allocations into single
 	 * page allocations, and add everything to image->dest_pages.
 	 *
 	 * For now it is simpler to just free the pages.
 	 */
 	kimage_free_page_list(&extra_pages);
 	return pages;
 }
 static struct page *kimage_alloc_crash_control_pages(struct kimage *image,
 						      unsigned int order)
 {
 	/* Control pages are special, they are the intermediaries
 	 * that are needed while we copy the rest of the pages
 	 * to their final resting place.  As such they must
 	 * not conflict with either the destination addresses
 	 * or memory the kernel is already using.
 	 *
 	 * Control pages are also the only pags we must allocate
 	 * when loading a crash kernel.  All of the other pages
 	 * are specified by the segments and we just memcpy
 	 * into them directly.
 	 *
 	 * The only case where we really need more than one of
 	 * these are for architectures where we cannot disable
 	 * the MMU and must instead generate an identity mapped
 	 * page table for all of the memory.
 	 *
 	 * Given the low demand this implements a very simple
 	 * allocator that finds the first hole of the appropriate
 	 * size in the reserved memory region, and allocates all
 	 * of the memory up to and including the hole.
 	 */
 	unsigned long hole_start, hole_end, size;
 	struct page *pages;
 	pages = NULL;
 	size = (1 << order) << PAGE_SHIFT;
 	hole_start = (image->control_page + (size - 1)) & ~(size - 1);
 	hole_end   = hole_start + size - 1;
 	while (hole_end <= crashk_res.end) {
 		unsigned long i;
 		if (hole_end > KEXEC_CRASH_CONTROL_MEMORY_LIMIT)
 			break;
 		if (hole_end > crashk_res.end)
 			break;
 		/* See if I overlap any of the segments */
 		for (i = 0; i < image->nr_segments; i++) {
 			unsigned long mstart, mend;
 			mstart = image->segment[i].mem;
 			mend   = mstart + image->segment[i].memsz - 1;
 			if ((hole_end >= mstart) && (hole_start <= mend)) {
 				/* Advance the hole to the end of the segment */
 				hole_start = (mend + (size - 1)) & ~(size - 1);
 				hole_end   = hole_start + size - 1;
 				break;
 			}
 		}
 		/* If I don't overlap any segments I have found my hole! */
 		if (i == image->nr_segments) {
 			pages = pfn_to_page(hole_start >> PAGE_SHIFT);
 			break;
 		}
 	}
 	if (pages)
 		image->control_page = hole_end;
 	return pages;
 }
 struct page *kimage_alloc_control_pages(struct kimage *image,
 					 unsigned int order)
 {
 	struct page *pages = NULL;
 	switch (image->type) {
 	case KEXEC_TYPE_DEFAULT:
 		pages = kimage_alloc_normal_control_pages(image, order);
 		break;
 	case KEXEC_TYPE_CRASH:
 		pages = kimage_alloc_crash_control_pages(image, order);
 		break;
 	}
 	return pages;
 }
 static int kimage_add_entry(struct kimage *image, kimage_entry_t entry)
 {
 	if (*image->entry != 0)
 		image->entry++;
 	if (image->entry == image->last_entry) {
 		kimage_entry_t *ind_page;
 		struct page *page;
 		page = kimage_alloc_page(image, GFP_KERNEL, KIMAGE_NO_DEST);
 		if (!page)
 			return -ENOMEM;
 		ind_page = page_address(page);
 		*image->entry = virt_to_phys(ind_page) | IND_INDIRECTION;
 		image->entry = ind_page;
 		image->last_entry = ind_page +
 				      ((PAGE_SIZE/sizeof(kimage_entry_t)) - 1);
 	}
 	*image->entry = entry;
 	image->entry++;
 	*image->entry = 0;
 	return 0;
 }
 static int kimage_set_destination(struct kimage *image,
 				   unsigned long destination)
 {
 	int result;
 	destination &= PAGE_MASK;
 	result = kimage_add_entry(image, destination | IND_DESTINATION);
 	if (result == 0)
 		image->destination = destination;
 	return result;
 }
 static int kimage_add_page(struct kimage *image, unsigned long page)
 {
 	int result;
 	page &= PAGE_MASK;
 	result = kimage_add_entry(image, page | IND_SOURCE);
 	if (result == 0)
 		image->destination += PAGE_SIZE;
 	return result;
 }
 static void kimage_free_extra_pages(struct kimage *image)
 {
 	/* Walk through and free any extra destination pages I may have */
 	kimage_free_page_list(&image->dest_pages);
 	/* Walk through and free any unusable pages I have cached */
 	kimage_free_page_list(&image->unuseable_pages);
 }
 static void kimage_terminate(struct kimage *image)
 {
 	if (*image->entry != 0)
 		image->entry++;
 	*image->entry = IND_DONE;
 }
 #define for_each_kimage_entry(image, ptr, entry) \
 	for (ptr = &image->head; (entry = *ptr) && !(entry & IND_DONE); \
 		ptr = (entry & IND_INDIRECTION)? \
 			phys_to_virt((entry & PAGE_MASK)): ptr +1)
 static void kimage_free_entry(kimage_entry_t entry)
 {
 	struct page *page;
 	page = pfn_to_page(entry >> PAGE_SHIFT);
 	kimage_free_pages(page);
 }
 static void kimage_free(struct kimage *image)
 {
 	kimage_entry_t *ptr, entry;
 	kimage_entry_t ind = 0;
 	if (!image)
 		return;
 	kimage_free_extra_pages(image);
 	for_each_kimage_entry(image, ptr, entry) {
 		if (entry & IND_INDIRECTION) {
 			/* Free the previous indirection page */
 			if (ind & IND_INDIRECTION)
 				kimage_free_entry(ind);
 			/* Save this indirection page until we are
 			 * done with it.
 			 */
 			ind = entry;
 		}
 		else if (entry & IND_SOURCE)
 			kimage_free_entry(entry);
 	}
 	/* Free the final indirection page */
 	if (ind & IND_INDIRECTION)
 		kimage_free_entry(ind);
 	/* Handle any machine specific cleanup */
 	machine_kexec_cleanup(image);
 	/* Free the kexec control pages... */
 	kimage_free_page_list(&image->control_pages);
 	kfree(image);
 }
 static kimage_entry_t *kimage_dst_used(struct kimage *image,
 					unsigned long page)
 {
 	kimage_entry_t *ptr, entry;
 	unsigned long destination = 0;
 	for_each_kimage_entry(image, ptr, entry) {
 		if (entry & IND_DESTINATION)
 			destination = entry & PAGE_MASK;
 		else if (entry & IND_SOURCE) {
 			if (page == destination)
 				return ptr;
 			destination += PAGE_SIZE;
 		}
 	}
 	return NULL;
 }
 static struct page *kimage_alloc_page(struct kimage *image,
 					gfp_t gfp_mask,
 					unsigned long destination)
 {
 	/*
 	 * Here we implement safeguards to ensure that a source page
 	 * is not copied to its destination page before the data on
 	 * the destination page is no longer useful.
 	 *
 	 * To do this we maintain the invariant that a source page is
 	 * either its own destination page, or it is not a
 	 * destination page at all.
 	 *
 	 * That is slightly stronger than required, but the proof
 	 * that no problems will not occur is trivial, and the
 	 * implementation is simply to verify.
 	 *
 	 * When allocating all pages normally this algorithm will run
 	 * in O(N) time, but in the worst case it will run in O(N^2)
 	 * time.   If the runtime is a problem the data structures can
 	 * be fixed.
 	 */
 	struct page *page;
 	unsigned long addr;
 	/*
 	 * Walk through the list of destination pages, and see if I
 	 * have a match.
 	 */
 	list_for_each_entry(page, &image->dest_pages, lru) {
 		addr = page_to_pfn(page) << PAGE_SHIFT;
 		if (addr == destination) {
 			list_del(&page->lru);
 			return page;
 		}
 	}
 	page = NULL;
 	while (1) {
 		kimage_entry_t *old;
 		/* Allocate a page, if we run out of memory give up */
 		page = kimage_alloc_pages(gfp_mask, 0);
 		if (!page)
 			return NULL;
 		/* If the page cannot be used file it away */
 		if (page_to_pfn(page) >
 				(KEXEC_SOURCE_MEMORY_LIMIT >> PAGE_SHIFT)) {
 			list_add(&page->lru, &image->unuseable_pages);
 			continue;
 		}
 		addr = page_to_pfn(page) << PAGE_SHIFT;
 		/* If it is the destination page we want use it */
 		if (addr == destination)
 			break;
 		/* If the page is not a destination page use it */
 		if (!kimage_is_destination_range(image, addr,
 						  addr + PAGE_SIZE))
 			break;
 		/*
 		 * I know that the page is someones destination page.
 		 * See if there is already a source page for this
 		 * destination page.  And if so swap the source pages.
 		 */
 		old = kimage_dst_used(image, addr);
 		if (old) {
 			/* If so move it */
 			unsigned long old_addr;
 			struct page *old_page;
 			old_addr = *old & PAGE_MASK;
 			old_page = pfn_to_page(old_addr >> PAGE_SHIFT);
 			copy_highpage(page, old_page);
 			*old = addr | (*old & ~PAGE_MASK);
 			/* The old page I have found cannot be a
 			 * destination page, so return it if it's
 			 * gfp_flags honor the ones passed in.
 			 */
 			if (!(gfp_mask & __GFP_HIGHMEM) &&
 			    PageHighMem(old_page)) {
 				kimage_free_pages(old_page);
 				continue;
 			}
 			addr = old_addr;
 			page = old_page;
 			break;
 		}
 		else {
 			/* Place the page on the destination list I
 			 * will use it later.
 			 */
 			list_add(&page->lru, &image->dest_pages);
 		}
 	}
 	return page;
 }
 static int kimage_load_normal_segment(struct kimage *image,
 					 struct kexec_segment *segment)
 {
 	unsigned long maddr;
 	unsigned long ubytes, mbytes;
 	int result;
 	unsigned char __user *buf;
 	result = 0;
 	buf = segment->buf;
 	ubytes = segment->bufsz;
 	mbytes = segment->memsz;
 	maddr = segment->mem;
 	result = kimage_set_destination(image, maddr);
 	if (result < 0)
 		goto out;
 	while (mbytes) {
 		struct page *page;
 		char *ptr;
 		size_t uchunk, mchunk;
 		page = kimage_alloc_page(image, GFP_HIGHUSER, maddr);
 		if (!page) {
 			result  = -ENOMEM;
 			goto out;
 		}
 		result = kimage_add_page(image, page_to_pfn(page)
 								<< PAGE_SHIFT);
 		if (result < 0)
 			goto out;
 		ptr = kmap(page);
 		/* Start with a clear page */
 		clear_page(ptr);
 		ptr += maddr & ~PAGE_MASK;
 		mchunk = PAGE_SIZE - (maddr & ~PAGE_MASK);
 		if (mchunk > mbytes)
 			mchunk = mbytes;
 		uchunk = mchunk;
 		if (uchunk > ubytes)
 			uchunk = ubytes;
 		result = copy_from_user(ptr, buf, uchunk);
 		kunmap(page);
 		if (result) {
 			result = -EFAULT;
 			goto out;
 		}
 		ubytes -= uchunk;
 		maddr  += mchunk;
 		buf    += mchunk;
 		mbytes -= mchunk;
 	}
 out:
 	return result;
 }
 static int kimage_load_crash_segment(struct kimage *image,
 					struct kexec_segment *segment)
 {
 	/* For crash dumps kernels we simply copy the data from
 	 * user space to it's destination.
 	 * We do things a page at a time for the sake of kmap.
 	 */
 	unsigned long maddr;
 	unsigned long ubytes, mbytes;
 	int result;
 	unsigned char __user *buf;
 	result = 0;
 	buf = segment->buf;
 	ubytes = segment->bufsz;
 	mbytes = segment->memsz;
 	maddr = segment->mem;
 	while (mbytes) {
 		struct page *page;
 		char *ptr;
 		size_t uchunk, mchunk;
 		page = pfn_to_page(maddr >> PAGE_SHIFT);
 		if (!page) {
 			result  = -ENOMEM;
 			goto out;
 		}
 		ptr = kmap(page);
 		ptr += maddr & ~PAGE_MASK;
 		mchunk = PAGE_SIZE - (maddr & ~PAGE_MASK);
 		if (mchunk > mbytes)
 			mchunk = mbytes;
 		uchunk = mchunk;
 		if (uchunk > ubytes) {
 			uchunk = ubytes;
 			/* Zero the trailing part of the page */
 			memset(ptr + uchunk, 0, mchunk - uchunk);
 		}
 		result = copy_from_user(ptr, buf, uchunk);
 		kexec_flush_icache_page(page);
 		kunmap(page);
 		if (result) {
 			result = -EFAULT;
 			goto out;
 		}
 		ubytes -= uchunk;
 		maddr  += mchunk;
 		buf    += mchunk;
 		mbytes -= mchunk;
 	}
 out:
 	return result;
 }
 static int kimage_load_segment(struct kimage *image,
 				struct kexec_segment *segment)
 {
 	int result = -ENOMEM;
 	switch (image->type) {
 	case KEXEC_TYPE_DEFAULT:
 		result = kimage_load_normal_segment(image, segment);
 		break;
 	case KEXEC_TYPE_CRASH:
 		result = kimage_load_crash_segment(image, segment);
 		break;
 	}
 	return result;
 }
 /*
  * Exec Kernel system call: for obvious reasons only root may call it.
  *
  * This call breaks up into three pieces.
  * - A generic part which loads the new kernel from the current
  *   address space, and very carefully places the data in the
  *   allocated pages.
  *
  * - A generic part that interacts with the kernel and tells all of
  *   the devices to shut down.  Preventing on-going dmas, and placing
  *   the devices in a consistent state so a later kernel can
  *   reinitialize them.
  *
  * - A machine specific part that includes the syscall number
  *   and the copies the image to it's final destination.  And
  *   jumps into the image at entry.
  *
  * kexec does not sync, or unmount filesystems so if you need
  * that to happen you need to do that yourself.
  */
 struct kimage *kexec_image;
 struct kimage *kexec_crash_image;
 static DEFINE_MUTEX(kexec_mutex);
 SYSCALL_DEFINE4(kexec_load, unsigned long, entry, unsigned long, nr_segments,
 		struct kexec_segment __user *, segments, unsigned long, flags)
 {
 	struct kimage **dest_image, *image;
 	int result;
 	/* We only trust the superuser with rebooting the system. */
 	if (!capable(CAP_SYS_BOOT))
 		return -EPERM;
 	/*
 	 * Verify we have a legal set of flags
 	 * This leaves us room for future extensions.
 	 */
 	if ((flags & KEXEC_FLAGS) != (flags & ~KEXEC_ARCH_MASK))
 		return -EINVAL;
 	/* Verify we are on the appropriate architecture */
 	if (((flags & KEXEC_ARCH_MASK) != KEXEC_ARCH) &&
 		((flags & KEXEC_ARCH_MASK) != KEXEC_ARCH_DEFAULT))
 		return -EINVAL;
 	/* Put an artificial cap on the number
 	 * of segments passed to kexec_load.
 	 */
 	if (nr_segments > KEXEC_SEGMENT_MAX)
 		return -EINVAL;
 	image = NULL;
 	result = 0;
 	/* Because we write directly to the reserved memory
 	 * region when loading crash kernels we need a mutex here to
 	 * prevent multiple crash  kernels from attempting to load
 	 * simultaneously, and to prevent a crash kernel from loading
 	 * over the top of a in use crash kernel.
 	 *
 	 * KISS: always take the mutex.
 	 */
 	if (!mutex_trylock(&kexec_mutex))
 		return -EBUSY;
 	dest_image = &kexec_image;
 	if (flags & KEXEC_ON_CRASH)
 		dest_image = &kexec_crash_image;
 	if (nr_segments > 0) {
 		unsigned long i;
 		/* Loading another kernel to reboot into */
 		if ((flags & KEXEC_ON_CRASH) == 0)
 			result = kimage_normal_alloc(&image, entry,
 							nr_segments, segments);
 		/* Loading another kernel to switch to if this one crashes */
 		else if (flags & KEXEC_ON_CRASH) {
 			/* Free any current crash dump kernel before
 			 * we corrupt it.
 			 */
 			kimage_free(xchg(&kexec_crash_image, NULL));
 			result = kimage_crash_alloc(&image, entry,
 						     nr_segments, segments);
 			crash_map_reserved_pages();
 		}
 		if (result)
 			goto out;
 		if (flags & KEXEC_PRESERVE_CONTEXT)
 			image->preserve_context = 1;
 		result = machine_kexec_prepare(image);
 		if (result)
 			goto out;
 		for (i = 0; i < nr_segments; i++) {
 			result = kimage_load_segment(image, &image->segment[i]);
 			if (result)
 				goto out;
 		}
 		kimage_terminate(image);
 		if (flags & KEXEC_ON_CRASH)
 			crash_unmap_reserved_pages();
 	}
 	/* Install the new kernel, and  Uninstall the old */
 	image = xchg(dest_image, image);
 out:
 	mutex_unlock(&kexec_mutex);
 	kimage_free(image);
 	return result;
 }
 /*
  * Add and remove page tables for crashkernel memory
  *
  * Provide an empty default implementation here -- architecture
  * code may override this
  */
 void __weak crash_map_reserved_pages(void)
 {}
 void __weak crash_unmap_reserved_pages(void)
 {}
 #ifdef CONFIG_COMPAT
 asmlinkage long compat_sys_kexec_load(unsigned long entry,
 				unsigned long nr_segments,
 				struct compat_kexec_segment __user *segments,
 				unsigned long flags)
 {
 	struct compat_kexec_segment in;
 	struct kexec_segment out, __user *ksegments;
 	unsigned long i, result;
 	/* Don't allow clients that don't understand the native
 	 * architecture to do anything.
 	 */
 	if ((flags & KEXEC_ARCH_MASK) == KEXEC_ARCH_DEFAULT)
 		return -EINVAL;
 	if (nr_segments > KEXEC_SEGMENT_MAX)
 		return -EINVAL;
 	ksegments = compat_alloc_user_space(nr_segments * sizeof(out));
 	for (i=0; i < nr_segments; i++) {
 		result = copy_from_user(&in, &segments[i], sizeof(in));
 		if (result)
 			return -EFAULT;
 		out.buf   = compat_ptr(in.buf);
 		out.bufsz = in.bufsz;
 		out.mem   = in.mem;
 		out.memsz = in.memsz;
 		result = copy_to_user(&ksegments[i], &out, sizeof(out));
 		if (result)
 			return -EFAULT;
 	}
 	return sys_kexec_load(entry, nr_segments, ksegments, flags);
 }
 #endif
 void crash_kexec(struct pt_regs *regs)
 {
 	/* Take the kexec_mutex here to prevent sys_kexec_load
 	 * running on one cpu from replacing the crash kernel
 	 * we are using after a panic on a different cpu.
 	 *
 	 * If the crash kernel was not located in a fixed area
 	 * of memory the xchg(&kexec_crash_image) would be
 	 * sufficient.  But since I reuse the memory...
 	 */
 	if (mutex_trylock(&kexec_mutex)) {
 		if (kexec_crash_image) {
 			struct pt_regs fixed_regs;
-			kmsg_dump(KMSG_DUMP_KEXEC);
 			crash_setup_regs(&fixed_regs, regs);
 			crash_save_vmcoreinfo();
 			machine_crash_shutdown(&fixed_regs);
 			machine_kexec(kexec_crash_image);
 		}
 		mutex_unlock(&kexec_mutex);
 	}
 }
 size_t crash_get_memory_size(void)
 {
 	size_t size = 0;
 	mutex_lock(&kexec_mutex);
 	if (crashk_res.end != crashk_res.start)
 		size = resource_size(&crashk_res);
 	mutex_unlock(&kexec_mutex);
 	return size;
 }
 void __weak crash_free_reserved_phys_range(unsigned long begin,
 					   unsigned long end)
 {
 	unsigned long addr;
 	for (addr = begin; addr < end; addr += PAGE_SIZE) {
 		ClearPageReserved(pfn_to_page(addr >> PAGE_SHIFT));
 		init_page_count(pfn_to_page(addr >> PAGE_SHIFT));
 		free_page((unsigned long)__va(addr));
 		totalram_pages++;
 	}
 }
 int crash_shrink_memory(unsigned long new_size)
 {
 	int ret = 0;
 	unsigned long start, end;
 	mutex_lock(&kexec_mutex);
 	if (kexec_crash_image) {
 		ret = -ENOENT;
 		goto unlock;
 	}
 	start = crashk_res.start;
 	end = crashk_res.end;
 	if (new_size >= end - start + 1) {
 		ret = -EINVAL;
 		if (new_size == end - start + 1)
 			ret = 0;
 		goto unlock;
 	}
 	start = roundup(start, KEXEC_CRASH_MEM_ALIGN);
 	end = roundup(start + new_size, KEXEC_CRASH_MEM_ALIGN);
 	crash_map_reserved_pages();
 	crash_free_reserved_phys_range(end, crashk_res.end);
 	if ((start == end) && (crashk_res.parent != NULL))
 		release_resource(&crashk_res);
 	crashk_res.end = end - 1;
 	crash_unmap_reserved_pages();
 unlock:
 	mutex_unlock(&kexec_mutex);
 	return ret;
 }
 static u32 *append_elf_note(u32 *buf, char *name, unsigned type, void *data,
 			    size_t data_len)
 {
 	struct elf_note note;
 	note.n_namesz = strlen(name) + 1;
 	note.n_descsz = data_len;
 	note.n_type   = type;
 	memcpy(buf, &note, sizeof(note));
 	buf += (sizeof(note) + 3)/4;
 	memcpy(buf, name, note.n_namesz);
 	buf += (note.n_namesz + 3)/4;
 	memcpy(buf, data, note.n_descsz);
 	buf += (note.n_descsz + 3)/4;
 	return buf;
 }
 static void final_note(u32 *buf)
 {
 	struct elf_note note;
 	note.n_namesz = 0;
 	note.n_descsz = 0;
 	note.n_type   = 0;
 	memcpy(buf, &note, sizeof(note));
 }
 void crash_save_cpu(struct pt_regs *regs, int cpu)
 {
 	struct elf_prstatus prstatus;
 	u32 *buf;
 	if ((cpu < 0) || (cpu >= nr_cpu_ids))
 		return;
 	/* Using ELF notes here is opportunistic.
 	 * I need a well defined structure format
 	 * for the data I pass, and I need tags
 	 * on the data to indicate what information I have
 	 * squirrelled away.  ELF notes happen to provide
 	 * all of that, so there is no need to invent something new.
 	 */
 	buf = (u32*)per_cpu_ptr(crash_notes, cpu);
 	if (!buf)
 		return;
 	memset(&prstatus, 0, sizeof(prstatus));
 	prstatus.pr_pid = current->pid;
 	elf_core_copy_kernel_regs(&prstatus.pr_reg, regs);
 	buf = append_elf_note(buf, KEXEC_CORE_NOTE_NAME, NT_PRSTATUS,
 		      	      &prstatus, sizeof(prstatus));
 	final_note(buf);
 }
 static int __init crash_notes_memory_init(void)
 {
 	/* Allocate memory for saving cpu registers. */
 	crash_notes = alloc_percpu(note_buf_t);
 	if (!crash_notes) {
 		printk("Kexec: Memory allocation for saving cpu register"
 		" states failed\n");
 		return -ENOMEM;
 	}
 	return 0;
 }
 module_init(crash_notes_memory_init)
 /*
  * parsing the "crashkernel" commandline
  *
  * this code is intended to be called from architecture specific code
  */
 /*
  * This function parses command lines in the format
  *
  *   crashkernel=ramsize-range:size[,...][@offset]
  *
  * The function returns 0 on success and -EINVAL on failure.
  */
 static int __init parse_crashkernel_mem(char 			*cmdline,
 					unsigned long long	system_ram,
 					unsigned long long	*crash_size,
 					unsigned long long	*crash_base)
 {
 	char *cur = cmdline, *tmp;
 	/* for each entry of the comma-separated list */
 	do {
 		unsigned long long start, end = ULLONG_MAX, size;
 		/* get the start of the range */
 		start = memparse(cur, &tmp);
 		if (cur == tmp) {
 			pr_warning("crashkernel: Memory value expected\n");
 			return -EINVAL;
 		}
 		cur = tmp;
 		if (*cur != '-') {
 			pr_warning("crashkernel: '-' expected\n");
 			return -EINVAL;
 		}
 		cur++;
 		/* if no ':' is here, than we read the end */
 		if (*cur != ':') {
 			end = memparse(cur, &tmp);
 			if (cur == tmp) {
 				pr_warning("crashkernel: Memory "
 						"value expected\n");
 				return -EINVAL;
 			}
 			cur = tmp;
 			if (end <= start) {
 				pr_warning("crashkernel: end <= start\n");
 				return -EINVAL;
 			}
 		}
 		if (*cur != ':') {
 			pr_warning("crashkernel: ':' expected\n");
 			return -EINVAL;
 		}
 		cur++;
 		size = memparse(cur, &tmp);
 		if (cur == tmp) {
 			pr_warning("Memory value expected\n");
 			return -EINVAL;
 		}
 		cur = tmp;
 		if (size >= system_ram) {
 			pr_warning("crashkernel: invalid size\n");
 			return -EINVAL;
 		}
 		/* match ? */
 		if (system_ram >= start && system_ram < end) {
 			*crash_size = size;
 			break;
 		}
 	} while (*cur++ == ',');
 	if (*crash_size > 0) {
 		while (*cur && *cur != ' ' && *cur != '@')
 			cur++;
 		if (*cur == '@') {
 			cur++;
 			*crash_base = memparse(cur, &tmp);
 			if (cur == tmp) {
 				pr_warning("Memory value expected "
 						"after '@'\n");
 				return -EINVAL;
 			}
 		}
 	}
 	return 0;
 }
 /*
  * That function parses "simple" (old) crashkernel command lines like
  *
  * 	crashkernel=size[@offset]
  *
  * It returns 0 on success and -EINVAL on failure.
  */
 static int __init parse_crashkernel_simple(char 		*cmdline,
 					   unsigned long long 	*crash_size,
 					   unsigned long long 	*crash_base)
 {
 	char *cur = cmdline;
 	*crash_size = memparse(cmdline, &cur);
 	if (cmdline == cur) {
 		pr_warning("crashkernel: memory value expected\n");
 		return -EINVAL;
 	}
 	if (*cur == '@')
 		*crash_base = memparse(cur+1, &cur);
 	return 0;
 }
 /*
  * That function is the entry point for command line parsing and should be
  * called from the arch-specific code.
  */
 int __init parse_crashkernel(char 		 *cmdline,
 			     unsigned long long system_ram,
 			     unsigned long long *crash_size,
 			     unsigned long long *crash_base)
 {
 	char 	*p = cmdline, *ck_cmdline = NULL;
 	char	*first_colon, *first_space;
 	BUG_ON(!crash_size || !crash_base);
 	*crash_size = 0;
 	*crash_base = 0;
 	/* find crashkernel and use the last one if there are more */
 	p = strstr(p, "crashkernel=");
 	while (p) {
 		ck_cmdline = p;
 		p = strstr(p+1, "crashkernel=");
 	}
 	if (!ck_cmdline)
 		return -EINVAL;
 	ck_cmdline += 12; /* strlen("crashkernel=") */
 	/*
 	 * if the commandline contains a ':', then that's the extended
 	 * syntax -- if not, it must be the classic syntax
 	 */
 	first_colon = strchr(ck_cmdline, ':');
 	first_space = strchr(ck_cmdline, ' ');
 	if (first_colon && (!first_space || first_colon < first_space))
 		return parse_crashkernel_mem(ck_cmdline, system_ram,
 				crash_size, crash_base);
 	else
 		return parse_crashkernel_simple(ck_cmdline, crash_size,
 				crash_base);
 	return 0;
 }
 static void update_vmcoreinfo_note(void)
 {
 	u32 *buf = vmcoreinfo_note;
 	if (!vmcoreinfo_size)
 		return;
 	buf = append_elf_note(buf, VMCOREINFO_NOTE_NAME, 0, vmcoreinfo_data,
 			      vmcoreinfo_size);
 	final_note(buf);
 }
 void crash_save_vmcoreinfo(void)
 {
 	vmcoreinfo_append_str("CRASHTIME=%ld", get_seconds());
 	update_vmcoreinfo_note();
 }
 void vmcoreinfo_append_str(const char *fmt, ...)
 {
 	va_list args;
 	char buf[0x50];
 	int r;
 	va_start(args, fmt);
 	r = vsnprintf(buf, sizeof(buf), fmt, args);
 	va_end(args);
 	if (r + vmcoreinfo_size > vmcoreinfo_max_size)
 		r = vmcoreinfo_max_size - vmcoreinfo_size;
 	memcpy(&vmcoreinfo_data[vmcoreinfo_size], buf, r);
 	vmcoreinfo_size += r;
 }
 /*
  * provide an empty default implementation here -- architecture
  * code may override this
  */
 void __attribute__ ((weak)) arch_crash_save_vmcoreinfo(void)
 {}
 unsigned long __attribute__ ((weak)) paddr_vmcoreinfo_note(void)
 {
 	return __pa((unsigned long)(char *)&vmcoreinfo_note);
 }
 static int __init crash_save_vmcoreinfo_init(void)
 {
 	VMCOREINFO_OSRELEASE(init_uts_ns.name.release);
 	VMCOREINFO_PAGESIZE(PAGE_SIZE);
 	VMCOREINFO_SYMBOL(init_uts_ns);
 	VMCOREINFO_SYMBOL(node_online_map);
 	VMCOREINFO_SYMBOL(swapper_pg_dir);
 	VMCOREINFO_SYMBOL(_stext);
 	VMCOREINFO_SYMBOL(vmlist);
 #ifndef CONFIG_NEED_MULTIPLE_NODES
 	VMCOREINFO_SYMBOL(mem_map);
 	VMCOREINFO_SYMBOL(contig_page_data);
 #endif
 #ifdef CONFIG_SPARSEMEM
 	VMCOREINFO_SYMBOL(mem_section);
 	VMCOREINFO_LENGTH(mem_section, NR_SECTION_ROOTS);
 	VMCOREINFO_STRUCT_SIZE(mem_section);
 	VMCOREINFO_OFFSET(mem_section, section_mem_map);
 #endif
 	VMCOREINFO_STRUCT_SIZE(page);
 	VMCOREINFO_STRUCT_SIZE(pglist_data);
 	VMCOREINFO_STRUCT_SIZE(zone);
 	VMCOREINFO_STRUCT_SIZE(free_area);
 	VMCOREINFO_STRUCT_SIZE(list_head);
 	VMCOREINFO_SIZE(nodemask_t);
 	VMCOREINFO_OFFSET(page, flags);
 	VMCOREINFO_OFFSET(page, _count);
 	VMCOREINFO_OFFSET(page, mapping);
 	VMCOREINFO_OFFSET(page, lru);
 	VMCOREINFO_OFFSET(pglist_data, node_zones);
 	VMCOREINFO_OFFSET(pglist_data, nr_zones);
 #ifdef CONFIG_FLAT_NODE_MEM_MAP
 	VMCOREINFO_OFFSET(pglist_data, node_mem_map);
 #endif
 	VMCOREINFO_OFFSET(pglist_data, node_start_pfn);
 	VMCOREINFO_OFFSET(pglist_data, node_spanned_pages);
 	VMCOREINFO_OFFSET(pglist_data, node_id);
 	VMCOREINFO_OFFSET(zone, free_area);
 	VMCOREINFO_OFFSET(zone, vm_stat);
 	VMCOREINFO_OFFSET(zone, spanned_pages);
 	VMCOREINFO_OFFSET(free_area, free_list);
 	VMCOREINFO_OFFSET(list_head, next);
 	VMCOREINFO_OFFSET(list_head, prev);
 	VMCOREINFO_OFFSET(vm_struct, addr);
 	VMCOREINFO_LENGTH(zone.free_area, MAX_ORDER);
 	log_buf_kexec_setup();
 	VMCOREINFO_LENGTH(free_area.free_list, MIGRATE_TYPES);
 	VMCOREINFO_NUMBER(NR_FREE_PAGES);
 	VMCOREINFO_NUMBER(PG_lru);
 	VMCOREINFO_NUMBER(PG_private);
 	VMCOREINFO_NUMBER(PG_swapcache);
 	arch_crash_save_vmcoreinfo();
 	update_vmcoreinfo_note();
 	return 0;
 }
 module_init(crash_save_vmcoreinfo_init)
 /*
  * Move into place and start executing a preloaded standalone
  * executable.  If nothing was preloaded return an error.
  */
 int kernel_kexec(void)
 {
 	int error = 0;
 	if (!mutex_trylock(&kexec_mutex))
 		return -EBUSY;
 	if (!kexec_image) {
 		error = -EINVAL;
 		goto Unlock;
 	}
 #ifdef CONFIG_KEXEC_JUMP
 	if (kexec_image->preserve_context) {
 		lock_system_sleep();
 		pm_prepare_console();
 		error = freeze_processes();
 		if (error) {
 			error = -EBUSY;
 			goto Restore_console;
 		}
 		suspend_console();
 		error = dpm_suspend_start(PMSG_FREEZE);
 		if (error)
 			goto Resume_console;
 		/* At this point, dpm_suspend_start() has been called,
 		 * but *not* dpm_suspend_noirq(). We *must* call
 		 * dpm_suspend_noirq() now.  Otherwise, drivers for
 		 * some devices (e.g. interrupt controllers) become
 		 * desynchronized with the actual state of the
 		 * hardware at resume time, and evil weirdness ensues.
 		 */
 		error = dpm_suspend_noirq(PMSG_FREEZE);
 		if (error)
 			goto Resume_devices;
 		error = disable_nonboot_cpus();
 		if (error)
 			goto Enable_cpus;
 		local_irq_disable();
 		error = syscore_suspend();
 		if (error)
 			goto Enable_irqs;
 	} else
 #endif
 	{
 		kernel_restart_prepare(NULL);
 		printk(KERN_EMERG "Starting new kernel\n");
 		machine_shutdown();
 	}
 	machine_kexec(kexec_image);
 #ifdef CONFIG_KEXEC_JUMP
 	if (kexec_image->preserve_context) {
 		syscore_resume();
  Enable_irqs:
 		local_irq_enable();
  Enable_cpus:
 		enable_nonboot_cpus();
 		dpm_resume_noirq(PMSG_RESTORE);
  Resume_devices:
 		dpm_resume_end(PMSG_RESTORE);
  Resume_console:
 		resume_console();
 		thaw_processes();
  Restore_console:
 		pm_restore_console();
 		unlock_system_sleep();
 	}
 #endif
  Unlock:
 	mutex_unlock(&kexec_mutex);
 	return error;
 }

Link here
Eric Lee 2015-01-20 15:57:44 UTC

mentioned in commit 381b87

_mentioned in commit 381b87_

Choose File ... File name...
Cancel
Link here
Eric Lee 2015-01-20 15:59:28 UTC

mentioned in commit 381b87

_mentioned in commit 381b87_

Choose File ... File name...
Cancel
Link here
Eric Lee 2015-01-20 16:00:11 UTC

mentioned in commit 381b87

_mentioned in commit 381b87_

Choose File ... File name...
Cancel
Link here
Eric Lee 2015-05-06 17:10:18 UTC

mentioned in commit 381b87

_mentioned in commit 381b87_

Choose File ... File name...
Cancel
Link here
Eric Lee 2015-06-23 15:26:24 UTC

mentioned in commit 381b87

_mentioned in commit 381b87_

Choose File ... File name...
Cancel
Link here
Eric Lee 2015-08-04 07:08:03 UTC

mentioned in commit 381b87

_mentioned in commit 381b87_

Choose File ... File name...
Cancel
Link here
Eric Lee 2015-08-04 07:57:00 UTC

mentioned in commit 381b87

_mentioned in commit 381b87_

Choose File ... File name...
Cancel
Link here
Eric Lee 2016-04-06 11:00:34 UTC

mentioned in commit 381b87

_mentioned in commit 381b87_

Choose File ... File name...
Cancel
Link here
Eric Lee 2016-04-06 11:14:08 UTC

mentioned in commit 381b87

_mentioned in commit 381b87_

Choose File ... File name...
Cancel
Link here
Eric Lee 2016-05-23 04:33:20 UTC

mentioned in commit 381b87

_mentioned in commit 381b87_

Choose File ... File name...
Cancel
Link here
Eric Lee 2016-05-23 16:45:19 UTC

mentioned in commit 381b87

_mentioned in commit 381b87_

Choose File ... File name...
Cancel
Link here
Eric Lee 2016-07-29 03:31:56 UTC

mentioned in commit 381b87

_mentioned in commit 381b87_

Choose File ... File name...
Cancel
Link here
Eric Lee 2016-09-28 06:54:26 UTC

mentioned in commit 381b87

_mentioned in commit 381b87_

Choose File ... File name...
Cancel
Link here
Eric Lee 2017-01-15 14:56:39 UTC

mentioned in commit 381b87

_mentioned in commit 381b87_

Choose File ... File name...
Cancel
Link here
Eric Lee 2017-03-06 10:04:53 UTC

mentioned in commit 381b87

_mentioned in commit 381b87_

Choose File ... File name...
Cancel
Link here
Eric Lee 2018-09-03 11:30:07 UTC

mentioned in commit 381b87

_mentioned in commit 381b87_

Choose File ... File name...
Cancel
Link here
Eric Lee 2018-09-03 11:49:57 UTC

mentioned in commit 381b87

_mentioned in commit 381b87_

Choose File ... File name...
Cancel
Link here
Eric Lee 2018-09-03 12:02:08 UTC

mentioned in commit 381b87

_mentioned in commit 381b87_

Choose File ... File name...
Cancel
Link here
Eric Lee 2018-11-28 03:15:46 UTC

mentioned in commit 381b87

_mentioned in commit 381b87_

Choose File ... File name...
Cancel
Link here
Eric Lee 2019-01-14 08:25:52 UTC

mentioned in commit 381b87

_mentioned in commit 381b87_

Choose File ... File name...
Cancel
Link here
Eric Lee 2019-01-23 06:36:45 UTC

mentioned in commit 381b87

_mentioned in commit 381b87_

Choose File ... File name...
Cancel
Link here
Eric Lee 2019-03-27 12:31:53 UTC

mentioned in commit 381b87

_mentioned in commit 381b87_

Choose File ... File name...
Cancel
Link here
Eric Lee 2019-04-03 08:15:54 UTC

mentioned in commit 381b87

_mentioned in commit 381b87_

Choose File ... File name...
Cancel
Link here
Eric Lee 2019-04-27 07:49:52 UTC

mentioned in commit 381b87

_mentioned in commit 381b87_

Choose File ... File name...
Cancel
Link here
Eric Lee 2019-07-10 04:10:11 UTC

mentioned in commit 381b87

_mentioned in commit 381b87_

Choose File ... File name...
Cancel
Link here
Eric Lee 2019-11-01 15:27:13 UTC

mentioned in commit 381b87

_mentioned in commit 381b87_

Choose File ... File name...
Cancel
Link here
Eric Lee 2019-11-11 02:55:15 UTC

mentioned in commit 381b87

_mentioned in commit 381b87_

Choose File ... File name...
Cancel
Link here
Eric Lee 2019-11-25 02:34:15 UTC

mentioned in commit 381b87

_mentioned in commit 381b87_

Choose File ... File name...
Cancel
Link here
Eric Lee 2019-12-09 02:57:16 UTC

mentioned in commit 381b87

_mentioned in commit 381b87_

Choose File ... File name...
Cancel
Link here
Eric Lee 2020-01-15 02:22:46 UTC

mentioned in commit 381b87

_mentioned in commit 381b87_

Choose File ... File name...
Cancel
Link here
Eric Lee 2020-04-16 03:46:03 UTC

mentioned in commit 381b87

_mentioned in commit 381b87_

Choose File ... File name...
Cancel
Link here
Eric Lee 2020-05-08 05:41:36 UTC

mentioned in commit 381b87

_mentioned in commit 381b87_

Choose File ... File name...
Cancel
Link here
Eric Lee 2020-07-07 10:54:13 UTC

mentioned in commit 381b87

_mentioned in commit 381b87_

Choose File ... File name...
Cancel
Link here
Eric Lee 2020-08-14 06:14:54 UTC

mentioned in commit 381b87

_mentioned in commit 381b87_

Choose File ... File name...
Cancel
Link here
Eric Lee 2020-09-08 09:00:54 UTC

mentioned in commit 381b87

_mentioned in commit 381b87_

Choose File ... File name...
Cancel
Link here
Eric Lee 2021-04-28 07:48:15 UTC

mentioned in commit 381b87

_mentioned in commit 381b87_

Choose File ... File name...
Cancel
Link here
Eric Lee 2021-10-31 07:31:17 UTC

mentioned in commit 381b87

_mentioned in commit 381b87_

Choose File ... File name...
Cancel
Link here
Eric Lee 2021-12-10 06:58:20 UTC

mentioned in commit 381b87

_mentioned in commit 381b87_

Choose File ... File name...
Cancel
Link here
Eric Lee 2021-12-14 03:51:33 UTC

mentioned in commit 381b87

_mentioned in commit 381b87_

Choose File ... File name...
Cancel
Link here
Eric Lee 2022-06-14 08:05:04 UTC

mentioned in commit 381b87

_mentioned in commit 381b87_

Choose File ... File name...
Cancel
Link here
Eric Lee 2023-05-03 12:24:34 UTC

mentioned in commit 381b87

_mentioned in commit 381b87_

Choose File ... File name...
Cancel
Link here
Eric Lee 2023-05-08 10:14:30 UTC

mentioned in commit 381b87

_mentioned in commit 381b87_

Choose File ... File name...
Cancel
Link here
Eric Lee 2023-05-26 07:52:25 UTC

mentioned in commit 381b87

_mentioned in commit 381b87_

Choose File ... File name...
Cancel
Link here
Eric Lee 2024-07-24 10:11:19 UTC

mentioned in commit 381b87

_mentioned in commit 381b87_

Choose File ... File name...
Cancel