* [PATCH] kdump: introduce "reset_devices" command line option
@ 2011-02-04 15:28 Olaf Hering
2011-02-04 15:30 ` [PATCH] reset PV devices in crash kernel Olaf Hering
0 siblings, 1 reply; 6+ messages in thread
From: Olaf Hering @ 2011-02-04 15:28 UTC (permalink / raw)
To: xen-devel
upstream commit 7e96287ddc4f42081e18248b6167041c0908004c
Author: Vivek Goyal <vgoyal@in.ibm.com>
[PATCH] kdump: introduce "reset_devices" command line option
Resetting the devices during driver initialization can be a costly
operation in terms of time (especially scsi devices). This option can be
used by drivers to know that user forcibly wants the devices to be reset
during initialization.
This option can be useful while kernel is booting in unreliable
environment. For ex. during kdump boot where devices are in unknown
random state and BIOS execution has been skipped.
Signed-off-by: Vivek Goyal <vgoyal@in.ibm.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
---
This change from 2.6.19-rc1 is required for the following kdump patch.
Documentation/kernel-parameters.txt | 3 +++
include/linux/init.h | 1 +
init/main.c | 20 ++++++++++++++++++++
3 files changed, 24 insertions(+)
--- linux-2.6.18-xen.hg.orig/Documentation/kernel-parameters.txt
+++ linux-2.6.18-xen.hg/Documentation/kernel-parameters.txt
@@ -1392,6 +1392,9 @@ running once the system is up.
reserve= [KNL,BUGS] Force the kernel to ignore some iomem area
+ reset_devices [KNL] Force drivers to reset the underlying device
+ during initialization.
+
resume= [SWSUSP]
Specify the partition device for software suspend
--- linux-2.6.18-xen.hg.orig/include/linux/init.h
+++ linux-2.6.18-xen.hg/include/linux/init.h
@@ -68,6 +68,7 @@ extern initcall_t __security_initcall_st
/* Defined in init/main.c */
extern char saved_command_line[];
+extern unsigned int reset_devices;
/* used by init/main.c */
extern void setup_arch(char **);
--- linux-2.6.18-xen.hg.orig/init/main.c
+++ linux-2.6.18-xen.hg/init/main.c
@@ -128,6 +128,18 @@ static char *ramdisk_execute_command;
static unsigned int max_cpus = NR_CPUS;
/*
+ * If set, this is an indication to the drivers that reset the underlying
+ * device before going ahead with the initialization otherwise driver might
+ * rely on the BIOS and skip the reset operation.
+ *
+ * This is useful if kernel is booting in an unreliable environment.
+ * For ex. kdump situaiton where previous kernel has crashed, BIOS has been
+ * skipped and devices will be in unknown state.
+ */
+unsigned int reset_devices;
+EXPORT_SYMBOL(reset_devices);
+
+/*
* Setup routine for controlling SMP activation
*
* Command-line option of "nosmp" or "maxcpus=0" will disable SMP
@@ -153,6 +165,14 @@ static int __init maxcpus(char *str)
__setup("maxcpus=", maxcpus);
+static int __init set_reset_devices(char *str)
+{
+ reset_devices = 1;
+ return 1;
+}
+
+__setup("reset_devices", set_reset_devices);
+
static char * argv_init[MAX_INIT_ARGS+2] = { "init", NULL, };
char * envp_init[MAX_INIT_ENVS+2] = { "HOME=/", "TERM=linux", NULL, };
static const char *panic_later, *panic_param;
^ permalink raw reply [flat|nested] 6+ messages in thread
* [PATCH] reset PV devices in crash kernel
2011-02-04 15:28 [PATCH] kdump: introduce "reset_devices" command line option Olaf Hering
@ 2011-02-04 15:30 ` Olaf Hering
2011-02-07 16:28 ` Olaf Hering
2011-04-01 10:16 ` Olaf Hering
0 siblings, 2 replies; 6+ messages in thread
From: Olaf Hering @ 2011-02-04 15:30 UTC (permalink / raw)
To: xen-devel
After triggering a crash dump in a HVM guest, the PV backend drivers
will remain in connected state. When the kdump kernel starts the PV
drivers will skip such devices. As a result, no root device is found
and the vmcore cant be saved.
With this change all frontend devices with state XenbusStateConnected
will be reset by changing the state file to Closing/Closed/Initializing.
This will trigger a disconnect in the backend drivers. Now the frontend
drivers will find the backend drivers in state Initwait and can connect.
Signed-off-by: Olaf Hering <olaf@aepfle.de>
---
drivers/xen/xenbus/xenbus_comms.c | 4 +
drivers/xen/xenbus/xenbus_probe.c | 96 ++++++++++++++++++++++++++++++++++++++
2 files changed, 99 insertions(+), 1 deletion(-)
--- linux-2.6.18-xen.hg.orig/drivers/xen/xenbus/xenbus_comms.c
+++ linux-2.6.18-xen.hg/drivers/xen/xenbus/xenbus_comms.c
@@ -234,7 +234,9 @@ int xb_init_comms(void)
printk(KERN_WARNING "XENBUS response ring is not quiescent "
"(%08x:%08x): fixing up\n",
intf->rsp_cons, intf->rsp_prod);
- intf->rsp_cons = intf->rsp_prod;
+ /* breaks kdump */
+ if (!reset_devices)
+ intf->rsp_cons = intf->rsp_prod;
}
if (xenbus_irq)
--- linux-2.6.18-xen.hg.orig/drivers/xen/xenbus/xenbus_probe.c
+++ linux-2.6.18-xen.hg/drivers/xen/xenbus/xenbus_probe.c
@@ -854,11 +854,107 @@ void unregister_xenstore_notifier(struct
}
EXPORT_SYMBOL_GPL(unregister_xenstore_notifier);
+#ifdef CONFIG_CRASH_DUMP
+static DECLARE_WAIT_QUEUE_HEAD(be_state_wq);
+static int be_state;
+
+static void xenbus_reset_state_changed(struct xenbus_watch *w, const char **v, unsigned int l)
+{
+ xenbus_scanf(XBT_NIL, v[XS_WATCH_PATH], "", "%i", &be_state);
+ printk(KERN_INFO "XENBUS: %s %s", v[XS_WATCH_PATH], xenbus_strstate(be_state));
+ wake_up(&be_state_wq);
+}
+
+static int xenbus_reset_check_final(int *st)
+{
+ return *st == XenbusStateInitialising || *st == XenbusStateInitWait;
+}
+
+static void xenbus_reset_frontend_state(char *backend, char *frontend)
+{
+ struct xenbus_watch watch;
+
+ memset(&watch, 0, sizeof(watch));
+ watch.node = kasprintf(GFP_NOIO | __GFP_HIGH, "%s/state", backend);
+ if (!watch.node)
+ return;
+
+ watch.callback = xenbus_reset_state_changed;
+ be_state = XenbusStateUnknown;
+
+ printk(KERN_INFO "triggering reconnect on %s", backend);
+ register_xenbus_watch(&watch);
+
+ xenbus_printf(XBT_NIL, frontend, "state", "%d", XenbusStateClosing);
+ wait_event_interruptible(be_state_wq, be_state == XenbusStateClosing);
+
+ xenbus_printf(XBT_NIL, frontend, "state", "%d", XenbusStateClosed);
+ wait_event_interruptible(be_state_wq, be_state == XenbusStateClosed);
+
+ xenbus_printf(XBT_NIL, frontend, "state", "%d", XenbusStateInitialising);
+ wait_event_interruptible(be_state_wq, xenbus_reset_check_final(&be_state));
+
+ unregister_xenbus_watch(&watch);
+ printk(KERN_INFO "reconnect done on %s", backend);
+ kfree(watch.node);
+}
+
+static void xenbus_reset_check_state(char *frontend)
+{
+ int state, err;
+ char *backend;
+
+ err = xenbus_scanf(XBT_NIL, frontend, "state", "%i", &state);
+ /* frontend connected? */
+ if (err == 1 && state == XenbusStateConnected) {
+ backend = xenbus_read(XBT_NIL, frontend, "backend", NULL);
+ if (!backend || IS_ERR(backend))
+ return;
+ err = xenbus_scanf(XBT_NIL, backend, "state", "%i", &state);
+ /* backend connected? */
+ if (err == 1 && state == XenbusStateConnected)
+ xenbus_reset_frontend_state(backend, frontend);
+ kfree(backend);
+ }
+}
+
+static void xenbus_reset_state(void)
+{
+ char *frontend;
+ char **devclass, **dev;
+ int devclass_n, dev_n;
+ int i, j;
+
+ devclass = xenbus_directory(XBT_NIL, "device", "", &devclass_n);
+ if (IS_ERR(devclass))
+ return;
+
+ for (i = 0; i < devclass_n; i++) {
+ dev = xenbus_directory(XBT_NIL, "device", devclass[i], &dev_n);
+ if (IS_ERR(dev))
+ continue;
+ for (j = 0; j < dev_n; j++) {
+ frontend = kasprintf(GFP_NOIO|__GFP_HIGH, "device/%s/%s", devclass[i], dev[j]);
+ if (!frontend)
+ continue;
+ xenbus_reset_check_state(frontend);
+ kfree(frontend);
+ }
+ kfree(dev);
+ }
+ kfree(devclass);
+}
+#endif
void xenbus_probe(void *unused)
{
BUG_ON(!is_xenstored_ready());
+#ifdef CONFIG_CRASH_DUMP
+ /* reset devices in XenbusStateConnected state */
+ if (!is_initial_xendomain() && reset_devices)
+ xenbus_reset_state();
+#endif
/* Enumerate devices in xenstore and watch for changes. */
xenbus_probe_devices(&xenbus_frontend);
register_xenbus_watch(&fe_watch);
^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [PATCH] reset PV devices in crash kernel
2011-02-04 15:30 ` [PATCH] reset PV devices in crash kernel Olaf Hering
@ 2011-02-07 16:28 ` Olaf Hering
2011-02-07 17:16 ` Konrad Rzeszutek Wilk
2011-04-01 10:16 ` Olaf Hering
1 sibling, 1 reply; 6+ messages in thread
From: Olaf Hering @ 2011-02-07 16:28 UTC (permalink / raw)
To: xen-devel
After triggering a crash dump in a HVM guest, the PV backend drivers
will remain in connected state. When the kdump kernel starts the PV
drivers will skip such devices. As a result, no root device is found
and the vmcore cant be saved.
With this change all frontend devices with state XenbusStateConnected
will be reset by changing the state file to Closing/Closed/Initializing.
This will trigger a disconnect in the backend drivers. Now the frontend
drivers will find the backend drivers in state Initwait and can connect.
Signed-off-by: Olaf Hering <olaf@aepfle.de>
---
v2:
add missing newlines to new printk() output
drivers/xen/xenbus/xenbus_comms.c | 4 +
drivers/xen/xenbus/xenbus_probe.c | 96 ++++++++++++++++++++++++++++++++++++++
2 files changed, 99 insertions(+), 1 deletion(-)
Index: linux-2.6.18-xen.hg/drivers/xen/xenbus/xenbus_comms.c
===================================================================
--- linux-2.6.18-xen.hg.orig/drivers/xen/xenbus/xenbus_comms.c
+++ linux-2.6.18-xen.hg/drivers/xen/xenbus/xenbus_comms.c
@@ -234,7 +234,9 @@ int xb_init_comms(void)
printk(KERN_WARNING "XENBUS response ring is not quiescent "
"(%08x:%08x): fixing up\n",
intf->rsp_cons, intf->rsp_prod);
- intf->rsp_cons = intf->rsp_prod;
+ /* breaks kdump */
+ if (!reset_devices)
+ intf->rsp_cons = intf->rsp_prod;
}
if (xenbus_irq)
Index: linux-2.6.18-xen.hg/drivers/xen/xenbus/xenbus_probe.c
===================================================================
--- linux-2.6.18-xen.hg.orig/drivers/xen/xenbus/xenbus_probe.c
+++ linux-2.6.18-xen.hg/drivers/xen/xenbus/xenbus_probe.c
@@ -854,11 +854,107 @@ void unregister_xenstore_notifier(struct
}
EXPORT_SYMBOL_GPL(unregister_xenstore_notifier);
+#ifdef CONFIG_CRASH_DUMP
+static DECLARE_WAIT_QUEUE_HEAD(be_state_wq);
+static int be_state;
+
+static void xenbus_reset_state_changed(struct xenbus_watch *w, const char **v, unsigned int l)
+{
+ xenbus_scanf(XBT_NIL, v[XS_WATCH_PATH], "", "%i", &be_state);
+ printk(KERN_INFO "XENBUS: %s %s\n", v[XS_WATCH_PATH], xenbus_strstate(be_state));
+ wake_up(&be_state_wq);
+}
+
+static int xenbus_reset_check_final(int *st)
+{
+ return *st == XenbusStateInitialising || *st == XenbusStateInitWait;
+}
+
+static void xenbus_reset_frontend_state(char *backend, char *frontend)
+{
+ struct xenbus_watch watch;
+
+ memset(&watch, 0, sizeof(watch));
+ watch.node = kasprintf(GFP_NOIO | __GFP_HIGH, "%s/state", backend);
+ if (!watch.node)
+ return;
+
+ watch.callback = xenbus_reset_state_changed;
+ be_state = XenbusStateUnknown;
+
+ printk(KERN_INFO "triggering reconnect on %s\n", backend);
+ register_xenbus_watch(&watch);
+
+ xenbus_printf(XBT_NIL, frontend, "state", "%d", XenbusStateClosing);
+ wait_event_interruptible(be_state_wq, be_state == XenbusStateClosing);
+
+ xenbus_printf(XBT_NIL, frontend, "state", "%d", XenbusStateClosed);
+ wait_event_interruptible(be_state_wq, be_state == XenbusStateClosed);
+
+ xenbus_printf(XBT_NIL, frontend, "state", "%d", XenbusStateInitialising);
+ wait_event_interruptible(be_state_wq, xenbus_reset_check_final(&be_state));
+
+ unregister_xenbus_watch(&watch);
+ printk(KERN_INFO "reconnect done on %s\n", backend);
+ kfree(watch.node);
+}
+
+static void xenbus_reset_check_state(char *frontend)
+{
+ int state, err;
+ char *backend;
+
+ err = xenbus_scanf(XBT_NIL, frontend, "state", "%i", &state);
+ /* frontend connected? */
+ if (err == 1 && state == XenbusStateConnected) {
+ backend = xenbus_read(XBT_NIL, frontend, "backend", NULL);
+ if (!backend || IS_ERR(backend))
+ return;
+ err = xenbus_scanf(XBT_NIL, backend, "state", "%i", &state);
+ /* backend connected? */
+ if (err == 1 && state == XenbusStateConnected)
+ xenbus_reset_frontend_state(backend, frontend);
+ kfree(backend);
+ }
+}
+
+static void xenbus_reset_state(void)
+{
+ char *frontend;
+ char **devclass, **dev;
+ int devclass_n, dev_n;
+ int i, j;
+
+ devclass = xenbus_directory(XBT_NIL, "device", "", &devclass_n);
+ if (IS_ERR(devclass))
+ return;
+
+ for (i = 0; i < devclass_n; i++) {
+ dev = xenbus_directory(XBT_NIL, "device", devclass[i], &dev_n);
+ if (IS_ERR(dev))
+ continue;
+ for (j = 0; j < dev_n; j++) {
+ frontend = kasprintf(GFP_NOIO|__GFP_HIGH, "device/%s/%s", devclass[i], dev[j]);
+ if (!frontend)
+ continue;
+ xenbus_reset_check_state(frontend);
+ kfree(frontend);
+ }
+ kfree(dev);
+ }
+ kfree(devclass);
+}
+#endif
void xenbus_probe(void *unused)
{
BUG_ON(!is_xenstored_ready());
+#ifdef CONFIG_CRASH_DUMP
+ /* reset devices in XenbusStateConnected state */
+ if (!is_initial_xendomain() && reset_devices)
+ xenbus_reset_state();
+#endif
/* Enumerate devices in xenstore and watch for changes. */
xenbus_probe_devices(&xenbus_frontend);
register_xenbus_watch(&fe_watch);
^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: Re: [PATCH] reset PV devices in crash kernel
2011-02-07 16:28 ` Olaf Hering
@ 2011-02-07 17:16 ` Konrad Rzeszutek Wilk
2011-02-07 17:42 ` Olaf Hering
0 siblings, 1 reply; 6+ messages in thread
From: Konrad Rzeszutek Wilk @ 2011-02-07 17:16 UTC (permalink / raw)
To: Olaf Hering; +Cc: xen-devel
On Mon, Feb 07, 2011 at 05:28:09PM +0100, Olaf Hering wrote:
>
> After triggering a crash dump in a HVM guest, the PV backend drivers
> will remain in connected state. When the kdump kernel starts the PV
> drivers will skip such devices. As a result, no root device is found
> and the vmcore cant be saved.
>
> With this change all frontend devices with state XenbusStateConnected
> will be reset by changing the state file to Closing/Closed/Initializing.
> This will trigger a disconnect in the backend drivers. Now the frontend
> drivers will find the backend drivers in state Initwait and can connect.
Do you have a similar patch for the pv-ops?
>
> Signed-off-by: Olaf Hering <olaf@aepfle.de>
>
> ---
> v2:
> add missing newlines to new printk() output
>
> drivers/xen/xenbus/xenbus_comms.c | 4 +
> drivers/xen/xenbus/xenbus_probe.c | 96 ++++++++++++++++++++++++++++++++++++++
> 2 files changed, 99 insertions(+), 1 deletion(-)
>
> Index: linux-2.6.18-xen.hg/drivers/xen/xenbus/xenbus_comms.c
> ===================================================================
> --- linux-2.6.18-xen.hg.orig/drivers/xen/xenbus/xenbus_comms.c
> +++ linux-2.6.18-xen.hg/drivers/xen/xenbus/xenbus_comms.c
> @@ -234,7 +234,9 @@ int xb_init_comms(void)
> printk(KERN_WARNING "XENBUS response ring is not quiescent "
> "(%08x:%08x): fixing up\n",
> intf->rsp_cons, intf->rsp_prod);
> - intf->rsp_cons = intf->rsp_prod;
> + /* breaks kdump */
> + if (!reset_devices)
> + intf->rsp_cons = intf->rsp_prod;
> }
>
> if (xenbus_irq)
> Index: linux-2.6.18-xen.hg/drivers/xen/xenbus/xenbus_probe.c
> ===================================================================
> --- linux-2.6.18-xen.hg.orig/drivers/xen/xenbus/xenbus_probe.c
> +++ linux-2.6.18-xen.hg/drivers/xen/xenbus/xenbus_probe.c
> @@ -854,11 +854,107 @@ void unregister_xenstore_notifier(struct
> }
> EXPORT_SYMBOL_GPL(unregister_xenstore_notifier);
>
> +#ifdef CONFIG_CRASH_DUMP
> +static DECLARE_WAIT_QUEUE_HEAD(be_state_wq);
> +static int be_state;
> +
> +static void xenbus_reset_state_changed(struct xenbus_watch *w, const char **v, unsigned int l)
> +{
> + xenbus_scanf(XBT_NIL, v[XS_WATCH_PATH], "", "%i", &be_state);
> + printk(KERN_INFO "XENBUS: %s %s\n", v[XS_WATCH_PATH], xenbus_strstate(be_state));
> + wake_up(&be_state_wq);
> +}
> +
> +static int xenbus_reset_check_final(int *st)
> +{
> + return *st == XenbusStateInitialising || *st == XenbusStateInitWait;
> +}
> +
> +static void xenbus_reset_frontend_state(char *backend, char *frontend)
> +{
> + struct xenbus_watch watch;
> +
> + memset(&watch, 0, sizeof(watch));
> + watch.node = kasprintf(GFP_NOIO | __GFP_HIGH, "%s/state", backend);
> + if (!watch.node)
> + return;
> +
> + watch.callback = xenbus_reset_state_changed;
> + be_state = XenbusStateUnknown;
> +
> + printk(KERN_INFO "triggering reconnect on %s\n", backend);
> + register_xenbus_watch(&watch);
> +
> + xenbus_printf(XBT_NIL, frontend, "state", "%d", XenbusStateClosing);
> + wait_event_interruptible(be_state_wq, be_state == XenbusStateClosing);
> +
> + xenbus_printf(XBT_NIL, frontend, "state", "%d", XenbusStateClosed);
> + wait_event_interruptible(be_state_wq, be_state == XenbusStateClosed);
> +
> + xenbus_printf(XBT_NIL, frontend, "state", "%d", XenbusStateInitialising);
> + wait_event_interruptible(be_state_wq, xenbus_reset_check_final(&be_state));
> +
> + unregister_xenbus_watch(&watch);
> + printk(KERN_INFO "reconnect done on %s\n", backend);
> + kfree(watch.node);
> +}
> +
> +static void xenbus_reset_check_state(char *frontend)
> +{
> + int state, err;
> + char *backend;
> +
> + err = xenbus_scanf(XBT_NIL, frontend, "state", "%i", &state);
> + /* frontend connected? */
> + if (err == 1 && state == XenbusStateConnected) {
> + backend = xenbus_read(XBT_NIL, frontend, "backend", NULL);
> + if (!backend || IS_ERR(backend))
> + return;
> + err = xenbus_scanf(XBT_NIL, backend, "state", "%i", &state);
> + /* backend connected? */
> + if (err == 1 && state == XenbusStateConnected)
> + xenbus_reset_frontend_state(backend, frontend);
> + kfree(backend);
> + }
> +}
> +
> +static void xenbus_reset_state(void)
> +{
> + char *frontend;
> + char **devclass, **dev;
> + int devclass_n, dev_n;
> + int i, j;
> +
> + devclass = xenbus_directory(XBT_NIL, "device", "", &devclass_n);
> + if (IS_ERR(devclass))
> + return;
> +
> + for (i = 0; i < devclass_n; i++) {
> + dev = xenbus_directory(XBT_NIL, "device", devclass[i], &dev_n);
> + if (IS_ERR(dev))
> + continue;
> + for (j = 0; j < dev_n; j++) {
> + frontend = kasprintf(GFP_NOIO|__GFP_HIGH, "device/%s/%s", devclass[i], dev[j]);
> + if (!frontend)
> + continue;
> + xenbus_reset_check_state(frontend);
> + kfree(frontend);
> + }
> + kfree(dev);
> + }
> + kfree(devclass);
> +}
> +#endif
>
> void xenbus_probe(void *unused)
> {
> BUG_ON(!is_xenstored_ready());
>
> +#ifdef CONFIG_CRASH_DUMP
> + /* reset devices in XenbusStateConnected state */
> + if (!is_initial_xendomain() && reset_devices)
> + xenbus_reset_state();
> +#endif
> /* Enumerate devices in xenstore and watch for changes. */
> xenbus_probe_devices(&xenbus_frontend);
> register_xenbus_watch(&fe_watch);
>
> _______________________________________________
> Xen-devel mailing list
> Xen-devel@lists.xensource.com
> http://lists.xensource.com/xen-devel
^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: Re: [PATCH] reset PV devices in crash kernel
2011-02-07 17:16 ` Konrad Rzeszutek Wilk
@ 2011-02-07 17:42 ` Olaf Hering
0 siblings, 0 replies; 6+ messages in thread
From: Olaf Hering @ 2011-02-07 17:42 UTC (permalink / raw)
To: Konrad Rzeszutek Wilk; +Cc: xen-devel
On Mon, Feb 07, Konrad Rzeszutek Wilk wrote:
> On Mon, Feb 07, 2011 at 05:28:09PM +0100, Olaf Hering wrote:
> >
> > After triggering a crash dump in a HVM guest, the PV backend drivers
> > will remain in connected state. When the kdump kernel starts the PV
> > drivers will skip such devices. As a result, no root device is found
> > and the vmcore cant be saved.
> >
> > With this change all frontend devices with state XenbusStateConnected
> > will be reset by changing the state file to Closing/Closed/Initializing.
> > This will trigger a disconnect in the backend drivers. Now the frontend
> > drivers will find the backend drivers in state Initwait and can connect.
>
> Do you have a similar patch for the pv-ops?
No yet, due to lack of pv-ops kernel on my side.
I will try to get one up and running soon.
Olaf
^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [PATCH] reset PV devices in crash kernel
2011-02-04 15:30 ` [PATCH] reset PV devices in crash kernel Olaf Hering
2011-02-07 16:28 ` Olaf Hering
@ 2011-04-01 10:16 ` Olaf Hering
1 sibling, 0 replies; 6+ messages in thread
From: Olaf Hering @ 2011-04-01 10:16 UTC (permalink / raw)
To: xen-devel
On Fri, Feb 04, Olaf Hering wrote:
Ping?
Can this and the reset_devices patch be applied to the 2.6.18 tree?
Olaf
>
> After triggering a crash dump in a HVM guest, the PV backend drivers
> will remain in connected state. When the kdump kernel starts the PV
> drivers will skip such devices. As a result, no root device is found
> and the vmcore cant be saved.
>
> With this change all frontend devices with state XenbusStateConnected
> will be reset by changing the state file to Closing/Closed/Initializing.
> This will trigger a disconnect in the backend drivers. Now the frontend
> drivers will find the backend drivers in state Initwait and can connect.
>
> Signed-off-by: Olaf Hering <olaf@aepfle.de>
>
> ---
> drivers/xen/xenbus/xenbus_comms.c | 4 +
> drivers/xen/xenbus/xenbus_probe.c | 96 ++++++++++++++++++++++++++++++++++++++
> 2 files changed, 99 insertions(+), 1 deletion(-)
>
> --- linux-2.6.18-xen.hg.orig/drivers/xen/xenbus/xenbus_comms.c
> +++ linux-2.6.18-xen.hg/drivers/xen/xenbus/xenbus_comms.c
> @@ -234,7 +234,9 @@ int xb_init_comms(void)
> printk(KERN_WARNING "XENBUS response ring is not quiescent "
> "(%08x:%08x): fixing up\n",
> intf->rsp_cons, intf->rsp_prod);
> - intf->rsp_cons = intf->rsp_prod;
> + /* breaks kdump */
> + if (!reset_devices)
> + intf->rsp_cons = intf->rsp_prod;
> }
>
> if (xenbus_irq)
> --- linux-2.6.18-xen.hg.orig/drivers/xen/xenbus/xenbus_probe.c
> +++ linux-2.6.18-xen.hg/drivers/xen/xenbus/xenbus_probe.c
> @@ -854,11 +854,107 @@ void unregister_xenstore_notifier(struct
> }
> EXPORT_SYMBOL_GPL(unregister_xenstore_notifier);
>
> +#ifdef CONFIG_CRASH_DUMP
> +static DECLARE_WAIT_QUEUE_HEAD(be_state_wq);
> +static int be_state;
> +
> +static void xenbus_reset_state_changed(struct xenbus_watch *w, const char **v, unsigned int l)
> +{
> + xenbus_scanf(XBT_NIL, v[XS_WATCH_PATH], "", "%i", &be_state);
> + printk(KERN_INFO "XENBUS: %s %s", v[XS_WATCH_PATH], xenbus_strstate(be_state));
> + wake_up(&be_state_wq);
> +}
> +
> +static int xenbus_reset_check_final(int *st)
> +{
> + return *st == XenbusStateInitialising || *st == XenbusStateInitWait;
> +}
> +
> +static void xenbus_reset_frontend_state(char *backend, char *frontend)
> +{
> + struct xenbus_watch watch;
> +
> + memset(&watch, 0, sizeof(watch));
> + watch.node = kasprintf(GFP_NOIO | __GFP_HIGH, "%s/state", backend);
> + if (!watch.node)
> + return;
> +
> + watch.callback = xenbus_reset_state_changed;
> + be_state = XenbusStateUnknown;
> +
> + printk(KERN_INFO "triggering reconnect on %s", backend);
> + register_xenbus_watch(&watch);
> +
> + xenbus_printf(XBT_NIL, frontend, "state", "%d", XenbusStateClosing);
> + wait_event_interruptible(be_state_wq, be_state == XenbusStateClosing);
> +
> + xenbus_printf(XBT_NIL, frontend, "state", "%d", XenbusStateClosed);
> + wait_event_interruptible(be_state_wq, be_state == XenbusStateClosed);
> +
> + xenbus_printf(XBT_NIL, frontend, "state", "%d", XenbusStateInitialising);
> + wait_event_interruptible(be_state_wq, xenbus_reset_check_final(&be_state));
> +
> + unregister_xenbus_watch(&watch);
> + printk(KERN_INFO "reconnect done on %s", backend);
> + kfree(watch.node);
> +}
> +
> +static void xenbus_reset_check_state(char *frontend)
> +{
> + int state, err;
> + char *backend;
> +
> + err = xenbus_scanf(XBT_NIL, frontend, "state", "%i", &state);
> + /* frontend connected? */
> + if (err == 1 && state == XenbusStateConnected) {
> + backend = xenbus_read(XBT_NIL, frontend, "backend", NULL);
> + if (!backend || IS_ERR(backend))
> + return;
> + err = xenbus_scanf(XBT_NIL, backend, "state", "%i", &state);
> + /* backend connected? */
> + if (err == 1 && state == XenbusStateConnected)
> + xenbus_reset_frontend_state(backend, frontend);
> + kfree(backend);
> + }
> +}
> +
> +static void xenbus_reset_state(void)
> +{
> + char *frontend;
> + char **devclass, **dev;
> + int devclass_n, dev_n;
> + int i, j;
> +
> + devclass = xenbus_directory(XBT_NIL, "device", "", &devclass_n);
> + if (IS_ERR(devclass))
> + return;
> +
> + for (i = 0; i < devclass_n; i++) {
> + dev = xenbus_directory(XBT_NIL, "device", devclass[i], &dev_n);
> + if (IS_ERR(dev))
> + continue;
> + for (j = 0; j < dev_n; j++) {
> + frontend = kasprintf(GFP_NOIO|__GFP_HIGH, "device/%s/%s", devclass[i], dev[j]);
> + if (!frontend)
> + continue;
> + xenbus_reset_check_state(frontend);
> + kfree(frontend);
> + }
> + kfree(dev);
> + }
> + kfree(devclass);
> +}
> +#endif
>
> void xenbus_probe(void *unused)
> {
> BUG_ON(!is_xenstored_ready());
>
> +#ifdef CONFIG_CRASH_DUMP
> + /* reset devices in XenbusStateConnected state */
> + if (!is_initial_xendomain() && reset_devices)
> + xenbus_reset_state();
> +#endif
> /* Enumerate devices in xenstore and watch for changes. */
> xenbus_probe_devices(&xenbus_frontend);
> register_xenbus_watch(&fe_watch);
^ permalink raw reply [flat|nested] 6+ messages in thread
end of thread, other threads:[~2011-04-01 10:16 UTC | newest]
Thread overview: 6+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2011-02-04 15:28 [PATCH] kdump: introduce "reset_devices" command line option Olaf Hering
2011-02-04 15:30 ` [PATCH] reset PV devices in crash kernel Olaf Hering
2011-02-07 16:28 ` Olaf Hering
2011-02-07 17:16 ` Konrad Rzeszutek Wilk
2011-02-07 17:42 ` Olaf Hering
2011-04-01 10:16 ` Olaf Hering
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.