[PATCH 0/3] Introduce Xen fault injection facility

[PATCH 0/3] Introduce Xen fault injection facility

[Stanislav Kinsburskii]

VGhpcyBzZXJpZXMgYWRkcyBhIGZhY2lsaXR5LCB3aGljaCBjYW4gYmUgdXNlZCB0byBpbnN0cnVt
ZW50IFhlbiBjb2RlIHdpdGgKZmF1bHQgaW5qZWN0aW9ucy4KSXQgaXMgYmFzZWQgIkZhdWx0IGlu
amVjdGlvbiBjYXBhYmlsaXRpZXMgaW5mcmFzdHJ1Y3R1cmUiIGRlc2NyaWJlZCBoZXJlOgotIERv
Y3VtZW50YXRpb24vZmF1bHQtaW5qZWN0aW9uL2ZhdWx0LWluamVjdGlvbi50eHQKCkZpcnN0IHBh
dGNoIGFkZHMgYSBnZW5lcmljIGZhY2lsaXR5IHRvIHVzZSBhbnl3aGVyZSBpbiBYZW4uCldoZW4g
dXNpbmcgaXQgYWxsIHRoZSBmYXVsdCBpbmplY3Rpb24gdXNlciBsYW5kIGNvbnRyb2wgZGlyZWN0
b3JpZXMgKGlmCmFueSkgd2lsbCBhcHBlYXIgaGVyZToKLSAvc3lzL2tlcm5lbC9kZWJ1Zy94ZW4v
ZmF1bHRfaW5qZWN0LwoKVG8gZGlzdGluZ3Vpc2ggd2l0aCBnZW5lcmljIChvciBjb3JlKSBYZW4g
ZmF1bHQgaW5qZWN0aW9ucywgbmV4dCB0d28KcGF0Y2hlcyBhZGQgYWRkaXRpb25hbCBkaXJlY3Rv
cmllcyB0byB0aGUgcm9vdCBwYXRoIGFib3ZlIGZvciBibGtiYWNrIGFuZApuZXRiYWNrIGRyaXZl
cnMgcmVzcGVjdGl2ZWx5OgotIC9zeXMva2VybmVsL2RlYnVnL3hlbi9mYXVsdF9pbmplY3QveGVu
LWJsa2JhY2svCi0gL3N5cy9rZXJuZWwvZGVidWcveGVuL2ZhdWx0X2luamVjdC94ZW4tbmV0YmFj
ay8KCi0tLQoKU3RhbmlzbGF2IEtpbnNidXJza2lpICgzKToKICAgICAgeGVuOiBhZGQgZ2VuZXJp
YyBmYXVsdCBpbmplY3Rpb24gZmFjaWxpdHkKICAgICAgeGVuIG5ldGJhY2s6IGFkZCBmYXVsdCBp
bmplY3Rpb24gZmFjaWxpdHkKICAgICAgeGVuIGJsa2JhY2s6IGFkZCBmYXVsdCBpbmplY3Rpb24g
ZmFjaWxpdHkKCgogYXJjaC94ODYveGVuL0tjb25maWcgICAgICAgICAgICAgICAgICAgfCAgICA3
ICsrCiBhcmNoL3g4Ni94ZW4vTWFrZWZpbGUgICAgICAgICAgICAgICAgICB8ICAgIDEgCiBhcmNo
L3g4Ni94ZW4vZmF1bHRfaW5qZWN0LmMgICAgICAgICAgICB8ICAxMDkgKysrKysrKysrKysrKysr
KysrKysrKysrKysrKysKIGRyaXZlcnMvYmxvY2svS2NvbmZpZyAgICAgICAgICAgICAgICAgIHwg
ICAgNyArKwogZHJpdmVycy9ibG9jay94ZW4tYmxrYmFjay9NYWtlZmlsZSAgICAgfCAgICAxIAog
ZHJpdmVycy9ibG9jay94ZW4tYmxrYmFjay9ibGtiYWNrLmMgICAgfCAgICA5ICsrCiBkcml2ZXJz
L2Jsb2NrL3hlbi1ibGtiYWNrL2Jsa2JhY2tfZmkuYyB8ICAxMTYgKysrKysrKysrKysrKysrKysr
KysrKysrKysrKysrKwogZHJpdmVycy9ibG9jay94ZW4tYmxrYmFjay9ibGtiYWNrX2ZpLmggfCAg
IDM3ICsrKysrKysrKysKIGRyaXZlcnMvYmxvY2sveGVuLWJsa2JhY2svY29tbW9uLmggICAgIHwg
ICAgMyArCiBkcml2ZXJzL2Jsb2NrL3hlbi1ibGtiYWNrL3hlbmJ1cy5jICAgICB8ICAgIDUgKwog
ZHJpdmVycy9uZXQvS2NvbmZpZyAgICAgICAgICAgICAgICAgICAgfCAgICA4ICsrCiBkcml2ZXJz
L25ldC94ZW4tbmV0YmFjay9NYWtlZmlsZSAgICAgICB8ICAgIDEgCiBkcml2ZXJzL25ldC94ZW4t
bmV0YmFjay9jb21tb24uaCAgICAgICB8ICAgIDMgKwogZHJpdmVycy9uZXQveGVuLW5ldGJhY2sv
bmV0YmFjay5jICAgICAgfCAgICAzICsKIGRyaXZlcnMvbmV0L3hlbi1uZXRiYWNrL25ldGJhY2tf
ZmkuYyAgIHwgIDExOSArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwogZHJpdmVycy9u
ZXQveGVuLW5ldGJhY2svbmV0YmFja19maS5oICAgfCAgIDM1ICsrKysrKysrKwogZHJpdmVycy9u
ZXQveGVuLW5ldGJhY2sveGVuYnVzLmMgICAgICAgfCAgICA2ICsrCiBpbmNsdWRlL3hlbi9mYXVs
dF9pbmplY3QuaCAgICAgICAgICAgICB8ICAgNDUgKysrKysrKysrKysrCiAxOCBmaWxlcyBjaGFu
Z2VkLCA1MTUgaW5zZXJ0aW9ucygrKQogY3JlYXRlIG1vZGUgMTAwNjQ0IGFyY2gveDg2L3hlbi9m
YXVsdF9pbmplY3QuYwogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvYmxvY2sveGVuLWJsa2Jh
Y2svYmxrYmFja19maS5jCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9ibG9jay94ZW4tYmxr
YmFjay9ibGtiYWNrX2ZpLmgKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL25ldC94ZW4tbmV0
YmFjay9uZXRiYWNrX2ZpLmMKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL25ldC94ZW4tbmV0
YmFjay9uZXRiYWNrX2ZpLmgKIGNyZWF0ZSBtb2RlIDEwMDY0NCBpbmNsdWRlL3hlbi9mYXVsdF9p
bmplY3QuaApBbWF6b24gRGV2ZWxvcG1lbnQgQ2VudGVyIEdlcm1hbnkgR21iSApCZXJsaW4gLSBE
cmVzZGVuIC0gQWFjaGVuCm1haW4gb2ZmaWNlOiBLcmF1c2Vuc3RyLiAzOCwgMTAxMTcgQmVybGlu
Ckdlc2NoYWVmdHNmdWVocmVyOiBEci4gUmFsZiBIZXJicmljaCwgQ2hyaXN0aWFuIFNjaGxhZWdl
cgpVc3QtSUQ6IERFMjg5MjM3ODc5CkVpbmdldHJhZ2VuIGFtIEFtdHNnZXJpY2h0IENoYXJsb3R0
ZW5idXJnIEhSQiAxNDkxNzMgQgo=

[PATCH 0/3] Introduce Xen fault injection facility

[Stanislav Kinsburskii]

This series adds a facility, which can be used to instrument Xen code with
fault injections.
It is based "Fault injection capabilities infrastructure" described here:
- Documentation/fault-injection/fault-injection.txt

First patch adds a generic facility to use anywhere in Xen.
When using it all the fault injection user land control directories (if
any) will appear here:
- /sys/kernel/debug/xen/fault_inject/

To distinguish with generic (or core) Xen fault injections, next two
patches add additional directories to the root path above for blkback and
netback drivers respectively:
- /sys/kernel/debug/xen/fault_inject/xen-blkback/
- /sys/kernel/debug/xen/fault_inject/xen-netback/

---

Stanislav Kinsburskii (3):
      xen: add generic fault injection facility
      xen netback: add fault injection facility
      xen blkback: add fault injection facility


 arch/x86/xen/Kconfig                   |    7 ++
 arch/x86/xen/Makefile                  |    1 
 arch/x86/xen/fault_inject.c            |  109 +++++++++++++++++++++++++++++
 drivers/block/Kconfig                  |    7 ++
 drivers/block/xen-blkback/Makefile     |    1 
 drivers/block/xen-blkback/blkback.c    |    9 ++
 drivers/block/xen-blkback/blkback_fi.c |  116 +++++++++++++++++++++++++++++++
 drivers/block/xen-blkback/blkback_fi.h |   37 ++++++++++
 drivers/block/xen-blkback/common.h     |    3 +
 drivers/block/xen-blkback/xenbus.c     |    5 +
 drivers/net/Kconfig                    |    8 ++
 drivers/net/xen-netback/Makefile       |    1 
 drivers/net/xen-netback/common.h       |    3 +
 drivers/net/xen-netback/netback.c      |    3 +
 drivers/net/xen-netback/netback_fi.c   |  119 ++++++++++++++++++++++++++++++++
 drivers/net/xen-netback/netback_fi.h   |   35 +++++++++
 drivers/net/xen-netback/xenbus.c       |    6 ++
 include/xen/fault_inject.h             |   45 ++++++++++++
 18 files changed, 515 insertions(+)
 create mode 100644 arch/x86/xen/fault_inject.c
 create mode 100644 drivers/block/xen-blkback/blkback_fi.c
 create mode 100644 drivers/block/xen-blkback/blkback_fi.h
 create mode 100644 drivers/net/xen-netback/netback_fi.c
 create mode 100644 drivers/net/xen-netback/netback_fi.h
 create mode 100644 include/xen/fault_inject.h
Amazon Development Center Germany GmbH
Berlin - Dresden - Aachen
main office: Krausenstr. 38, 10117 Berlin
Geschaeftsfuehrer: Dr. Ralf Herbrich, Christian Schlaeger
Ust-ID: DE289237879
Eingetragen am Amtsgericht Charlottenburg HRB 149173 B

[PATCH 1/3] xen: add generic fault injection facility

[Stanislav Kinsburskii]
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[PATCH 1/3] xen: add generic fault injection facility

[Stanislav Kinsburskii]

The overall idea of this patch is to add a generic fault injection facility
to Xen, which later can be used in various places by different Xen parts.

Core implementation ideas:

- The facility build is controlled by boolean config
  CONFIG_XEN_FAULT_INJECTION option ("N" by default).

- All fault injection logic is located in an optionally compiled separated
  file.

- Fault injection attribute and control directory creation and destruction
  are wrapped with helpers, producing and accepting a pointer to an opaque
  object thus making all the rest of code independent on fault injection
  engine.

When enabled Xen root fault injection directory appears:

- /sys/kernel/debug/xen/fault_inject/

The falicity provides the following helpers (exported to be accessible in
modules):

- xen_fi_add(name) - adds fault injection control directory "name" to Xen
  root fault injection directory

- xen_fi_dir_create(name) - allows to create a subdirectory "name" in Xen
  root fault injection directory.

- xen_fi_dir_add(dir, name) - adds fault injection control directory "name"
  to directory "dir"

- xen_should_fail(fi) - check whether fi hav to fail.

Signed-off-by: Stanislav Kinsburskii <staskins@amazon.com>
CC: Boris Ostrovsky <boris.ostrovsky@oracle.com>
CC: Juergen Gross <jgross@suse.com>
CC: Thomas Gleixner <tglx@linutronix.de>
CC: Ingo Molnar <mingo@redhat.com>
CC: "H. Peter Anvin" <hpa@zytor.com>
CC: x86@kernel.org
CC: xen-devel@lists.xenproject.org
CC: linux-kernel@vger.kernel.org
CC: Stanislav Kinsburskii <staskins@amazon.com>
CC: David Woodhouse <dwmw@amazon.co.uk>
---
 arch/x86/xen/Kconfig        |    7 +++
 arch/x86/xen/Makefile       |    1 
 arch/x86/xen/fault_inject.c |  109 +++++++++++++++++++++++++++++++++++++++++++
 include/xen/fault_inject.h  |   45 ++++++++++++++++++
 4 files changed, 162 insertions(+)
 create mode 100644 arch/x86/xen/fault_inject.c
 create mode 100644 include/xen/fault_inject.h

diff --git a/arch/x86/xen/Kconfig b/arch/x86/xen/Kconfig
index c1f98f3..483fc16 100644
--- a/arch/x86/xen/Kconfig
+++ b/arch/x86/xen/Kconfig
@@ -77,3 +77,10 @@ config XEN_PVH
 	bool "Support for running as a PVH guest"
 	depends on XEN && XEN_PVHVM && ACPI
 	def_bool n
+
+config XEN_FAULT_INJECTION
+	bool "Enable Xen fault injection"
+	depends on FAULT_INJECTION_DEBUG_FS
+	default n
+	help
+	  Enable Xen fault injection facility
diff --git a/arch/x86/xen/Makefile b/arch/x86/xen/Makefile
index d83cb54..3158fe1 100644
--- a/arch/x86/xen/Makefile
+++ b/arch/x86/xen/Makefile
@@ -34,3 +34,4 @@ obj-$(CONFIG_XEN_DOM0)		+= vga.o
 obj-$(CONFIG_SWIOTLB_XEN)	+= pci-swiotlb-xen.o
 obj-$(CONFIG_XEN_EFI)		+= efi.o
 obj-$(CONFIG_XEN_PVH)	 	+= xen-pvh.o
+obj-$(CONFIG_XEN_FAULT_INJECTION)	+= fault_inject.o
diff --git a/arch/x86/xen/fault_inject.c b/arch/x86/xen/fault_inject.c
new file mode 100644
index 0000000..ecf0f7c
--- /dev/null
+++ b/arch/x86/xen/fault_inject.c
@@ -0,0 +1,109 @@
+/*
+ * Fauit injection interface for Xen virtual block devices
+ *
+ * Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * 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; or, when distributed
+ * separately from the Linux kernel or incorporated into other
+ * software packages, subject to the following license:
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this source file (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy, modify,
+ * merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#include <linux/slab.h>
+#include <linux/fault-inject.h>
+
+#include <xen/fault_inject.h>
+
+#include "debugfs.h"
+
+static struct dentry *d_fi_debug;
+
+static DECLARE_FAULT_ATTR(template_attr);
+
+struct xen_fi {
+	struct dentry		*dir;
+	struct fault_attr	attr;
+};
+
+struct xen_fi *xen_fi_dir_add(struct dentry *parent, const char *name)
+{
+	struct xen_fi *fi;
+	struct dentry *dir;
+
+	fi = kzalloc(sizeof(*fi), GFP_KERNEL);
+	if (!fi)
+		return ERR_PTR(-ENOMEM);
+
+	memcpy(&fi->attr, &template_attr, sizeof(template_attr));
+
+	dir = fault_create_debugfs_attr(name, parent, &fi->attr);
+	if (IS_ERR(dir)) {
+		kfree(fi);
+		return (struct xen_fi *)dir;
+	}
+
+	fi->dir = dir;
+
+	return fi;
+}
+EXPORT_SYMBOL(xen_fi_dir_add);
+
+struct xen_fi *xen_fi_add(const char *name)
+{
+	return xen_fi_dir_add(d_fi_debug, name);
+}
+
+void xen_fi_del(struct xen_fi *fi)
+{
+	debugfs_remove_recursive(fi->dir);
+	kfree(fi);
+}
+EXPORT_SYMBOL(xen_fi_del);
+
+bool xen_should_fail(struct xen_fi *fi)
+{
+	return should_fail(&fi->attr, 0);
+}
+EXPORT_SYMBOL(xen_should_fail);
+
+struct dentry *xen_fi_dir_create(const char *name)
+{
+	return debugfs_create_dir(name, d_fi_debug);
+}
+EXPORT_SYMBOL(xen_fi_dir_create);
+
+static int __init xen_fi_init(void)
+{
+	struct dentry *d_xen;
+
+	d_xen = xen_init_debugfs();
+	if (!d_xen)
+		return -ENOMEM;
+
+	d_fi_debug = debugfs_create_dir("fault_inject", d_xen);
+	if (d_fi_debug == NULL)
+		return -ENOMEM;
+
+	return 0;
+}
+
+fs_initcall(xen_fi_init);
diff --git a/include/xen/fault_inject.h b/include/xen/fault_inject.h
new file mode 100644
index 0000000..e2bf14a
--- /dev/null
+++ b/include/xen/fault_inject.h
@@ -0,0 +1,45 @@
+#ifndef _XEN_FAULT_INJECT_H
+#define _XEN_FAULT_INJECT_H
+
+struct dentry;
+struct xen_fi;
+
+#ifdef CONFIG_FAULT_INJECTION_DEBUG_FS
+
+struct dentry *xen_fi_dir_create(const char *name);
+
+struct xen_fi *xen_fi_dir_add(struct dentry *parent, const char *name);
+struct xen_fi *xen_fi_add(const char *name);
+void xen_fi_del(struct xen_fi *fi);
+
+bool xen_should_fail(struct xen_fi *fi);
+
+#else
+
+static inline struct dentry *xen_fi_dir_create(const char *name)
+{
+	return NULL;
+}
+
+static inline struct xen_fi *xen_fi_dir_add(struct dentry *parent, const char *name)
+{
+	return NULL;
+}
+
+static inline struct xen_fi *xen_fi_add(const char *name)
+{
+	return NULL;
+}
+
+static inline void xen_fi_del(struct xen_fi *fi) { }
+
+static inline bool xen_should_fail(struct xen_fi *fi)
+{
+	return false;
+}
+
+#endif /* CONFIG_FAULT_INJECTION_DEBUG_FS */
+
+#endif /* _XEN_FAULT_INJECT_H */
+
+

Amazon Development Center Germany GmbH
Berlin - Dresden - Aachen
main office: Krausenstr. 38, 10117 Berlin
Geschaeftsfuehrer: Dr. Ralf Herbrich, Christian Schlaeger
Ust-ID: DE289237879
Eingetragen am Amtsgericht Charlottenburg HRB 149173 B

[PATCH 1/3] xen: add generic fault injection facility

[Stanislav Kinsburskii]

The overall idea of this patch is to add a generic fault injection facility
to Xen, which later can be used in various places by different Xen parts.

Core implementation ideas:

- The facility build is controlled by boolean config
  CONFIG_XEN_FAULT_INJECTION option ("N" by default).

- All fault injection logic is located in an optionally compiled separated
  file.

- Fault injection attribute and control directory creation and destruction
  are wrapped with helpers, producing and accepting a pointer to an opaque
  object thus making all the rest of code independent on fault injection
  engine.

When enabled Xen root fault injection directory appears:

- /sys/kernel/debug/xen/fault_inject/

The falicity provides the following helpers (exported to be accessible in
modules):

- xen_fi_add(name) - adds fault injection control directory "name" to Xen
  root fault injection directory

- xen_fi_dir_create(name) - allows to create a subdirectory "name" in Xen
  root fault injection directory.

- xen_fi_dir_add(dir, name) - adds fault injection control directory "name"
  to directory "dir"

- xen_should_fail(fi) - check whether fi hav to fail.

Signed-off-by: Stanislav Kinsburskii <staskins@amazon.com>
CC: Boris Ostrovsky <boris.ostrovsky@oracle.com>
CC: Juergen Gross <jgross@suse.com>
CC: Thomas Gleixner <tglx@linutronix.de>
CC: Ingo Molnar <mingo@redhat.com>
CC: "H. Peter Anvin" <hpa@zytor.com>
CC: x86@kernel.org
CC: xen-devel@lists.xenproject.org
CC: linux-kernel@vger.kernel.org
CC: Stanislav Kinsburskii <staskins@amazon.com>
CC: David Woodhouse <dwmw@amazon.co.uk>
---
 arch/x86/xen/Kconfig        |    7 +++
 arch/x86/xen/Makefile       |    1 
 arch/x86/xen/fault_inject.c |  109 +++++++++++++++++++++++++++++++++++++++++++
 include/xen/fault_inject.h  |   45 ++++++++++++++++++
 4 files changed, 162 insertions(+)
 create mode 100644 arch/x86/xen/fault_inject.c
 create mode 100644 include/xen/fault_inject.h

diff --git a/arch/x86/xen/Kconfig b/arch/x86/xen/Kconfig
index c1f98f3..483fc16 100644
--- a/arch/x86/xen/Kconfig
+++ b/arch/x86/xen/Kconfig
@@ -77,3 +77,10 @@ config XEN_PVH
 	bool "Support for running as a PVH guest"
 	depends on XEN && XEN_PVHVM && ACPI
 	def_bool n
+
+config XEN_FAULT_INJECTION
+	bool "Enable Xen fault injection"
+	depends on FAULT_INJECTION_DEBUG_FS
+	default n
+	help
+	  Enable Xen fault injection facility
diff --git a/arch/x86/xen/Makefile b/arch/x86/xen/Makefile
index d83cb54..3158fe1 100644
--- a/arch/x86/xen/Makefile
+++ b/arch/x86/xen/Makefile
@@ -34,3 +34,4 @@ obj-$(CONFIG_XEN_DOM0)		+= vga.o
 obj-$(CONFIG_SWIOTLB_XEN)	+= pci-swiotlb-xen.o
 obj-$(CONFIG_XEN_EFI)		+= efi.o
 obj-$(CONFIG_XEN_PVH)	 	+= xen-pvh.o
+obj-$(CONFIG_XEN_FAULT_INJECTION)	+= fault_inject.o
diff --git a/arch/x86/xen/fault_inject.c b/arch/x86/xen/fault_inject.c
new file mode 100644
index 0000000..ecf0f7c
--- /dev/null
+++ b/arch/x86/xen/fault_inject.c
@@ -0,0 +1,109 @@
+/*
+ * Fauit injection interface for Xen virtual block devices
+ *
+ * Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * 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; or, when distributed
+ * separately from the Linux kernel or incorporated into other
+ * software packages, subject to the following license:
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this source file (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy, modify,
+ * merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#include <linux/slab.h>
+#include <linux/fault-inject.h>
+
+#include <xen/fault_inject.h>
+
+#include "debugfs.h"
+
+static struct dentry *d_fi_debug;
+
+static DECLARE_FAULT_ATTR(template_attr);
+
+struct xen_fi {
+	struct dentry		*dir;
+	struct fault_attr	attr;
+};
+
+struct xen_fi *xen_fi_dir_add(struct dentry *parent, const char *name)
+{
+	struct xen_fi *fi;
+	struct dentry *dir;
+
+	fi = kzalloc(sizeof(*fi), GFP_KERNEL);
+	if (!fi)
+		return ERR_PTR(-ENOMEM);
+
+	memcpy(&fi->attr, &template_attr, sizeof(template_attr));
+
+	dir = fault_create_debugfs_attr(name, parent, &fi->attr);
+	if (IS_ERR(dir)) {
+		kfree(fi);
+		return (struct xen_fi *)dir;
+	}
+
+	fi->dir = dir;
+
+	return fi;
+}
+EXPORT_SYMBOL(xen_fi_dir_add);
+
+struct xen_fi *xen_fi_add(const char *name)
+{
+	return xen_fi_dir_add(d_fi_debug, name);
+}
+
+void xen_fi_del(struct xen_fi *fi)
+{
+	debugfs_remove_recursive(fi->dir);
+	kfree(fi);
+}
+EXPORT_SYMBOL(xen_fi_del);
+
+bool xen_should_fail(struct xen_fi *fi)
+{
+	return should_fail(&fi->attr, 0);
+}
+EXPORT_SYMBOL(xen_should_fail);
+
+struct dentry *xen_fi_dir_create(const char *name)
+{
+	return debugfs_create_dir(name, d_fi_debug);
+}
+EXPORT_SYMBOL(xen_fi_dir_create);
+
+static int __init xen_fi_init(void)
+{
+	struct dentry *d_xen;
+
+	d_xen = xen_init_debugfs();
+	if (!d_xen)
+		return -ENOMEM;
+
+	d_fi_debug = debugfs_create_dir("fault_inject", d_xen);
+	if (d_fi_debug == NULL)
+		return -ENOMEM;
+
+	return 0;
+}
+
+fs_initcall(xen_fi_init);
diff --git a/include/xen/fault_inject.h b/include/xen/fault_inject.h
new file mode 100644
index 0000000..e2bf14a
--- /dev/null
+++ b/include/xen/fault_inject.h
@@ -0,0 +1,45 @@
+#ifndef _XEN_FAULT_INJECT_H
+#define _XEN_FAULT_INJECT_H
+
+struct dentry;
+struct xen_fi;
+
+#ifdef CONFIG_FAULT_INJECTION_DEBUG_FS
+
+struct dentry *xen_fi_dir_create(const char *name);
+
+struct xen_fi *xen_fi_dir_add(struct dentry *parent, const char *name);
+struct xen_fi *xen_fi_add(const char *name);
+void xen_fi_del(struct xen_fi *fi);
+
+bool xen_should_fail(struct xen_fi *fi);
+
+#else
+
+static inline struct dentry *xen_fi_dir_create(const char *name)
+{
+	return NULL;
+}
+
+static inline struct xen_fi *xen_fi_dir_add(struct dentry *parent, const char *name)
+{
+	return NULL;
+}
+
+static inline struct xen_fi *xen_fi_add(const char *name)
+{
+	return NULL;
+}
+
+static inline void xen_fi_del(struct xen_fi *fi) { }
+
+static inline bool xen_should_fail(struct xen_fi *fi)
+{
+	return false;
+}
+
+#endif /* CONFIG_FAULT_INJECTION_DEBUG_FS */
+
+#endif /* _XEN_FAULT_INJECT_H */
+
+

Amazon Development Center Germany GmbH
Berlin - Dresden - Aachen
main office: Krausenstr. 38, 10117 Berlin
Geschaeftsfuehrer: Dr. Ralf Herbrich, Christian Schlaeger
Ust-ID: DE289237879
Eingetragen am Amtsgericht Charlottenburg HRB 149173 B
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

[PATCH 2/3] xen netback: add fault injection facility

[Stanislav Kinsburskii]
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[PATCH 2/3] xen netback: add fault injection facility

[Stanislav Kinsburskii]

This patch adds wrapper helpers around generic Xen fault inject facility.
The major reason is to keep all the module fault injection directories
in a dedicated subdirectory instead of Xen fault inject root.

IOW, when using these helpers, per-device and named by device name fault
injection control directories will appear under the following directory:
- /sys/kernel/debug/xen/fault_inject/xen-netback/
instead of:
- /sys/kernel/debug/xen/fault_inject/

Signed-off-by: Stanislav Kinsburskii <staskins@amazon.com>
CC: Wei Liu <wei.liu2@citrix.com>
CC: Paul Durrant <paul.durrant@citrix.com>
CC: "David S. Miller" <davem@davemloft.net>
CC: Matteo Croce <mcroce@redhat.com>
CC: Stefan Hajnoczi <stefanha@redhat.com>
CC: Daniel Borkmann <daniel@iogearbox.net>
CC: Gerard Garcia <ggarcia@deic.uab.cat>
CC: David Ahern <dsa@cumulusnetworks.com>
CC: Juergen Gross <jgross@suse.com>
CC: Amir Levy <amir.jer.levy@intel.com>
CC: Jakub Kicinski <jakub.kicinski@netronome.com>
CC: linux-kernel@vger.kernel.org
CC: netdev@vger.kernel.org
CC: xen-devel@lists.xenproject.org
CC: Stanislav Kinsburskii <staskins@amazon.com>
CC: David Woodhouse <dwmw@amazon.co.uk>
---
 drivers/net/Kconfig                  |    8 ++
 drivers/net/xen-netback/Makefile     |    1 
 drivers/net/xen-netback/common.h     |    3 +
 drivers/net/xen-netback/netback.c    |    3 +
 drivers/net/xen-netback/netback_fi.c |  119 ++++++++++++++++++++++++++++++++++
 drivers/net/xen-netback/netback_fi.h |   35 ++++++++++
 drivers/net/xen-netback/xenbus.c     |    6 ++
 7 files changed, 175 insertions(+)
 create mode 100644 drivers/net/xen-netback/netback_fi.c
 create mode 100644 drivers/net/xen-netback/netback_fi.h

diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig
index 8918466..5cc9acd 100644
--- a/drivers/net/Kconfig
+++ b/drivers/net/Kconfig
@@ -465,6 +465,14 @@ config XEN_NETDEV_BACKEND
 	  compile this driver as a module, chose M here: the module
 	  will be called xen-netback.
 
+config XEN_NETDEV_BACKEND_FAULT_INJECTION
+	  bool "Xen net-device backend driver fault injection"
+	  depends on XEN_NETDEV_BACKEND
+	  depends on XEN_FAULT_INJECTION
+	  default n
+	  help
+	    Allow to inject errors to Xen backend network driver
+
 config VMXNET3
 	tristate "VMware VMXNET3 ethernet driver"
 	depends on PCI && INET
diff --git a/drivers/net/xen-netback/Makefile b/drivers/net/xen-netback/Makefile
index d49798a..28abcdc 100644
--- a/drivers/net/xen-netback/Makefile
+++ b/drivers/net/xen-netback/Makefile
@@ -1,3 +1,4 @@
 obj-$(CONFIG_XEN_NETDEV_BACKEND) := xen-netback.o
 
 xen-netback-y := netback.o xenbus.o interface.o hash.o rx.o
+xen-netback-$(CONFIG_XEN_NETDEV_BACKEND_FAULT_INJECTION) += netback_fi.o
diff --git a/drivers/net/xen-netback/common.h b/drivers/net/xen-netback/common.h
index a46a1e9..30d676d 100644
--- a/drivers/net/xen-netback/common.h
+++ b/drivers/net/xen-netback/common.h
@@ -286,6 +286,9 @@ struct xenvif {
 
 #ifdef CONFIG_DEBUG_FS
 	struct dentry *xenvif_dbg_root;
+#ifdef CONFIG_XEN_NETDEV_BACKEND_FAULT_INJECTION
+	void *fi_info;
+#endif
 #endif
 
 	struct xen_netif_ctrl_back_ring ctrl;
diff --git a/drivers/net/xen-netback/netback.c b/drivers/net/xen-netback/netback.c
index a27daa2..ecc416e 100644
--- a/drivers/net/xen-netback/netback.c
+++ b/drivers/net/xen-netback/netback.c
@@ -33,6 +33,7 @@
  */
 
 #include "common.h"
+#include "netback_fi.h"
 
 #include <linux/kthread.h>
 #include <linux/if_vlan.h>
@@ -1649,6 +1650,7 @@ static int __init netback_init(void)
 			PTR_ERR(xen_netback_dbg_root));
 #endif /* CONFIG_DEBUG_FS */
 
+	(void) xen_netbk_fi_init();
 	return 0;
 
 failed_init:
@@ -1659,6 +1661,7 @@ module_init(netback_init);
 
 static void __exit netback_fini(void)
 {
+	xen_netbk_fi_fini();
 #ifdef CONFIG_DEBUG_FS
 	if (!IS_ERR_OR_NULL(xen_netback_dbg_root))
 		debugfs_remove_recursive(xen_netback_dbg_root);
diff --git a/drivers/net/xen-netback/netback_fi.c b/drivers/net/xen-netback/netback_fi.c
new file mode 100644
index 0000000..47541d0
--- /dev/null
+++ b/drivers/net/xen-netback/netback_fi.c
@@ -0,0 +1,119 @@
+/*
+ * Fault injection interface for Xen backend network driver
+ *
+ * Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * 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; or, when distributed
+ * separately from the Linux kernel or incorporated into other
+ * software packages, subject to the following license:
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this source file (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy, modify,
+ * merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#include "common.h"
+
+#include <linux/debugfs.h>
+
+#include <xen/fault_inject.h>
+#include "netback_fi.h"
+
+static struct dentry *vif_fi_dir;
+
+static const char *xenvif_fi_names[] = {
+};
+
+struct xenvif_fi {
+	struct dentry *dir;
+	struct xen_fi *faults[XENVIF_FI_MAX];
+};
+
+int xen_netbk_fi_init(void)
+{
+	vif_fi_dir = xen_fi_dir_create("xen-netback");
+	if (!vif_fi_dir)
+		return -ENOMEM;
+	return 0;
+}
+
+void xen_netbk_fi_fini(void)
+{
+	debugfs_remove_recursive(vif_fi_dir);
+}
+
+void xenvif_fi_fini(struct xenvif *vif)
+{
+	struct xenvif_fi *vfi = vif->fi_info;
+	int fi;
+
+	if (!vif->fi_info)
+		return;
+
+	vif->fi_info = NULL;
+
+	for (fi = 0; fi < XENVIF_FI_MAX; fi++)
+		xen_fi_del(vfi->faults[fi]);
+	debugfs_remove_recursive(vfi->dir);
+	kfree(vfi);
+}
+
+int xenvif_fi_init(struct xenvif *vif)
+{
+	struct dentry *parent;
+	struct xenvif_fi *vfi;
+	int fi, err = -ENOMEM;
+
+	parent = vif_fi_dir;
+	if (!parent)
+		return -ENOMEM;
+
+	vfi = kmalloc(sizeof(*vfi), GFP_KERNEL);
+	if (!vfi)
+		return -ENOMEM;
+
+	vfi->dir = debugfs_create_dir(vif->dev->name, parent);
+	if (!vfi->dir)
+		goto err_dir;
+
+	for (fi = 0; fi < XENVIF_FI_MAX; fi++) {
+		vfi->faults[fi] = xen_fi_dir_add(vfi->dir,
+				xenvif_fi_names[fi]);
+		if (!vfi->faults[fi])
+			goto err_fault;
+	}
+
+	vif->fi_info = vfi;
+	return 0;
+
+err_fault:
+	for (; fi > 0; fi--)
+		xen_fi_del(vfi->faults[fi]);
+	debugfs_remove_recursive(vfi->dir);
+err_dir:
+	kfree(vfi);
+	return err;
+}
+
+bool xenvif_should_fail(struct xenvif *vif, xenvif_fi_t type)
+{
+	struct xenvif_fi *vfi = vif->fi_info;
+
+	return xen_should_fail(vfi->faults[type]);
+}
diff --git a/drivers/net/xen-netback/netback_fi.h b/drivers/net/xen-netback/netback_fi.h
new file mode 100644
index 0000000..895c6a6
--- /dev/null
+++ b/drivers/net/xen-netback/netback_fi.h
@@ -0,0 +1,35 @@
+#ifndef _XEN_NETBACK_FI_H
+#define _XEN_NETBACK_FI_H
+
+struct xen_fi;
+
+typedef enum {
+	XENVIF_FI_MAX
+} xenvif_fi_t;
+
+#ifdef CONFIG_XEN_NETDEV_BACKEND_FAULT_INJECTION
+
+int xen_netbk_fi_init(void);
+void xen_netbk_fi_fini(void);
+
+void xenvif_fi_fini(struct xenvif *vif);
+int xenvif_fi_init(struct xenvif *vif);
+
+bool xenvif_should_fail(struct xenvif *vif, xenvif_fi_t type);
+
+#else
+
+static inline int xen_netbk_fi_init(void) { return 0; }
+static inline void xen_netbk_fi_fini(void) { }
+
+static inline void xenvif_fi_fini(struct xenvif *vif) { }
+static inline int xenvif_fi_init(struct xenvif *vif) { return 0; }
+
+static inline bool xenvif_should_fail(struct xenvif *vif, xenvif_fi_t type)
+{
+	return false;
+}
+
+#endif /* CONFIG_XEN_NETDEV_BACKEND_FAULT_INJECTION */
+
+#endif /* _XEN_NETBACK_FI_H */
diff --git a/drivers/net/xen-netback/xenbus.c b/drivers/net/xen-netback/xenbus.c
index e1aef25..c775ee0 100644
--- a/drivers/net/xen-netback/xenbus.c
+++ b/drivers/net/xen-netback/xenbus.c
@@ -21,6 +21,7 @@
 #include "common.h"
 #include <linux/vmalloc.h>
 #include <linux/rtnetlink.h>
+#include "netback_fi.h"
 
 struct backend_info {
 	struct xenbus_device *dev;
@@ -502,6 +503,7 @@ static void backend_disconnect(struct backend_info *be)
 #ifdef CONFIG_DEBUG_FS
 		xenvif_debugfs_delif(vif);
 #endif /* CONFIG_DEBUG_FS */
+		xenvif_fi_fini(vif);
 		xenvif_disconnect_data(vif);
 
 		/* At this point some of the handlers may still be active
@@ -1024,6 +1026,10 @@ static void connect(struct backend_info *be)
 		}
 	}
 
+	err = xenvif_fi_init(be->vif);
+	if (err)
+		goto err;
+
 #ifdef CONFIG_DEBUG_FS
 	xenvif_debugfs_addif(be->vif);
 #endif /* CONFIG_DEBUG_FS */

Amazon Development Center Germany GmbH
Berlin - Dresden - Aachen
main office: Krausenstr. 38, 10117 Berlin
Geschaeftsfuehrer: Dr. Ralf Herbrich, Christian Schlaeger
Ust-ID: DE289237879
Eingetragen am Amtsgericht Charlottenburg HRB 149173 B

[PATCH 2/3] xen netback: add fault injection facility

[Stanislav Kinsburskii]

This patch adds wrapper helpers around generic Xen fault inject facility.
The major reason is to keep all the module fault injection directories
in a dedicated subdirectory instead of Xen fault inject root.

IOW, when using these helpers, per-device and named by device name fault
injection control directories will appear under the following directory:
- /sys/kernel/debug/xen/fault_inject/xen-netback/
instead of:
- /sys/kernel/debug/xen/fault_inject/

Signed-off-by: Stanislav Kinsburskii <staskins@amazon.com>
CC: Wei Liu <wei.liu2@citrix.com>
CC: Paul Durrant <paul.durrant@citrix.com>
CC: "David S. Miller" <davem@davemloft.net>
CC: Matteo Croce <mcroce@redhat.com>
CC: Stefan Hajnoczi <stefanha@redhat.com>
CC: Daniel Borkmann <daniel@iogearbox.net>
CC: Gerard Garcia <ggarcia@deic.uab.cat>
CC: David Ahern <dsa@cumulusnetworks.com>
CC: Juergen Gross <jgross@suse.com>
CC: Amir Levy <amir.jer.levy@intel.com>
CC: Jakub Kicinski <jakub.kicinski@netronome.com>
CC: linux-kernel@vger.kernel.org
CC: netdev@vger.kernel.org
CC: xen-devel@lists.xenproject.org
CC: Stanislav Kinsburskii <staskins@amazon.com>
CC: David Woodhouse <dwmw@amazon.co.uk>
---
 drivers/net/Kconfig                  |    8 ++
 drivers/net/xen-netback/Makefile     |    1 
 drivers/net/xen-netback/common.h     |    3 +
 drivers/net/xen-netback/netback.c    |    3 +
 drivers/net/xen-netback/netback_fi.c |  119 ++++++++++++++++++++++++++++++++++
 drivers/net/xen-netback/netback_fi.h |   35 ++++++++++
 drivers/net/xen-netback/xenbus.c     |    6 ++
 7 files changed, 175 insertions(+)
 create mode 100644 drivers/net/xen-netback/netback_fi.c
 create mode 100644 drivers/net/xen-netback/netback_fi.h

diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig
index 8918466..5cc9acd 100644
--- a/drivers/net/Kconfig
+++ b/drivers/net/Kconfig
@@ -465,6 +465,14 @@ config XEN_NETDEV_BACKEND
 	  compile this driver as a module, chose M here: the module
 	  will be called xen-netback.
 
+config XEN_NETDEV_BACKEND_FAULT_INJECTION
+	  bool "Xen net-device backend driver fault injection"
+	  depends on XEN_NETDEV_BACKEND
+	  depends on XEN_FAULT_INJECTION
+	  default n
+	  help
+	    Allow to inject errors to Xen backend network driver
+
 config VMXNET3
 	tristate "VMware VMXNET3 ethernet driver"
 	depends on PCI && INET
diff --git a/drivers/net/xen-netback/Makefile b/drivers/net/xen-netback/Makefile
index d49798a..28abcdc 100644
--- a/drivers/net/xen-netback/Makefile
+++ b/drivers/net/xen-netback/Makefile
@@ -1,3 +1,4 @@
 obj-$(CONFIG_XEN_NETDEV_BACKEND) := xen-netback.o
 
 xen-netback-y := netback.o xenbus.o interface.o hash.o rx.o
+xen-netback-$(CONFIG_XEN_NETDEV_BACKEND_FAULT_INJECTION) += netback_fi.o
diff --git a/drivers/net/xen-netback/common.h b/drivers/net/xen-netback/common.h
index a46a1e9..30d676d 100644
--- a/drivers/net/xen-netback/common.h
+++ b/drivers/net/xen-netback/common.h
@@ -286,6 +286,9 @@ struct xenvif {
 
 #ifdef CONFIG_DEBUG_FS
 	struct dentry *xenvif_dbg_root;
+#ifdef CONFIG_XEN_NETDEV_BACKEND_FAULT_INJECTION
+	void *fi_info;
+#endif
 #endif
 
 	struct xen_netif_ctrl_back_ring ctrl;
diff --git a/drivers/net/xen-netback/netback.c b/drivers/net/xen-netback/netback.c
index a27daa2..ecc416e 100644
--- a/drivers/net/xen-netback/netback.c
+++ b/drivers/net/xen-netback/netback.c
@@ -33,6 +33,7 @@
  */
 
 #include "common.h"
+#include "netback_fi.h"
 
 #include <linux/kthread.h>
 #include <linux/if_vlan.h>
@@ -1649,6 +1650,7 @@ static int __init netback_init(void)
 			PTR_ERR(xen_netback_dbg_root));
 #endif /* CONFIG_DEBUG_FS */
 
+	(void) xen_netbk_fi_init();
 	return 0;
 
 failed_init:
@@ -1659,6 +1661,7 @@ module_init(netback_init);
 
 static void __exit netback_fini(void)
 {
+	xen_netbk_fi_fini();
 #ifdef CONFIG_DEBUG_FS
 	if (!IS_ERR_OR_NULL(xen_netback_dbg_root))
 		debugfs_remove_recursive(xen_netback_dbg_root);
diff --git a/drivers/net/xen-netback/netback_fi.c b/drivers/net/xen-netback/netback_fi.c
new file mode 100644
index 0000000..47541d0
--- /dev/null
+++ b/drivers/net/xen-netback/netback_fi.c
@@ -0,0 +1,119 @@
+/*
+ * Fault injection interface for Xen backend network driver
+ *
+ * Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * 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; or, when distributed
+ * separately from the Linux kernel or incorporated into other
+ * software packages, subject to the following license:
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this source file (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy, modify,
+ * merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#include "common.h"
+
+#include <linux/debugfs.h>
+
+#include <xen/fault_inject.h>
+#include "netback_fi.h"
+
+static struct dentry *vif_fi_dir;
+
+static const char *xenvif_fi_names[] = {
+};
+
+struct xenvif_fi {
+	struct dentry *dir;
+	struct xen_fi *faults[XENVIF_FI_MAX];
+};
+
+int xen_netbk_fi_init(void)
+{
+	vif_fi_dir = xen_fi_dir_create("xen-netback");
+	if (!vif_fi_dir)
+		return -ENOMEM;
+	return 0;
+}
+
+void xen_netbk_fi_fini(void)
+{
+	debugfs_remove_recursive(vif_fi_dir);
+}
+
+void xenvif_fi_fini(struct xenvif *vif)
+{
+	struct xenvif_fi *vfi = vif->fi_info;
+	int fi;
+
+	if (!vif->fi_info)
+		return;
+
+	vif->fi_info = NULL;
+
+	for (fi = 0; fi < XENVIF_FI_MAX; fi++)
+		xen_fi_del(vfi->faults[fi]);
+	debugfs_remove_recursive(vfi->dir);
+	kfree(vfi);
+}
+
+int xenvif_fi_init(struct xenvif *vif)
+{
+	struct dentry *parent;
+	struct xenvif_fi *vfi;
+	int fi, err = -ENOMEM;
+
+	parent = vif_fi_dir;
+	if (!parent)
+		return -ENOMEM;
+
+	vfi = kmalloc(sizeof(*vfi), GFP_KERNEL);
+	if (!vfi)
+		return -ENOMEM;
+
+	vfi->dir = debugfs_create_dir(vif->dev->name, parent);
+	if (!vfi->dir)
+		goto err_dir;
+
+	for (fi = 0; fi < XENVIF_FI_MAX; fi++) {
+		vfi->faults[fi] = xen_fi_dir_add(vfi->dir,
+				xenvif_fi_names[fi]);
+		if (!vfi->faults[fi])
+			goto err_fault;
+	}
+
+	vif->fi_info = vfi;
+	return 0;
+
+err_fault:
+	for (; fi > 0; fi--)
+		xen_fi_del(vfi->faults[fi]);
+	debugfs_remove_recursive(vfi->dir);
+err_dir:
+	kfree(vfi);
+	return err;
+}
+
+bool xenvif_should_fail(struct xenvif *vif, xenvif_fi_t type)
+{
+	struct xenvif_fi *vfi = vif->fi_info;
+
+	return xen_should_fail(vfi->faults[type]);
+}
diff --git a/drivers/net/xen-netback/netback_fi.h b/drivers/net/xen-netback/netback_fi.h
new file mode 100644
index 0000000..895c6a6
--- /dev/null
+++ b/drivers/net/xen-netback/netback_fi.h
@@ -0,0 +1,35 @@
+#ifndef _XEN_NETBACK_FI_H
+#define _XEN_NETBACK_FI_H
+
+struct xen_fi;
+
+typedef enum {
+	XENVIF_FI_MAX
+} xenvif_fi_t;
+
+#ifdef CONFIG_XEN_NETDEV_BACKEND_FAULT_INJECTION
+
+int xen_netbk_fi_init(void);
+void xen_netbk_fi_fini(void);
+
+void xenvif_fi_fini(struct xenvif *vif);
+int xenvif_fi_init(struct xenvif *vif);
+
+bool xenvif_should_fail(struct xenvif *vif, xenvif_fi_t type);
+
+#else
+
+static inline int xen_netbk_fi_init(void) { return 0; }
+static inline void xen_netbk_fi_fini(void) { }
+
+static inline void xenvif_fi_fini(struct xenvif *vif) { }
+static inline int xenvif_fi_init(struct xenvif *vif) { return 0; }
+
+static inline bool xenvif_should_fail(struct xenvif *vif, xenvif_fi_t type)
+{
+	return false;
+}
+
+#endif /* CONFIG_XEN_NETDEV_BACKEND_FAULT_INJECTION */
+
+#endif /* _XEN_NETBACK_FI_H */
diff --git a/drivers/net/xen-netback/xenbus.c b/drivers/net/xen-netback/xenbus.c
index e1aef25..c775ee0 100644
--- a/drivers/net/xen-netback/xenbus.c
+++ b/drivers/net/xen-netback/xenbus.c
@@ -21,6 +21,7 @@
 #include "common.h"
 #include <linux/vmalloc.h>
 #include <linux/rtnetlink.h>
+#include "netback_fi.h"
 
 struct backend_info {
 	struct xenbus_device *dev;
@@ -502,6 +503,7 @@ static void backend_disconnect(struct backend_info *be)
 #ifdef CONFIG_DEBUG_FS
 		xenvif_debugfs_delif(vif);
 #endif /* CONFIG_DEBUG_FS */
+		xenvif_fi_fini(vif);
 		xenvif_disconnect_data(vif);
 
 		/* At this point some of the handlers may still be active
@@ -1024,6 +1026,10 @@ static void connect(struct backend_info *be)
 		}
 	}
 
+	err = xenvif_fi_init(be->vif);
+	if (err)
+		goto err;
+
 #ifdef CONFIG_DEBUG_FS
 	xenvif_debugfs_addif(be->vif);
 #endif /* CONFIG_DEBUG_FS */

Amazon Development Center Germany GmbH
Berlin - Dresden - Aachen
main office: Krausenstr. 38, 10117 Berlin
Geschaeftsfuehrer: Dr. Ralf Herbrich, Christian Schlaeger
Ust-ID: DE289237879
Eingetragen am Amtsgericht Charlottenburg HRB 149173 B
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

[PATCH 3/3] xen blkback: add fault injection facility

[Stanislav Kinsburskii]
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[PATCH 3/3] xen blkback: add fault injection facility

[Stanislav Kinsburskii]

This patch adds wrapper helpers around generic Xen fault inject
facility.
The major reason is to keep all the module fault injection directories
in a dedicated subdirectory instead of Xen fault inject root.

IOW, when using these helpers, per-device and named by device name
fault injection control directories will appear under the following
directory:
- /sys/kernel/debug/xen/fault_inject/xen-blkback/
instead of:
- /sys/kernel/debug/xen/fault_inject/

Signed-off-by: Stanislav Kinsburskii <staskins@amazon.com>
CC: Jens Axboe <axboe@kernel.dk>
CC: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
CC: "Roger Pau Monné" <roger.pau@citrix.com>
CC: linux-kernel@vger.kernel.org
CC: linux-block@vger.kernel.org
CC: xen-devel@lists.xenproject.org
CC: Stanislav Kinsburskii <staskins@amazon.com>
CC: David Woodhouse <dwmw@amazon.co.uk>
---
 drivers/block/Kconfig                  |    7 ++
 drivers/block/xen-blkback/Makefile     |    1 
 drivers/block/xen-blkback/blkback.c    |    9 ++
 drivers/block/xen-blkback/blkback_fi.c |  116 ++++++++++++++++++++++++++++++++
 drivers/block/xen-blkback/blkback_fi.h |   37 ++++++++++
 drivers/block/xen-blkback/common.h     |    3 +
 drivers/block/xen-blkback/xenbus.c     |    5 +
 7 files changed, 178 insertions(+)
 create mode 100644 drivers/block/xen-blkback/blkback_fi.c
 create mode 100644 drivers/block/xen-blkback/blkback_fi.h

diff --git a/drivers/block/Kconfig b/drivers/block/Kconfig
index ad9b687..0ce05fe 100644
--- a/drivers/block/Kconfig
+++ b/drivers/block/Kconfig
@@ -436,6 +436,13 @@ config XEN_BLKDEV_BACKEND
 	  compile this driver as a module, chose M here: the module
 	  will be called xen-blkback.
 
+config XEN_BLKDEV_BACKEND_FAULT_INJECTION
+	  bool "Xen block-device backend driver fault injection"
+	  depends on XEN_BLKDEV_BACKEND
+	  depends on XEN_FAULT_INJECTION
+	  default n
+	  help
+	    Allow to inject errors to Xen backend block driver
 
 config VIRTIO_BLK
 	tristate "Virtio block driver"
diff --git a/drivers/block/xen-blkback/Makefile b/drivers/block/xen-blkback/Makefile
index e491c1b..035d134 100644
--- a/drivers/block/xen-blkback/Makefile
+++ b/drivers/block/xen-blkback/Makefile
@@ -1,3 +1,4 @@
 obj-$(CONFIG_XEN_BLKDEV_BACKEND) := xen-blkback.o
 
 xen-blkback-y	:= blkback.o xenbus.o
+xen-blkback-$(CONFIG_XEN_BLKDEV_BACKEND_FAULT_INJECTION) += blkback_fi.o
diff --git a/drivers/block/xen-blkback/blkback.c b/drivers/block/xen-blkback/blkback.c
index 987d665..2933bec 100644
--- a/drivers/block/xen-blkback/blkback.c
+++ b/drivers/block/xen-blkback/blkback.c
@@ -51,6 +51,7 @@
 #include <xen/balloon.h>
 #include <xen/grant_table.h>
 #include "common.h"
+#include "blkback_fi.h"
 
 /*
  * Maximum number of unused free pages to keep in the internal buffer.
@@ -1491,11 +1492,19 @@ static int __init xen_blkif_init(void)
 	if (rc)
 		goto failed_init;
 
+	(void) xen_blkbk_fi_init();
  failed_init:
 	return rc;
 }
 
 module_init(xen_blkif_init);
 
+static void __exit xen_blkif_fini(void)
+{
+	xen_blkbk_fi_fini();
+}
+
+module_exit(xen_blkif_fini);
+
 MODULE_LICENSE("Dual BSD/GPL");
 MODULE_ALIAS("xen-backend:vbd");
diff --git a/drivers/block/xen-blkback/blkback_fi.c b/drivers/block/xen-blkback/blkback_fi.c
new file mode 100644
index 0000000..b7abaea
--- /dev/null
+++ b/drivers/block/xen-blkback/blkback_fi.c
@@ -0,0 +1,116 @@
+/*
+ * Fault injection interface for Xen virtual block devices
+ *
+ * Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * 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; or, when distributed
+ * separately from the Linux kernel or incorporated into other
+ * software packages, subject to the following license:
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this source file (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy, modify,
+ * merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#include <linux/slab.h>
+#include <linux/debugfs.h>
+
+#include <xen/fault_inject.h>
+
+#include "blkback_fi.h"
+#include "common.h"
+
+static struct dentry *blkif_fi_dir;
+
+static const char *xen_blkif_fi_names[XENBLKIF_FI_MAX] = {
+};
+
+struct xen_blkif_fi {
+	struct dentry *dir;
+	struct xen_fi *faults[XENBLKIF_FI_MAX];
+};
+
+int xen_blkbk_fi_init(void)
+{
+	blkif_fi_dir = xen_fi_dir_create("xen-blkback");
+	if (!blkif_fi_dir)
+		return -ENOMEM;
+	return 0;
+}
+
+void xen_blkbk_fi_fini(void)
+{
+	debugfs_remove_recursive(blkif_fi_dir);
+}
+
+void xen_blkif_fi_fini(struct xen_blkif *blkif)
+{
+	struct xen_blkif_fi *bfi = blkif->fi_info;
+	int fi;
+
+	if (!blkif->fi_info)
+		return;
+
+	blkif->fi_info = NULL;
+
+	for (fi = 0; fi < XENBLKIF_FI_MAX; fi++)
+		xen_fi_del(bfi->faults[fi]);
+	debugfs_remove_recursive(bfi->dir);
+	kfree(bfi);
+}
+
+int xen_blkif_fi_init(struct xen_blkif *blkif)
+{
+	struct xen_blkif_fi *bfi;
+	int fi, err = -ENOMEM;
+
+	bfi = kmalloc(sizeof(*bfi), GFP_KERNEL);
+	if (!bfi)
+		return -ENOMEM;
+
+	bfi->dir = debugfs_create_dir(dev_name(&blkif->be->dev->dev),
+				      blkif_fi_dir);
+	if (!bfi->dir)
+		goto err_dir;
+
+	for (fi = 0; fi < XENBLKIF_FI_MAX; fi++) {
+		bfi->faults[fi] = xen_fi_dir_add(bfi->dir,
+						 xen_blkif_fi_names[fi]);
+		if (!bfi->faults[fi])
+			goto err_fault;
+	}
+
+	blkif->fi_info = bfi;
+	return 0;
+
+err_fault:
+	for (; fi > 0; fi--)
+		xen_fi_del(bfi->faults[fi]);
+	debugfs_remove_recursive(bfi->dir);
+err_dir:
+	kfree(bfi);
+	return err;
+}
+
+bool xenblkif_should_fail(struct xen_blkif *blkif, xen_blkbk_fi_t type)
+{
+	struct xen_blkif_fi *bfi = blkif->fi_info;
+
+	return xen_should_fail(bfi->faults[type]);
+}
diff --git a/drivers/block/xen-blkback/blkback_fi.h b/drivers/block/xen-blkback/blkback_fi.h
new file mode 100644
index 0000000..4e29850
--- /dev/null
+++ b/drivers/block/xen-blkback/blkback_fi.h
@@ -0,0 +1,37 @@
+#ifndef _XEN_BLKBACK_FI_H
+#define _XEN_BLKBACK_FI_H
+
+struct xen_fi;
+struct xen_blkif;
+
+typedef enum {
+	XENBLKIF_FI_MAX
+} xen_blkbk_fi_t;
+
+#ifdef CONFIG_XEN_BLKDEV_BACKEND_FAULT_INJECTION
+
+void xen_blkbk_fi_fini(void);
+int xen_blkbk_fi_init(void);
+
+void xen_blkif_fi_fini(struct xen_blkif *blkif);
+int xen_blkif_fi_init(struct xen_blkif *blkif);
+
+bool xenblkif_should_fail(struct xen_blkif *blkif, xen_blkbk_fi_t type);
+
+#else
+
+static inline void xen_blkbk_fi_fini(void) { }
+static inline int xen_blkbk_fi_init(void) { return 0; }
+
+static inline void xen_blkif_fi_fini(struct xen_blkif *blkif) { }
+static inline int xen_blkif_fi_init(struct xen_blkif *blkif) { return 0; }
+
+static inline bool xenblkif_should_fail(struct xen_blkif *blkif, xen_blkbk_fi_t type)
+{
+	return false;
+}
+
+#endif /* CONFIG_XEN_BLKDEV_BACKEND_FAULT_INJECTION */
+
+#endif /* _XEN_BLKBACK_FI_H */
+
diff --git a/drivers/block/xen-blkback/common.h b/drivers/block/xen-blkback/common.h
index ecb35fe..6d12d4d 100644
--- a/drivers/block/xen-blkback/common.h
+++ b/drivers/block/xen-blkback/common.h
@@ -329,6 +329,9 @@ struct xen_blkif {
 	/* All rings for this device. */
 	struct xen_blkif_ring	*rings;
 	unsigned int		nr_rings;
+#ifdef CONFIG_XEN_BLKDEV_BACKEND_FAULT_INJECTION
+	void			*fi_info;
+#endif
 };
 
 struct seg_buf {
diff --git a/drivers/block/xen-blkback/xenbus.c b/drivers/block/xen-blkback/xenbus.c
index 21c1be1..9931fc8 100644
--- a/drivers/block/xen-blkback/xenbus.c
+++ b/drivers/block/xen-blkback/xenbus.c
@@ -22,6 +22,7 @@
 #include <xen/events.h>
 #include <xen/grant_table.h>
 #include "common.h"
+#include "blkback_fi.h"
 
 /* On the XenBus the max length of 'ring-ref%u'. */
 #define RINGREF_NAME_LEN (20)
@@ -246,6 +247,8 @@ static int xen_blkif_disconnect(struct xen_blkif *blkif)
 	unsigned int j, r;
 	bool busy = false;
 
+	xen_blkif_fi_fini(blkif);
+
 	for (r = 0; r < blkif->nr_rings; r++) {
 		struct xen_blkif_ring *ring = &blkif->rings[r];
 		unsigned int i = 0;
@@ -998,6 +1001,8 @@ static int read_per_ring_refs(struct xen_blkif_ring *ring, const char *dir)
 		return err;
 	}
 
+	(void) xen_blkif_fi_init(blkif);
+
 	return 0;
 
 fail:

Amazon Development Center Germany GmbH
Berlin - Dresden - Aachen
main office: Krausenstr. 38, 10117 Berlin
Geschaeftsfuehrer: Dr. Ralf Herbrich, Christian Schlaeger
Ust-ID: DE289237879
Eingetragen am Amtsgericht Charlottenburg HRB 149173 B

[PATCH 3/3] xen blkback: add fault injection facility

[Stanislav Kinsburskii]

This patch adds wrapper helpers around generic Xen fault inject
facility.
The major reason is to keep all the module fault injection directories
in a dedicated subdirectory instead of Xen fault inject root.

IOW, when using these helpers, per-device and named by device name
fault injection control directories will appear under the following
directory:
- /sys/kernel/debug/xen/fault_inject/xen-blkback/
instead of:
- /sys/kernel/debug/xen/fault_inject/

Signed-off-by: Stanislav Kinsburskii <staskins@amazon.com>
CC: Jens Axboe <axboe@kernel.dk>
CC: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
CC: "Roger Pau Monné" <roger.pau@citrix.com>
CC: linux-kernel@vger.kernel.org
CC: linux-block@vger.kernel.org
CC: xen-devel@lists.xenproject.org
CC: Stanislav Kinsburskii <staskins@amazon.com>
CC: David Woodhouse <dwmw@amazon.co.uk>
---
 drivers/block/Kconfig                  |    7 ++
 drivers/block/xen-blkback/Makefile     |    1 
 drivers/block/xen-blkback/blkback.c    |    9 ++
 drivers/block/xen-blkback/blkback_fi.c |  116 ++++++++++++++++++++++++++++++++
 drivers/block/xen-blkback/blkback_fi.h |   37 ++++++++++
 drivers/block/xen-blkback/common.h     |    3 +
 drivers/block/xen-blkback/xenbus.c     |    5 +
 7 files changed, 178 insertions(+)
 create mode 100644 drivers/block/xen-blkback/blkback_fi.c
 create mode 100644 drivers/block/xen-blkback/blkback_fi.h

diff --git a/drivers/block/Kconfig b/drivers/block/Kconfig
index ad9b687..0ce05fe 100644
--- a/drivers/block/Kconfig
+++ b/drivers/block/Kconfig
@@ -436,6 +436,13 @@ config XEN_BLKDEV_BACKEND
 	  compile this driver as a module, chose M here: the module
 	  will be called xen-blkback.
 
+config XEN_BLKDEV_BACKEND_FAULT_INJECTION
+	  bool "Xen block-device backend driver fault injection"
+	  depends on XEN_BLKDEV_BACKEND
+	  depends on XEN_FAULT_INJECTION
+	  default n
+	  help
+	    Allow to inject errors to Xen backend block driver
 
 config VIRTIO_BLK
 	tristate "Virtio block driver"
diff --git a/drivers/block/xen-blkback/Makefile b/drivers/block/xen-blkback/Makefile
index e491c1b..035d134 100644
--- a/drivers/block/xen-blkback/Makefile
+++ b/drivers/block/xen-blkback/Makefile
@@ -1,3 +1,4 @@
 obj-$(CONFIG_XEN_BLKDEV_BACKEND) := xen-blkback.o
 
 xen-blkback-y	:= blkback.o xenbus.o
+xen-blkback-$(CONFIG_XEN_BLKDEV_BACKEND_FAULT_INJECTION) += blkback_fi.o
diff --git a/drivers/block/xen-blkback/blkback.c b/drivers/block/xen-blkback/blkback.c
index 987d665..2933bec 100644
--- a/drivers/block/xen-blkback/blkback.c
+++ b/drivers/block/xen-blkback/blkback.c
@@ -51,6 +51,7 @@
 #include <xen/balloon.h>
 #include <xen/grant_table.h>
 #include "common.h"
+#include "blkback_fi.h"
 
 /*
  * Maximum number of unused free pages to keep in the internal buffer.
@@ -1491,11 +1492,19 @@ static int __init xen_blkif_init(void)
 	if (rc)
 		goto failed_init;
 
+	(void) xen_blkbk_fi_init();
  failed_init:
 	return rc;
 }
 
 module_init(xen_blkif_init);
 
+static void __exit xen_blkif_fini(void)
+{
+	xen_blkbk_fi_fini();
+}
+
+module_exit(xen_blkif_fini);
+
 MODULE_LICENSE("Dual BSD/GPL");
 MODULE_ALIAS("xen-backend:vbd");
diff --git a/drivers/block/xen-blkback/blkback_fi.c b/drivers/block/xen-blkback/blkback_fi.c
new file mode 100644
index 0000000..b7abaea
--- /dev/null
+++ b/drivers/block/xen-blkback/blkback_fi.c
@@ -0,0 +1,116 @@
+/*
+ * Fault injection interface for Xen virtual block devices
+ *
+ * Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * 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; or, when distributed
+ * separately from the Linux kernel or incorporated into other
+ * software packages, subject to the following license:
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this source file (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy, modify,
+ * merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#include <linux/slab.h>
+#include <linux/debugfs.h>
+
+#include <xen/fault_inject.h>
+
+#include "blkback_fi.h"
+#include "common.h"
+
+static struct dentry *blkif_fi_dir;
+
+static const char *xen_blkif_fi_names[XENBLKIF_FI_MAX] = {
+};
+
+struct xen_blkif_fi {
+	struct dentry *dir;
+	struct xen_fi *faults[XENBLKIF_FI_MAX];
+};
+
+int xen_blkbk_fi_init(void)
+{
+	blkif_fi_dir = xen_fi_dir_create("xen-blkback");
+	if (!blkif_fi_dir)
+		return -ENOMEM;
+	return 0;
+}
+
+void xen_blkbk_fi_fini(void)
+{
+	debugfs_remove_recursive(blkif_fi_dir);
+}
+
+void xen_blkif_fi_fini(struct xen_blkif *blkif)
+{
+	struct xen_blkif_fi *bfi = blkif->fi_info;
+	int fi;
+
+	if (!blkif->fi_info)
+		return;
+
+	blkif->fi_info = NULL;
+
+	for (fi = 0; fi < XENBLKIF_FI_MAX; fi++)
+		xen_fi_del(bfi->faults[fi]);
+	debugfs_remove_recursive(bfi->dir);
+	kfree(bfi);
+}
+
+int xen_blkif_fi_init(struct xen_blkif *blkif)
+{
+	struct xen_blkif_fi *bfi;
+	int fi, err = -ENOMEM;
+
+	bfi = kmalloc(sizeof(*bfi), GFP_KERNEL);
+	if (!bfi)
+		return -ENOMEM;
+
+	bfi->dir = debugfs_create_dir(dev_name(&blkif->be->dev->dev),
+				      blkif_fi_dir);
+	if (!bfi->dir)
+		goto err_dir;
+
+	for (fi = 0; fi < XENBLKIF_FI_MAX; fi++) {
+		bfi->faults[fi] = xen_fi_dir_add(bfi->dir,
+						 xen_blkif_fi_names[fi]);
+		if (!bfi->faults[fi])
+			goto err_fault;
+	}
+
+	blkif->fi_info = bfi;
+	return 0;
+
+err_fault:
+	for (; fi > 0; fi--)
+		xen_fi_del(bfi->faults[fi]);
+	debugfs_remove_recursive(bfi->dir);
+err_dir:
+	kfree(bfi);
+	return err;
+}
+
+bool xenblkif_should_fail(struct xen_blkif *blkif, xen_blkbk_fi_t type)
+{
+	struct xen_blkif_fi *bfi = blkif->fi_info;
+
+	return xen_should_fail(bfi->faults[type]);
+}
diff --git a/drivers/block/xen-blkback/blkback_fi.h b/drivers/block/xen-blkback/blkback_fi.h
new file mode 100644
index 0000000..4e29850
--- /dev/null
+++ b/drivers/block/xen-blkback/blkback_fi.h
@@ -0,0 +1,37 @@
+#ifndef _XEN_BLKBACK_FI_H
+#define _XEN_BLKBACK_FI_H
+
+struct xen_fi;
+struct xen_blkif;
+
+typedef enum {
+	XENBLKIF_FI_MAX
+} xen_blkbk_fi_t;
+
+#ifdef CONFIG_XEN_BLKDEV_BACKEND_FAULT_INJECTION
+
+void xen_blkbk_fi_fini(void);
+int xen_blkbk_fi_init(void);
+
+void xen_blkif_fi_fini(struct xen_blkif *blkif);
+int xen_blkif_fi_init(struct xen_blkif *blkif);
+
+bool xenblkif_should_fail(struct xen_blkif *blkif, xen_blkbk_fi_t type);
+
+#else
+
+static inline void xen_blkbk_fi_fini(void) { }
+static inline int xen_blkbk_fi_init(void) { return 0; }
+
+static inline void xen_blkif_fi_fini(struct xen_blkif *blkif) { }
+static inline int xen_blkif_fi_init(struct xen_blkif *blkif) { return 0; }
+
+static inline bool xenblkif_should_fail(struct xen_blkif *blkif, xen_blkbk_fi_t type)
+{
+	return false;
+}
+
+#endif /* CONFIG_XEN_BLKDEV_BACKEND_FAULT_INJECTION */
+
+#endif /* _XEN_BLKBACK_FI_H */
+
diff --git a/drivers/block/xen-blkback/common.h b/drivers/block/xen-blkback/common.h
index ecb35fe..6d12d4d 100644
--- a/drivers/block/xen-blkback/common.h
+++ b/drivers/block/xen-blkback/common.h
@@ -329,6 +329,9 @@ struct xen_blkif {
 	/* All rings for this device. */
 	struct xen_blkif_ring	*rings;
 	unsigned int		nr_rings;
+#ifdef CONFIG_XEN_BLKDEV_BACKEND_FAULT_INJECTION
+	void			*fi_info;
+#endif
 };
 
 struct seg_buf {
diff --git a/drivers/block/xen-blkback/xenbus.c b/drivers/block/xen-blkback/xenbus.c
index 21c1be1..9931fc8 100644
--- a/drivers/block/xen-blkback/xenbus.c
+++ b/drivers/block/xen-blkback/xenbus.c
@@ -22,6 +22,7 @@
 #include <xen/events.h>
 #include <xen/grant_table.h>
 #include "common.h"
+#include "blkback_fi.h"
 
 /* On the XenBus the max length of 'ring-ref%u'. */
 #define RINGREF_NAME_LEN (20)
@@ -246,6 +247,8 @@ static int xen_blkif_disconnect(struct xen_blkif *blkif)
 	unsigned int j, r;
 	bool busy = false;
 
+	xen_blkif_fi_fini(blkif);
+
 	for (r = 0; r < blkif->nr_rings; r++) {
 		struct xen_blkif_ring *ring = &blkif->rings[r];
 		unsigned int i = 0;
@@ -998,6 +1001,8 @@ static int read_per_ring_refs(struct xen_blkif_ring *ring, const char *dir)
 		return err;
 	}
 
+	(void) xen_blkif_fi_init(blkif);
+
 	return 0;
 
 fail:

Amazon Development Center Germany GmbH
Berlin - Dresden - Aachen
main office: Krausenstr. 38, 10117 Berlin
Geschaeftsfuehrer: Dr. Ralf Herbrich, Christian Schlaeger
Ust-ID: DE289237879
Eingetragen am Amtsgericht Charlottenburg HRB 149173 B
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

Re: [PATCH 1/3] xen: add generic fault injection facility

[Juergen Gross]

On 20/04/18 12:47, Stanislav Kinsburskii wrote:
> The overall idea of this patch is to add a generic fault injection facility
> to Xen, which later can be used in various places by different Xen parts.
> 
> Core implementation ideas:
> 
> - The facility build is controlled by boolean config
>   CONFIG_XEN_FAULT_INJECTION option ("N" by default).
> 
> - All fault injection logic is located in an optionally compiled separated
>   file.
> 
> - Fault injection attribute and control directory creation and destruction
>   are wrapped with helpers, producing and accepting a pointer to an opaque
>   object thus making all the rest of code independent on fault injection
>   engine.
> 
> When enabled Xen root fault injection directory appears:
> 
> - /sys/kernel/debug/xen/fault_inject/
> 
> The falicity provides the following helpers (exported to be accessible in
> modules):
> 
> - xen_fi_add(name) - adds fault injection control directory "name" to Xen
>   root fault injection directory
> 
> - xen_fi_dir_create(name) - allows to create a subdirectory "name" in Xen
>   root fault injection directory.
> 
> - xen_fi_dir_add(dir, name) - adds fault injection control directory "name"
>   to directory "dir"
> 
> - xen_should_fail(fi) - check whether fi hav to fail.
> 
> Signed-off-by: Stanislav Kinsburskii <staskins@amazon.com>
> CC: Boris Ostrovsky <boris.ostrovsky@oracle.com>
> CC: Juergen Gross <jgross@suse.com>
> CC: Thomas Gleixner <tglx@linutronix.de>
> CC: Ingo Molnar <mingo@redhat.com>
> CC: "H. Peter Anvin" <hpa@zytor.com>
> CC: x86@kernel.org
> CC: xen-devel@lists.xenproject.org
> CC: linux-kernel@vger.kernel.org
> CC: Stanislav Kinsburskii <staskins@amazon.com>
> CC: David Woodhouse <dwmw@amazon.co.uk>
> ---
>  arch/x86/xen/Kconfig        |    7 +++
>  arch/x86/xen/Makefile       |    1 
>  arch/x86/xen/fault_inject.c |  109 +++++++++++++++++++++++++++++++++++++++++++
>  include/xen/fault_inject.h  |   45 ++++++++++++++++++
>  4 files changed, 162 insertions(+)
>  create mode 100644 arch/x86/xen/fault_inject.c
>  create mode 100644 include/xen/fault_inject.h
> 
> diff --git a/arch/x86/xen/Kconfig b/arch/x86/xen/Kconfig
> index c1f98f3..483fc16 100644
> --- a/arch/x86/xen/Kconfig
> +++ b/arch/x86/xen/Kconfig
> @@ -77,3 +77,10 @@ config XEN_PVH
>  	bool "Support for running as a PVH guest"
>  	depends on XEN && XEN_PVHVM && ACPI
>  	def_bool n
> +
> +config XEN_FAULT_INJECTION
> +	bool "Enable Xen fault injection"
> +	depends on FAULT_INJECTION_DEBUG_FS
> +	default n
> +	help
> +	  Enable Xen fault injection facility

Why for x86 only? I'd rather add this under drivers/xen

> diff --git a/arch/x86/xen/Makefile b/arch/x86/xen/Makefile
> index d83cb54..3158fe1 100644
> --- a/arch/x86/xen/Makefile
> +++ b/arch/x86/xen/Makefile
> @@ -34,3 +34,4 @@ obj-$(CONFIG_XEN_DOM0)		+= vga.o
>  obj-$(CONFIG_SWIOTLB_XEN)	+= pci-swiotlb-xen.o
>  obj-$(CONFIG_XEN_EFI)		+= efi.o
>  obj-$(CONFIG_XEN_PVH)	 	+= xen-pvh.o
> +obj-$(CONFIG_XEN_FAULT_INJECTION)	+= fault_inject.o
> diff --git a/arch/x86/xen/fault_inject.c b/arch/x86/xen/fault_inject.c
> new file mode 100644
> index 0000000..ecf0f7c
> --- /dev/null
> +++ b/arch/x86/xen/fault_inject.c
> @@ -0,0 +1,109 @@
> +/*
> + * Fauit injection interface for Xen virtual block devices
> + *
> + * Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
> + *
> + * 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; or, when distributed
> + * separately from the Linux kernel or incorporated into other
> + * software packages, subject to the following license:

Please use the appropriate SPDX header instead of the full GPL2
boilerplate.


Juergen

Re: [PATCH 1/3] xen: add generic fault injection facility

[Juergen Gross]

On 20/04/18 12:47, Stanislav Kinsburskii wrote:
> The overall idea of this patch is to add a generic fault injection facility
> to Xen, which later can be used in various places by different Xen parts.
> 
> Core implementation ideas:
> 
> - The facility build is controlled by boolean config
>   CONFIG_XEN_FAULT_INJECTION option ("N" by default).
> 
> - All fault injection logic is located in an optionally compiled separated
>   file.
> 
> - Fault injection attribute and control directory creation and destruction
>   are wrapped with helpers, producing and accepting a pointer to an opaque
>   object thus making all the rest of code independent on fault injection
>   engine.
> 
> When enabled Xen root fault injection directory appears:
> 
> - /sys/kernel/debug/xen/fault_inject/
> 
> The falicity provides the following helpers (exported to be accessible in
> modules):
> 
> - xen_fi_add(name) - adds fault injection control directory "name" to Xen
>   root fault injection directory
> 
> - xen_fi_dir_create(name) - allows to create a subdirectory "name" in Xen
>   root fault injection directory.
> 
> - xen_fi_dir_add(dir, name) - adds fault injection control directory "name"
>   to directory "dir"
> 
> - xen_should_fail(fi) - check whether fi hav to fail.
> 
> Signed-off-by: Stanislav Kinsburskii <staskins@amazon.com>
> CC: Boris Ostrovsky <boris.ostrovsky@oracle.com>
> CC: Juergen Gross <jgross@suse.com>
> CC: Thomas Gleixner <tglx@linutronix.de>
> CC: Ingo Molnar <mingo@redhat.com>
> CC: "H. Peter Anvin" <hpa@zytor.com>
> CC: x86@kernel.org
> CC: xen-devel@lists.xenproject.org
> CC: linux-kernel@vger.kernel.org
> CC: Stanislav Kinsburskii <staskins@amazon.com>
> CC: David Woodhouse <dwmw@amazon.co.uk>
> ---
>  arch/x86/xen/Kconfig        |    7 +++
>  arch/x86/xen/Makefile       |    1 
>  arch/x86/xen/fault_inject.c |  109 +++++++++++++++++++++++++++++++++++++++++++
>  include/xen/fault_inject.h  |   45 ++++++++++++++++++
>  4 files changed, 162 insertions(+)
>  create mode 100644 arch/x86/xen/fault_inject.c
>  create mode 100644 include/xen/fault_inject.h
> 
> diff --git a/arch/x86/xen/Kconfig b/arch/x86/xen/Kconfig
> index c1f98f3..483fc16 100644
> --- a/arch/x86/xen/Kconfig
> +++ b/arch/x86/xen/Kconfig
> @@ -77,3 +77,10 @@ config XEN_PVH
>  	bool "Support for running as a PVH guest"
>  	depends on XEN && XEN_PVHVM && ACPI
>  	def_bool n
> +
> +config XEN_FAULT_INJECTION
> +	bool "Enable Xen fault injection"
> +	depends on FAULT_INJECTION_DEBUG_FS
> +	default n
> +	help
> +	  Enable Xen fault injection facility

Why for x86 only? I'd rather add this under drivers/xen

> diff --git a/arch/x86/xen/Makefile b/arch/x86/xen/Makefile
> index d83cb54..3158fe1 100644
> --- a/arch/x86/xen/Makefile
> +++ b/arch/x86/xen/Makefile
> @@ -34,3 +34,4 @@ obj-$(CONFIG_XEN_DOM0)		+= vga.o
>  obj-$(CONFIG_SWIOTLB_XEN)	+= pci-swiotlb-xen.o
>  obj-$(CONFIG_XEN_EFI)		+= efi.o
>  obj-$(CONFIG_XEN_PVH)	 	+= xen-pvh.o
> +obj-$(CONFIG_XEN_FAULT_INJECTION)	+= fault_inject.o
> diff --git a/arch/x86/xen/fault_inject.c b/arch/x86/xen/fault_inject.c
> new file mode 100644
> index 0000000..ecf0f7c
> --- /dev/null
> +++ b/arch/x86/xen/fault_inject.c
> @@ -0,0 +1,109 @@
> +/*
> + * Fauit injection interface for Xen virtual block devices
> + *
> + * Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
> + *
> + * 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; or, when distributed
> + * separately from the Linux kernel or incorporated into other
> + * software packages, subject to the following license:

Please use the appropriate SPDX header instead of the full GPL2
boilerplate.


Juergen

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

Re: [PATCH 2/3] xen netback: add fault injection facility

[Juergen Gross]

On 20/04/18 12:47, Stanislav Kinsburskii wrote:
> This patch adds wrapper helpers around generic Xen fault inject facility.
> The major reason is to keep all the module fault injection directories
> in a dedicated subdirectory instead of Xen fault inject root.
> 
> IOW, when using these helpers, per-device and named by device name fault
> injection control directories will appear under the following directory:
> - /sys/kernel/debug/xen/fault_inject/xen-netback/
> instead of:
> - /sys/kernel/debug/xen/fault_inject/
> 
> Signed-off-by: Stanislav Kinsburskii <staskins@amazon.com>
> CC: Wei Liu <wei.liu2@citrix.com>
> CC: Paul Durrant <paul.durrant@citrix.com>
> CC: "David S. Miller" <davem@davemloft.net>
> CC: Matteo Croce <mcroce@redhat.com>
> CC: Stefan Hajnoczi <stefanha@redhat.com>
> CC: Daniel Borkmann <daniel@iogearbox.net>
> CC: Gerard Garcia <ggarcia@deic.uab.cat>
> CC: David Ahern <dsa@cumulusnetworks.com>
> CC: Juergen Gross <jgross@suse.com>
> CC: Amir Levy <amir.jer.levy@intel.com>
> CC: Jakub Kicinski <jakub.kicinski@netronome.com>
> CC: linux-kernel@vger.kernel.org
> CC: netdev@vger.kernel.org
> CC: xen-devel@lists.xenproject.org
> CC: Stanislav Kinsburskii <staskins@amazon.com>
> CC: David Woodhouse <dwmw@amazon.co.uk>
> ---
>  drivers/net/Kconfig                  |    8 ++
>  drivers/net/xen-netback/Makefile     |    1 
>  drivers/net/xen-netback/common.h     |    3 +
>  drivers/net/xen-netback/netback.c    |    3 +
>  drivers/net/xen-netback/netback_fi.c |  119 ++++++++++++++++++++++++++++++++++
>  drivers/net/xen-netback/netback_fi.h |   35 ++++++++++
>  drivers/net/xen-netback/xenbus.c     |    6 ++
>  7 files changed, 175 insertions(+)
>  create mode 100644 drivers/net/xen-netback/netback_fi.c
>  create mode 100644 drivers/net/xen-netback/netback_fi.h
> 
> diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig
> index 8918466..5cc9acd 100644
> --- a/drivers/net/Kconfig
> +++ b/drivers/net/Kconfig
> @@ -465,6 +465,14 @@ config XEN_NETDEV_BACKEND
>  	  compile this driver as a module, chose M here: the module
>  	  will be called xen-netback.
>  
> +config XEN_NETDEV_BACKEND_FAULT_INJECTION
> +	  bool "Xen net-device backend driver fault injection"
> +	  depends on XEN_NETDEV_BACKEND
> +	  depends on XEN_FAULT_INJECTION
> +	  default n
> +	  help
> +	    Allow to inject errors to Xen backend network driver
> +
>  config VMXNET3
>  	tristate "VMware VMXNET3 ethernet driver"
>  	depends on PCI && INET
> diff --git a/drivers/net/xen-netback/Makefile b/drivers/net/xen-netback/Makefile
> index d49798a..28abcdc 100644
> --- a/drivers/net/xen-netback/Makefile
> +++ b/drivers/net/xen-netback/Makefile
> @@ -1,3 +1,4 @@
>  obj-$(CONFIG_XEN_NETDEV_BACKEND) := xen-netback.o
>  
>  xen-netback-y := netback.o xenbus.o interface.o hash.o rx.o
> +xen-netback-$(CONFIG_XEN_NETDEV_BACKEND_FAULT_INJECTION) += netback_fi.o
> diff --git a/drivers/net/xen-netback/common.h b/drivers/net/xen-netback/common.h
> index a46a1e9..30d676d 100644
> --- a/drivers/net/xen-netback/common.h
> +++ b/drivers/net/xen-netback/common.h
> @@ -286,6 +286,9 @@ struct xenvif {
>  
>  #ifdef CONFIG_DEBUG_FS
>  	struct dentry *xenvif_dbg_root;
> +#ifdef CONFIG_XEN_NETDEV_BACKEND_FAULT_INJECTION
> +	void *fi_info;
> +#endif
>  #endif
>  
>  	struct xen_netif_ctrl_back_ring ctrl;
> diff --git a/drivers/net/xen-netback/netback.c b/drivers/net/xen-netback/netback.c
> index a27daa2..ecc416e 100644
> --- a/drivers/net/xen-netback/netback.c
> +++ b/drivers/net/xen-netback/netback.c
> @@ -33,6 +33,7 @@
>   */
>  
>  #include "common.h"
> +#include "netback_fi.h"
>  
>  #include <linux/kthread.h>
>  #include <linux/if_vlan.h>
> @@ -1649,6 +1650,7 @@ static int __init netback_init(void)
>  			PTR_ERR(xen_netback_dbg_root));
>  #endif /* CONFIG_DEBUG_FS */
>  
> +	(void) xen_netbk_fi_init();

This is the only usage of xen_netbk_fi_init(). Why don't you make it
return void from the beginning?

>  	return 0;
>  
>  failed_init:
> @@ -1659,6 +1661,7 @@ module_init(netback_init);
>  
>  static void __exit netback_fini(void)
>  {
> +	xen_netbk_fi_fini();
>  #ifdef CONFIG_DEBUG_FS
>  	if (!IS_ERR_OR_NULL(xen_netback_dbg_root))
>  		debugfs_remove_recursive(xen_netback_dbg_root);
> diff --git a/drivers/net/xen-netback/netback_fi.c b/drivers/net/xen-netback/netback_fi.c
> new file mode 100644
> index 0000000..47541d0
> --- /dev/null
> +++ b/drivers/net/xen-netback/netback_fi.c
> @@ -0,0 +1,119 @@
> +/*
> + * Fault injection interface for Xen backend network driver
> + *
> + * Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
> + *
> + * 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; or, when distributed
> + * separately from the Linux kernel or incorporated into other
> + * software packages, subject to the following license:

SPDX again.

> + *
> + * Permission is hereby granted, free of charge, to any person obtaining a copy
> + * of this source file (the "Software"), to deal in the Software without
> + * restriction, including without limitation the rights to use, copy, modify,
> + * merge, publish, distribute, sublicense, and/or sell copies of the Software,
> + * and to permit persons to whom the Software is furnished to do so, subject to
> + * the following conditions:
> + *
> + * The above copyright notice and this permission notice shall be included in
> + * all copies or substantial portions of the Software.
> + *
> + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
> + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
> + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
> + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
> + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
> + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
> + * IN THE SOFTWARE.
> + */
> +
> +#include "common.h"
> +
> +#include <linux/debugfs.h>
> +
> +#include <xen/fault_inject.h>
> +#include "netback_fi.h"
> +
> +static struct dentry *vif_fi_dir;
> +
> +static const char *xenvif_fi_names[] = {
> +};
> +
> +struct xenvif_fi {
> +	struct dentry *dir;
> +	struct xen_fi *faults[XENVIF_FI_MAX];
> +};
> +
> +int xen_netbk_fi_init(void)
> +{
> +	vif_fi_dir = xen_fi_dir_create("xen-netback");
> +	if (!vif_fi_dir)
> +		return -ENOMEM;
> +	return 0;
> +}
> +
> +void xen_netbk_fi_fini(void)
> +{
> +	debugfs_remove_recursive(vif_fi_dir);
> +}
> +
> +void xenvif_fi_fini(struct xenvif *vif)
> +{
> +	struct xenvif_fi *vfi = vif->fi_info;
> +	int fi;
> +
> +	if (!vif->fi_info)
> +		return;
> +
> +	vif->fi_info = NULL;
> +
> +	for (fi = 0; fi < XENVIF_FI_MAX; fi++)
> +		xen_fi_del(vfi->faults[fi]);
> +	debugfs_remove_recursive(vfi->dir);
> +	kfree(vfi);
> +}
> +
> +int xenvif_fi_init(struct xenvif *vif)
> +{
> +	struct dentry *parent;
> +	struct xenvif_fi *vfi;
> +	int fi, err = -ENOMEM;
> +
> +	parent = vif_fi_dir;
> +	if (!parent)
> +		return -ENOMEM;
> +
> +	vfi = kmalloc(sizeof(*vfi), GFP_KERNEL);
> +	if (!vfi)
> +		return -ENOMEM;
> +
> +	vfi->dir = debugfs_create_dir(vif->dev->name, parent);
> +	if (!vfi->dir)
> +		goto err_dir;
> +
> +	for (fi = 0; fi < XENVIF_FI_MAX; fi++) {
> +		vfi->faults[fi] = xen_fi_dir_add(vfi->dir,
> +				xenvif_fi_names[fi]);

How does this work? xenvif_fi_names[] is an empty array and this is the
only reference to it. Who is allocating the memory for that array?

> +		if (!vfi->faults[fi])
> +			goto err_fault;
> +	}
> +
> +	vif->fi_info = vfi;
> +	return 0;
> +
> +err_fault:
> +	for (; fi > 0; fi--)
> +		xen_fi_del(vfi->faults[fi]);

What about vfi->faults[0] ?

> +	debugfs_remove_recursive(vfi->dir);
> +err_dir:
> +	kfree(vfi);
> +	return err;
> +}
> +
> +bool xenvif_should_fail(struct xenvif *vif, xenvif_fi_t type)
> +{
> +	struct xenvif_fi *vfi = vif->fi_info;
> +
> +	return xen_should_fail(vfi->faults[type]);
> +}
> diff --git a/drivers/net/xen-netback/netback_fi.h b/drivers/net/xen-netback/netback_fi.h
> new file mode 100644
> index 0000000..895c6a6
> --- /dev/null
> +++ b/drivers/net/xen-netback/netback_fi.h
> @@ -0,0 +1,35 @@
> +#ifndef _XEN_NETBACK_FI_H
> +#define _XEN_NETBACK_FI_H
> +
> +struct xen_fi;

Why?

> +
> +typedef enum {
> +	XENVIF_FI_MAX
> +} xenvif_fi_t;

It would have helped if you had added some users of the stuff you are
adding here. This enum just looks weird this way.

> +
> +#ifdef CONFIG_XEN_NETDEV_BACKEND_FAULT_INJECTION
> +
> +int xen_netbk_fi_init(void);
> +void xen_netbk_fi_fini(void);
> +
> +void xenvif_fi_fini(struct xenvif *vif);
> +int xenvif_fi_init(struct xenvif *vif);
> +
> +bool xenvif_should_fail(struct xenvif *vif, xenvif_fi_t type);
> +
> +#else
> +
> +static inline int xen_netbk_fi_init(void) { return 0; }
> +static inline void xen_netbk_fi_fini(void) { }
> +
> +static inline void xenvif_fi_fini(struct xenvif *vif) { }
> +static inline int xenvif_fi_init(struct xenvif *vif) { return 0; }
> +
> +static inline bool xenvif_should_fail(struct xenvif *vif, xenvif_fi_t type)
> +{
> +	return false;
> +}
> +
> +#endif /* CONFIG_XEN_NETDEV_BACKEND_FAULT_INJECTION */
> +
> +#endif /* _XEN_NETBACK_FI_H */
> diff --git a/drivers/net/xen-netback/xenbus.c b/drivers/net/xen-netback/xenbus.c
> index e1aef25..c775ee0 100644
> --- a/drivers/net/xen-netback/xenbus.c
> +++ b/drivers/net/xen-netback/xenbus.c
> @@ -21,6 +21,7 @@
>  #include "common.h"
>  #include <linux/vmalloc.h>
>  #include <linux/rtnetlink.h>
> +#include "netback_fi.h"
>  
>  struct backend_info {
>  	struct xenbus_device *dev;
> @@ -502,6 +503,7 @@ static void backend_disconnect(struct backend_info *be)
>  #ifdef CONFIG_DEBUG_FS
>  		xenvif_debugfs_delif(vif);
>  #endif /* CONFIG_DEBUG_FS */
> +		xenvif_fi_fini(vif);
>  		xenvif_disconnect_data(vif);
>  
>  		/* At this point some of the handlers may still be active
> @@ -1024,6 +1026,10 @@ static void connect(struct backend_info *be)
>  		}
>  	}
>  
> +	err = xenvif_fi_init(be->vif);
> +	if (err)
> +		goto err;
> +
>  #ifdef CONFIG_DEBUG_FS
>  	xenvif_debugfs_addif(be->vif);
>  #endif /* CONFIG_DEBUG_FS */
>

Without any user of that infrastructure I really can't say whether I
want this.


Juergen

Re: [PATCH 2/3] xen netback: add fault injection facility

[Juergen Gross]

On 20/04/18 12:47, Stanislav Kinsburskii wrote:
> This patch adds wrapper helpers around generic Xen fault inject facility.
> The major reason is to keep all the module fault injection directories
> in a dedicated subdirectory instead of Xen fault inject root.
> 
> IOW, when using these helpers, per-device and named by device name fault
> injection control directories will appear under the following directory:
> - /sys/kernel/debug/xen/fault_inject/xen-netback/
> instead of:
> - /sys/kernel/debug/xen/fault_inject/
> 
> Signed-off-by: Stanislav Kinsburskii <staskins@amazon.com>
> CC: Wei Liu <wei.liu2@citrix.com>
> CC: Paul Durrant <paul.durrant@citrix.com>
> CC: "David S. Miller" <davem@davemloft.net>
> CC: Matteo Croce <mcroce@redhat.com>
> CC: Stefan Hajnoczi <stefanha@redhat.com>
> CC: Daniel Borkmann <daniel@iogearbox.net>
> CC: Gerard Garcia <ggarcia@deic.uab.cat>
> CC: David Ahern <dsa@cumulusnetworks.com>
> CC: Juergen Gross <jgross@suse.com>
> CC: Amir Levy <amir.jer.levy@intel.com>
> CC: Jakub Kicinski <jakub.kicinski@netronome.com>
> CC: linux-kernel@vger.kernel.org
> CC: netdev@vger.kernel.org
> CC: xen-devel@lists.xenproject.org
> CC: Stanislav Kinsburskii <staskins@amazon.com>
> CC: David Woodhouse <dwmw@amazon.co.uk>
> ---
>  drivers/net/Kconfig                  |    8 ++
>  drivers/net/xen-netback/Makefile     |    1 
>  drivers/net/xen-netback/common.h     |    3 +
>  drivers/net/xen-netback/netback.c    |    3 +
>  drivers/net/xen-netback/netback_fi.c |  119 ++++++++++++++++++++++++++++++++++
>  drivers/net/xen-netback/netback_fi.h |   35 ++++++++++
>  drivers/net/xen-netback/xenbus.c     |    6 ++
>  7 files changed, 175 insertions(+)
>  create mode 100644 drivers/net/xen-netback/netback_fi.c
>  create mode 100644 drivers/net/xen-netback/netback_fi.h
> 
> diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig
> index 8918466..5cc9acd 100644
> --- a/drivers/net/Kconfig
> +++ b/drivers/net/Kconfig
> @@ -465,6 +465,14 @@ config XEN_NETDEV_BACKEND
>  	  compile this driver as a module, chose M here: the module
>  	  will be called xen-netback.
>  
> +config XEN_NETDEV_BACKEND_FAULT_INJECTION
> +	  bool "Xen net-device backend driver fault injection"
> +	  depends on XEN_NETDEV_BACKEND
> +	  depends on XEN_FAULT_INJECTION
> +	  default n
> +	  help
> +	    Allow to inject errors to Xen backend network driver
> +
>  config VMXNET3
>  	tristate "VMware VMXNET3 ethernet driver"
>  	depends on PCI && INET
> diff --git a/drivers/net/xen-netback/Makefile b/drivers/net/xen-netback/Makefile
> index d49798a..28abcdc 100644
> --- a/drivers/net/xen-netback/Makefile
> +++ b/drivers/net/xen-netback/Makefile
> @@ -1,3 +1,4 @@
>  obj-$(CONFIG_XEN_NETDEV_BACKEND) := xen-netback.o
>  
>  xen-netback-y := netback.o xenbus.o interface.o hash.o rx.o
> +xen-netback-$(CONFIG_XEN_NETDEV_BACKEND_FAULT_INJECTION) += netback_fi.o
> diff --git a/drivers/net/xen-netback/common.h b/drivers/net/xen-netback/common.h
> index a46a1e9..30d676d 100644
> --- a/drivers/net/xen-netback/common.h
> +++ b/drivers/net/xen-netback/common.h
> @@ -286,6 +286,9 @@ struct xenvif {
>  
>  #ifdef CONFIG_DEBUG_FS
>  	struct dentry *xenvif_dbg_root;
> +#ifdef CONFIG_XEN_NETDEV_BACKEND_FAULT_INJECTION
> +	void *fi_info;
> +#endif
>  #endif
>  
>  	struct xen_netif_ctrl_back_ring ctrl;
> diff --git a/drivers/net/xen-netback/netback.c b/drivers/net/xen-netback/netback.c
> index a27daa2..ecc416e 100644
> --- a/drivers/net/xen-netback/netback.c
> +++ b/drivers/net/xen-netback/netback.c
> @@ -33,6 +33,7 @@
>   */
>  
>  #include "common.h"
> +#include "netback_fi.h"
>  
>  #include <linux/kthread.h>
>  #include <linux/if_vlan.h>
> @@ -1649,6 +1650,7 @@ static int __init netback_init(void)
>  			PTR_ERR(xen_netback_dbg_root));
>  #endif /* CONFIG_DEBUG_FS */
>  
> +	(void) xen_netbk_fi_init();

This is the only usage of xen_netbk_fi_init(). Why don't you make it
return void from the beginning?

>  	return 0;
>  
>  failed_init:
> @@ -1659,6 +1661,7 @@ module_init(netback_init);
>  
>  static void __exit netback_fini(void)
>  {
> +	xen_netbk_fi_fini();
>  #ifdef CONFIG_DEBUG_FS
>  	if (!IS_ERR_OR_NULL(xen_netback_dbg_root))
>  		debugfs_remove_recursive(xen_netback_dbg_root);
> diff --git a/drivers/net/xen-netback/netback_fi.c b/drivers/net/xen-netback/netback_fi.c
> new file mode 100644
> index 0000000..47541d0
> --- /dev/null
> +++ b/drivers/net/xen-netback/netback_fi.c
> @@ -0,0 +1,119 @@
> +/*
> + * Fault injection interface for Xen backend network driver
> + *
> + * Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
> + *
> + * 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; or, when distributed
> + * separately from the Linux kernel or incorporated into other
> + * software packages, subject to the following license:

SPDX again.

> + *
> + * Permission is hereby granted, free of charge, to any person obtaining a copy
> + * of this source file (the "Software"), to deal in the Software without
> + * restriction, including without limitation the rights to use, copy, modify,
> + * merge, publish, distribute, sublicense, and/or sell copies of the Software,
> + * and to permit persons to whom the Software is furnished to do so, subject to
> + * the following conditions:
> + *
> + * The above copyright notice and this permission notice shall be included in
> + * all copies or substantial portions of the Software.
> + *
> + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
> + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
> + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
> + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
> + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
> + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
> + * IN THE SOFTWARE.
> + */
> +
> +#include "common.h"
> +
> +#include <linux/debugfs.h>
> +
> +#include <xen/fault_inject.h>
> +#include "netback_fi.h"
> +
> +static struct dentry *vif_fi_dir;
> +
> +static const char *xenvif_fi_names[] = {
> +};
> +
> +struct xenvif_fi {
> +	struct dentry *dir;
> +	struct xen_fi *faults[XENVIF_FI_MAX];
> +};
> +
> +int xen_netbk_fi_init(void)
> +{
> +	vif_fi_dir = xen_fi_dir_create("xen-netback");
> +	if (!vif_fi_dir)
> +		return -ENOMEM;
> +	return 0;
> +}
> +
> +void xen_netbk_fi_fini(void)
> +{
> +	debugfs_remove_recursive(vif_fi_dir);
> +}
> +
> +void xenvif_fi_fini(struct xenvif *vif)
> +{
> +	struct xenvif_fi *vfi = vif->fi_info;
> +	int fi;
> +
> +	if (!vif->fi_info)
> +		return;
> +
> +	vif->fi_info = NULL;
> +
> +	for (fi = 0; fi < XENVIF_FI_MAX; fi++)
> +		xen_fi_del(vfi->faults[fi]);
> +	debugfs_remove_recursive(vfi->dir);
> +	kfree(vfi);
> +}
> +
> +int xenvif_fi_init(struct xenvif *vif)
> +{
> +	struct dentry *parent;
> +	struct xenvif_fi *vfi;
> +	int fi, err = -ENOMEM;
> +
> +	parent = vif_fi_dir;
> +	if (!parent)
> +		return -ENOMEM;
> +
> +	vfi = kmalloc(sizeof(*vfi), GFP_KERNEL);
> +	if (!vfi)
> +		return -ENOMEM;
> +
> +	vfi->dir = debugfs_create_dir(vif->dev->name, parent);
> +	if (!vfi->dir)
> +		goto err_dir;
> +
> +	for (fi = 0; fi < XENVIF_FI_MAX; fi++) {
> +		vfi->faults[fi] = xen_fi_dir_add(vfi->dir,
> +				xenvif_fi_names[fi]);

How does this work? xenvif_fi_names[] is an empty array and this is the
only reference to it. Who is allocating the memory for that array?

> +		if (!vfi->faults[fi])
> +			goto err_fault;
> +	}
> +
> +	vif->fi_info = vfi;
> +	return 0;
> +
> +err_fault:
> +	for (; fi > 0; fi--)
> +		xen_fi_del(vfi->faults[fi]);

What about vfi->faults[0] ?

> +	debugfs_remove_recursive(vfi->dir);
> +err_dir:
> +	kfree(vfi);
> +	return err;
> +}
> +
> +bool xenvif_should_fail(struct xenvif *vif, xenvif_fi_t type)
> +{
> +	struct xenvif_fi *vfi = vif->fi_info;
> +
> +	return xen_should_fail(vfi->faults[type]);
> +}
> diff --git a/drivers/net/xen-netback/netback_fi.h b/drivers/net/xen-netback/netback_fi.h
> new file mode 100644
> index 0000000..895c6a6
> --- /dev/null
> +++ b/drivers/net/xen-netback/netback_fi.h
> @@ -0,0 +1,35 @@
> +#ifndef _XEN_NETBACK_FI_H
> +#define _XEN_NETBACK_FI_H
> +
> +struct xen_fi;

Why?

> +
> +typedef enum {
> +	XENVIF_FI_MAX
> +} xenvif_fi_t;

It would have helped if you had added some users of the stuff you are
adding here. This enum just looks weird this way.

> +
> +#ifdef CONFIG_XEN_NETDEV_BACKEND_FAULT_INJECTION
> +
> +int xen_netbk_fi_init(void);
> +void xen_netbk_fi_fini(void);
> +
> +void xenvif_fi_fini(struct xenvif *vif);
> +int xenvif_fi_init(struct xenvif *vif);
> +
> +bool xenvif_should_fail(struct xenvif *vif, xenvif_fi_t type);
> +
> +#else
> +
> +static inline int xen_netbk_fi_init(void) { return 0; }
> +static inline void xen_netbk_fi_fini(void) { }
> +
> +static inline void xenvif_fi_fini(struct xenvif *vif) { }
> +static inline int xenvif_fi_init(struct xenvif *vif) { return 0; }
> +
> +static inline bool xenvif_should_fail(struct xenvif *vif, xenvif_fi_t type)
> +{
> +	return false;
> +}
> +
> +#endif /* CONFIG_XEN_NETDEV_BACKEND_FAULT_INJECTION */
> +
> +#endif /* _XEN_NETBACK_FI_H */
> diff --git a/drivers/net/xen-netback/xenbus.c b/drivers/net/xen-netback/xenbus.c
> index e1aef25..c775ee0 100644
> --- a/drivers/net/xen-netback/xenbus.c
> +++ b/drivers/net/xen-netback/xenbus.c
> @@ -21,6 +21,7 @@
>  #include "common.h"
>  #include <linux/vmalloc.h>
>  #include <linux/rtnetlink.h>
> +#include "netback_fi.h"
>  
>  struct backend_info {
>  	struct xenbus_device *dev;
> @@ -502,6 +503,7 @@ static void backend_disconnect(struct backend_info *be)
>  #ifdef CONFIG_DEBUG_FS
>  		xenvif_debugfs_delif(vif);
>  #endif /* CONFIG_DEBUG_FS */
> +		xenvif_fi_fini(vif);
>  		xenvif_disconnect_data(vif);
>  
>  		/* At this point some of the handlers may still be active
> @@ -1024,6 +1026,10 @@ static void connect(struct backend_info *be)
>  		}
>  	}
>  
> +	err = xenvif_fi_init(be->vif);
> +	if (err)
> +		goto err;
> +
>  #ifdef CONFIG_DEBUG_FS
>  	xenvif_debugfs_addif(be->vif);
>  #endif /* CONFIG_DEBUG_FS */
>

Without any user of that infrastructure I really can't say whether I
want this.


Juergen

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

Re: [PATCH 3/3] xen blkback: add fault injection facility

[Juergen Gross]

On 20/04/18 12:47, Stanislav Kinsburskii wrote:
> This patch adds wrapper helpers around generic Xen fault inject
> facility.
> The major reason is to keep all the module fault injection directories
> in a dedicated subdirectory instead of Xen fault inject root.
> 
> IOW, when using these helpers, per-device and named by device name
> fault injection control directories will appear under the following
> directory:
> - /sys/kernel/debug/xen/fault_inject/xen-blkback/
> instead of:
> - /sys/kernel/debug/xen/fault_inject/
> 
> Signed-off-by: Stanislav Kinsburskii <staskins@amazon.com>
> CC: Jens Axboe <axboe@kernel.dk>
> CC: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
> CC: "Roger Pau Monné" <roger.pau@citrix.com>
> CC: linux-kernel@vger.kernel.org
> CC: linux-block@vger.kernel.org
> CC: xen-devel@lists.xenproject.org
> CC: Stanislav Kinsburskii <staskins@amazon.com>
> CC: David Woodhouse <dwmw@amazon.co.uk>

This is an exact copy of the netback patch apart from the names.

I don't like adding multiple copies of the same coding to the tree.


Juergen

Re: [PATCH 3/3] xen blkback: add fault injection facility

[Juergen Gross]

On 20/04/18 12:47, Stanislav Kinsburskii wrote:
> This patch adds wrapper helpers around generic Xen fault inject
> facility.
> The major reason is to keep all the module fault injection directories
> in a dedicated subdirectory instead of Xen fault inject root.
> 
> IOW, when using these helpers, per-device and named by device name
> fault injection control directories will appear under the following
> directory:
> - /sys/kernel/debug/xen/fault_inject/xen-blkback/
> instead of:
> - /sys/kernel/debug/xen/fault_inject/
> 
> Signed-off-by: Stanislav Kinsburskii <staskins@amazon.com>
> CC: Jens Axboe <axboe@kernel.dk>
> CC: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
> CC: "Roger Pau Monné" <roger.pau@citrix.com>
> CC: linux-kernel@vger.kernel.org
> CC: linux-block@vger.kernel.org
> CC: xen-devel@lists.xenproject.org
> CC: Stanislav Kinsburskii <staskins@amazon.com>
> CC: David Woodhouse <dwmw@amazon.co.uk>

This is an exact copy of the netback patch apart from the names.

I don't like adding multiple copies of the same coding to the tree.


Juergen

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

Re: [PATCH 1/3] xen: add generic fault injection facility

[staskins]
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Re: [PATCH 1/3] xen: add generic fault injection facility

[staskins]

On 04/20/18 12:59, Juergen Gross wrote:
> On 20/04/18 12:47, Stanislav Kinsburskii wrote:
>> diff --git a/arch/x86/xen/Kconfig b/arch/x86/xen/Kconfig
>> index c1f98f3..483fc16 100644
>> --- a/arch/x86/xen/Kconfig
>> +++ b/arch/x86/xen/Kconfig
>> @@ -77,3 +77,10 @@ config XEN_PVH
>>   	bool "Support for running as a PVH guest"
>>   	depends on XEN && XEN_PVHVM && ACPI
>>   	def_bool n
>> +
>> +config XEN_FAULT_INJECTION
>> +	bool "Enable Xen fault injection"
>> +	depends on FAULT_INJECTION_DEBUG_FS
>> +	default n
>> +	help
>> +	  Enable Xen fault injection facility
> Why for x86 only? I'd rather add this under drivers/xen

Sure.

>
>> diff --git a/arch/x86/xen/Makefile b/arch/x86/xen/Makefile
>> index d83cb54..3158fe1 100644
>> --- a/arch/x86/xen/Makefile
>> +++ b/arch/x86/xen/Makefile
>> @@ -34,3 +34,4 @@ obj-$(CONFIG_XEN_DOM0)		+= vga.o
>>   obj-$(CONFIG_SWIOTLB_XEN)	+= pci-swiotlb-xen.o
>>   obj-$(CONFIG_XEN_EFI)		+= efi.o
>>   obj-$(CONFIG_XEN_PVH)	 	+= xen-pvh.o
>> +obj-$(CONFIG_XEN_FAULT_INJECTION)	+= fault_inject.o
>> diff --git a/arch/x86/xen/fault_inject.c b/arch/x86/xen/fault_inject.c
>> new file mode 100644
>> index 0000000..ecf0f7c
>> --- /dev/null
>> +++ b/arch/x86/xen/fault_inject.c
>> @@ -0,0 +1,109 @@
>> +/*
>> + * Fauit injection interface for Xen virtual block devices
>> + *
>> + * Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
>> + *
>> + * 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; or, when distributed
>> + * separately from the Linux kernel or incorporated into other
>> + * software packages, subject to the following license:
> Please use the appropriate SPDX header instead of the full GPL2
> boilerplate.

Ditto.

>
>
> Juergen
>

Amazon Development Center Germany GmbH
Berlin - Dresden - Aachen
main office: Krausenstr. 38, 10117 Berlin
Geschaeftsfuehrer: Dr. Ralf Herbrich, Christian Schlaeger
Ust-ID: DE289237879
Eingetragen am Amtsgericht Charlottenburg HRB 149173 B

Re: [PATCH 1/3] xen: add generic fault injection facility

[staskins]

On 04/20/18 12:59, Juergen Gross wrote:
> On 20/04/18 12:47, Stanislav Kinsburskii wrote:
>> diff --git a/arch/x86/xen/Kconfig b/arch/x86/xen/Kconfig
>> index c1f98f3..483fc16 100644
>> --- a/arch/x86/xen/Kconfig
>> +++ b/arch/x86/xen/Kconfig
>> @@ -77,3 +77,10 @@ config XEN_PVH
>>   	bool "Support for running as a PVH guest"
>>   	depends on XEN && XEN_PVHVM && ACPI
>>   	def_bool n
>> +
>> +config XEN_FAULT_INJECTION
>> +	bool "Enable Xen fault injection"
>> +	depends on FAULT_INJECTION_DEBUG_FS
>> +	default n
>> +	help
>> +	  Enable Xen fault injection facility
> Why for x86 only? I'd rather add this under drivers/xen

Sure.

>
>> diff --git a/arch/x86/xen/Makefile b/arch/x86/xen/Makefile
>> index d83cb54..3158fe1 100644
>> --- a/arch/x86/xen/Makefile
>> +++ b/arch/x86/xen/Makefile
>> @@ -34,3 +34,4 @@ obj-$(CONFIG_XEN_DOM0)		+= vga.o
>>   obj-$(CONFIG_SWIOTLB_XEN)	+= pci-swiotlb-xen.o
>>   obj-$(CONFIG_XEN_EFI)		+= efi.o
>>   obj-$(CONFIG_XEN_PVH)	 	+= xen-pvh.o
>> +obj-$(CONFIG_XEN_FAULT_INJECTION)	+= fault_inject.o
>> diff --git a/arch/x86/xen/fault_inject.c b/arch/x86/xen/fault_inject.c
>> new file mode 100644
>> index 0000000..ecf0f7c
>> --- /dev/null
>> +++ b/arch/x86/xen/fault_inject.c
>> @@ -0,0 +1,109 @@
>> +/*
>> + * Fauit injection interface for Xen virtual block devices
>> + *
>> + * Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
>> + *
>> + * 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; or, when distributed
>> + * separately from the Linux kernel or incorporated into other
>> + * software packages, subject to the following license:
> Please use the appropriate SPDX header instead of the full GPL2
> boilerplate.

Ditto.

>
>
> Juergen
>

Amazon Development Center Germany GmbH
Berlin - Dresden - Aachen
main office: Krausenstr. 38, 10117 Berlin
Geschaeftsfuehrer: Dr. Ralf Herbrich, Christian Schlaeger
Ust-ID: DE289237879
Eingetragen am Amtsgericht Charlottenburg HRB 149173 B
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

Re: [PATCH 2/3] xen netback: add fault injection facility

[staskins]
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Re: [PATCH 2/3] xen netback: add fault injection facility

[staskins]

On 04/20/18 13:25, Juergen Gross wrote:
> On 20/04/18 12:47, Stanislav Kinsburskii wrote:
>> diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig
>> index 8918466..5cc9acd 100644
>> --- a/drivers/net/Kconfig
>> +++ b/drivers/net/Kconfig
>> @@ -465,6 +465,14 @@ config XEN_NETDEV_BACKEND
>>   	  compile this driver as a module, chose M here: the module
>>   	  will be called xen-netback.
>>   
>> +config XEN_NETDEV_BACKEND_FAULT_INJECTION
>> +	  bool "Xen net-device backend driver fault injection"
>> +	  depends on XEN_NETDEV_BACKEND
>> +	  depends on XEN_FAULT_INJECTION
>> +	  default n
>> +	  help
>> +	    Allow to inject errors to Xen backend network driver
>> +
>>   config VMXNET3
>>   	tristate "VMware VMXNET3 ethernet driver"
>>   	depends on PCI && INET
>> diff --git a/drivers/net/xen-netback/Makefile b/drivers/net/xen-netback/Makefile
>> index d49798a..28abcdc 100644
>> --- a/drivers/net/xen-netback/Makefile
>> +++ b/drivers/net/xen-netback/Makefile
>> @@ -1,3 +1,4 @@
>>   obj-$(CONFIG_XEN_NETDEV_BACKEND) := xen-netback.o
>>   
>>   xen-netback-y := netback.o xenbus.o interface.o hash.o rx.o
>> +xen-netback-$(CONFIG_XEN_NETDEV_BACKEND_FAULT_INJECTION) += netback_fi.o
>> diff --git a/drivers/net/xen-netback/common.h b/drivers/net/xen-netback/common.h
>> index a46a1e9..30d676d 100644
>> --- a/drivers/net/xen-netback/common.h
>> +++ b/drivers/net/xen-netback/common.h
>> @@ -286,6 +286,9 @@ struct xenvif {
>>   
>>   #ifdef CONFIG_DEBUG_FS
>>   	struct dentry *xenvif_dbg_root;
>> +#ifdef CONFIG_XEN_NETDEV_BACKEND_FAULT_INJECTION
>> +	void *fi_info;
>> +#endif
>>   #endif
>>   
>>   	struct xen_netif_ctrl_back_ring ctrl;
>> diff --git a/drivers/net/xen-netback/netback.c b/drivers/net/xen-netback/netback.c
>> index a27daa2..ecc416e 100644
>> --- a/drivers/net/xen-netback/netback.c
>> +++ b/drivers/net/xen-netback/netback.c
>> @@ -33,6 +33,7 @@
>>    */
>>   
>>   #include "common.h"
>> +#include "netback_fi.h"
>>   
>>   #include <linux/kthread.h>
>>   #include <linux/if_vlan.h>
>> @@ -1649,6 +1650,7 @@ static int __init netback_init(void)
>>   			PTR_ERR(xen_netback_dbg_root));
>>   #endif /* CONFIG_DEBUG_FS */
>>   
>> +	(void) xen_netbk_fi_init();
> This is the only usage of xen_netbk_fi_init(). Why don't you make it
> return void from the beginning?

Well, I could do so, of course.
My intention was to treat this as an error. But then it doesn't 
correlate to ignored debugfs directory creation error above.

>>   	return 0;
>>   
>>   failed_init:
>> @@ -1659,6 +1661,7 @@ module_init(netback_init);
>>   
>>   static void __exit netback_fini(void)
>>   {
>> +	xen_netbk_fi_fini();
>>   #ifdef CONFIG_DEBUG_FS
>>   	if (!IS_ERR_OR_NULL(xen_netback_dbg_root))
>>   		debugfs_remove_recursive(xen_netback_dbg_root);
>> diff --git a/drivers/net/xen-netback/netback_fi.c b/drivers/net/xen-netback/netback_fi.c
>> new file mode 100644
>> index 0000000..47541d0
>> --- /dev/null
>> +++ b/drivers/net/xen-netback/netback_fi.c
>> @@ -0,0 +1,119 @@
>> +/*
>> + * Fault injection interface for Xen backend network driver
>> + *
>> + * Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
>> + *
>> + * 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; or, when distributed
>> + * separately from the Linux kernel or incorporated into other
>> + * software packages, subject to the following license:
> SPDX again.

Will fix.

>
>> + *
>> + * Permission is hereby granted, free of charge, to any person obtaining a copy
>> + * of this source file (the "Software"), to deal in the Software without
>> + * restriction, including without limitation the rights to use, copy, modify,
>> + * merge, publish, distribute, sublicense, and/or sell copies of the Software,
>> + * and to permit persons to whom the Software is furnished to do so, subject to
>> + * the following conditions:
>> + *
>> + * The above copyright notice and this permission notice shall be included in
>> + * all copies or substantial portions of the Software.
>> + *
>> + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
>> + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
>> + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
>> + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
>> + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
>> + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
>> + * IN THE SOFTWARE.
>> + */
>> +
>> +#include "common.h"
>> +
>> +#include <linux/debugfs.h>
>> +
>> +#include <xen/fault_inject.h>
>> +#include "netback_fi.h"
>> +
>> +static struct dentry *vif_fi_dir;
>> +
>> +static const char *xenvif_fi_names[] = {
>> +};
>> +
>> +struct xenvif_fi {
>> +	struct dentry *dir;
>> +	struct xen_fi *faults[XENVIF_FI_MAX];
>> +};
>> +
>> +int xen_netbk_fi_init(void)
>> +{
>> +	vif_fi_dir = xen_fi_dir_create("xen-netback");
>> +	if (!vif_fi_dir)
>> +		return -ENOMEM;
>> +	return 0;
>> +}
>> +
>> +void xen_netbk_fi_fini(void)
>> +{
>> +	debugfs_remove_recursive(vif_fi_dir);
>> +}
>> +
>> +void xenvif_fi_fini(struct xenvif *vif)
>> +{
>> +	struct xenvif_fi *vfi = vif->fi_info;
>> +	int fi;
>> +
>> +	if (!vif->fi_info)
>> +		return;
>> +
>> +	vif->fi_info = NULL;
>> +
>> +	for (fi = 0; fi < XENVIF_FI_MAX; fi++)
>> +		xen_fi_del(vfi->faults[fi]);
>> +	debugfs_remove_recursive(vfi->dir);
>> +	kfree(vfi);
>> +}
>> +
>> +int xenvif_fi_init(struct xenvif *vif)
>> +{
>> +	struct dentry *parent;
>> +	struct xenvif_fi *vfi;
>> +	int fi, err = -ENOMEM;
>> +
>> +	parent = vif_fi_dir;
>> +	if (!parent)
>> +		return -ENOMEM;
>> +
>> +	vfi = kmalloc(sizeof(*vfi), GFP_KERNEL);
>> +	if (!vfi)
>> +		return -ENOMEM;
>> +
>> +	vfi->dir = debugfs_create_dir(vif->dev->name, parent);
>> +	if (!vfi->dir)
>> +		goto err_dir;
>> +
>> +	for (fi = 0; fi < XENVIF_FI_MAX; fi++) {
>> +		vfi->faults[fi] = xen_fi_dir_add(vfi->dir,
>> +				xenvif_fi_names[fi]);
> How does this work? xenvif_fi_names[] is an empty array and this is the
> only reference to it. Who is allocating the memory for that array?

Well, it works in the way one adds a var to enum (which is used as a key 
later) and a corresponding string into the array (which is used as a 
name for the fault directory in sysfs).

>> +		if (!vfi->faults[fi])
>> +			goto err_fault;
>> +	}
>> +
>> +	vif->fi_info = vfi;
>> +	return 0;
>> +
>> +err_fault:
>> +	for (; fi > 0; fi--)
>> +		xen_fi_del(vfi->faults[fi]);
> What about vfi->faults[0] ?

Thanks! Will fix.


>> +	debugfs_remove_recursive(vfi->dir);
>> +err_dir:
>> +	kfree(vfi);
>> +	return err;
>> +}
>> +
>> +bool xenvif_should_fail(struct xenvif *vif, xenvif_fi_t type)
>> +{
>> +	struct xenvif_fi *vfi = vif->fi_info;
>> +
>> +	return xen_should_fail(vfi->faults[type]);
>> +}
>> diff --git a/drivers/net/xen-netback/netback_fi.h b/drivers/net/xen-netback/netback_fi.h
>> new file mode 100644
>> index 0000000..895c6a6
>> --- /dev/null
>> +++ b/drivers/net/xen-netback/netback_fi.h
>> @@ -0,0 +1,35 @@
>> +#ifndef _XEN_NETBACK_FI_H
>> +#define _XEN_NETBACK_FI_H
>> +
>> +struct xen_fi;
> Why?

Ditto.

>> +
>> +typedef enum {
>> +	XENVIF_FI_MAX
>> +} xenvif_fi_t;
> It would have helped if you had added some users of the stuff you are
> adding here. This enum just looks weird this way.
>
it in pla
Yeah... Probably I should mark this thing as a RFC.

>> +
>> +#ifdef CONFIG_XEN_NETDEV_BACKEND_FAULT_INJECTION
>> +
>> +int xen_netbk_fi_init(void);
>> +void xen_netbk_fi_fini(void);
>> +
>> +void xenvif_fi_fini(struct xenvif *vif);
>> +int xenvif_fi_init(struct xenvif *vif);
>> +
>> +bool xenvif_should_fail(struct xenvif *vif, xenvif_fi_t type);
>> +
>> +#else
>> +
>> +static inline int xen_netbk_fi_init(void) { return 0; }
>> +static inline void xen_netbk_fi_fini(void) { }
>> +
>> +static inline void xenvif_fi_fini(struct xenvif *vif) { }
>> +static inline int xenvif_fi_init(struct xenvif *vif) { return 0; }
>> +
>> +static inline bool xenvif_should_fail(struct xenvif *vif, xenvif_fi_t type)
>> +{
>> +	return false;
>> +}
>> +
>> +#endif /* CONFIG_XEN_NETDEV_BACKEND_FAULT_INJECTION */
>> +
>> +#endif /* _XEN_NETBACK_FI_H */
>> diff --git a/drivers/net/xen-netback/xenbus.c b/drivers/net/xen-netback/xenbus.c
>> index e1aef25..c775ee0 100644
>> --- a/drivers/net/xen-netback/xenbus.c
>> +++ b/drivers/net/xen-netback/xenbus.c
>> @@ -21,6 +21,7 @@
>>   #include "common.h"
>>   #include <linux/vmalloc.h>
>>   #include <linux/rtnetlink.h>
>> +#include "netback_fi.h"
>>   
>>   struct backend_info {
>>   	struct xenbus_device *dev;
>> @@ -502,6 +503,7 @@ static void backend_disconnect(struct backend_info *be)
>>   #ifdef CONFIG_DEBUG_FS
>>   		xenvif_debugfs_delif(vif);
>>   #endif /* CONFIG_DEBUG_FS */
>> +		xenvif_fi_fini(vif);
>>   		xenvif_disconnect_data(vif);
>>   
>>   		/* At this point some of the handlers may still be active
>> @@ -1024,6 +1026,10 @@ static void connect(struct backend_info *be)
>>   		}
>>   	}
>>   
>> +	err = xenvif_fi_init(be->vif);
>> +	if (err)
>> +		goto err;
>> +
>>   #ifdef CONFIG_DEBUG_FS
>>   	xenvif_debugfs_addif(be->vif);
>>   #endif /* CONFIG_DEBUG_FS */
>>
> Without any user of that infrastructure I really can't say whether I
> want this.
>

The code we are using this faults for is not yet sent (we have it in plans).
Probably I'll send it once again after this code using it is sent.
Thanks anyway!

> Juergen
>

Amazon Development Center Germany GmbH
Berlin - Dresden - Aachen
main office: Krausenstr. 38, 10117 Berlin
Geschaeftsfuehrer: Dr. Ralf Herbrich, Christian Schlaeger
Ust-ID: DE289237879
Eingetragen am Amtsgericht Charlottenburg HRB 149173 B

Re: [PATCH 2/3] xen netback: add fault injection facility

[staskins]

On 04/20/18 13:25, Juergen Gross wrote:
> On 20/04/18 12:47, Stanislav Kinsburskii wrote:
>> diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig
>> index 8918466..5cc9acd 100644
>> --- a/drivers/net/Kconfig
>> +++ b/drivers/net/Kconfig
>> @@ -465,6 +465,14 @@ config XEN_NETDEV_BACKEND
>>   	  compile this driver as a module, chose M here: the module
>>   	  will be called xen-netback.
>>   
>> +config XEN_NETDEV_BACKEND_FAULT_INJECTION
>> +	  bool "Xen net-device backend driver fault injection"
>> +	  depends on XEN_NETDEV_BACKEND
>> +	  depends on XEN_FAULT_INJECTION
>> +	  default n
>> +	  help
>> +	    Allow to inject errors to Xen backend network driver
>> +
>>   config VMXNET3
>>   	tristate "VMware VMXNET3 ethernet driver"
>>   	depends on PCI && INET
>> diff --git a/drivers/net/xen-netback/Makefile b/drivers/net/xen-netback/Makefile
>> index d49798a..28abcdc 100644
>> --- a/drivers/net/xen-netback/Makefile
>> +++ b/drivers/net/xen-netback/Makefile
>> @@ -1,3 +1,4 @@
>>   obj-$(CONFIG_XEN_NETDEV_BACKEND) := xen-netback.o
>>   
>>   xen-netback-y := netback.o xenbus.o interface.o hash.o rx.o
>> +xen-netback-$(CONFIG_XEN_NETDEV_BACKEND_FAULT_INJECTION) += netback_fi.o
>> diff --git a/drivers/net/xen-netback/common.h b/drivers/net/xen-netback/common.h
>> index a46a1e9..30d676d 100644
>> --- a/drivers/net/xen-netback/common.h
>> +++ b/drivers/net/xen-netback/common.h
>> @@ -286,6 +286,9 @@ struct xenvif {
>>   
>>   #ifdef CONFIG_DEBUG_FS
>>   	struct dentry *xenvif_dbg_root;
>> +#ifdef CONFIG_XEN_NETDEV_BACKEND_FAULT_INJECTION
>> +	void *fi_info;
>> +#endif
>>   #endif
>>   
>>   	struct xen_netif_ctrl_back_ring ctrl;
>> diff --git a/drivers/net/xen-netback/netback.c b/drivers/net/xen-netback/netback.c
>> index a27daa2..ecc416e 100644
>> --- a/drivers/net/xen-netback/netback.c
>> +++ b/drivers/net/xen-netback/netback.c
>> @@ -33,6 +33,7 @@
>>    */
>>   
>>   #include "common.h"
>> +#include "netback_fi.h"
>>   
>>   #include <linux/kthread.h>
>>   #include <linux/if_vlan.h>
>> @@ -1649,6 +1650,7 @@ static int __init netback_init(void)
>>   			PTR_ERR(xen_netback_dbg_root));
>>   #endif /* CONFIG_DEBUG_FS */
>>   
>> +	(void) xen_netbk_fi_init();
> This is the only usage of xen_netbk_fi_init(). Why don't you make it
> return void from the beginning?

Well, I could do so, of course.
My intention was to treat this as an error. But then it doesn't 
correlate to ignored debugfs directory creation error above.

>>   	return 0;
>>   
>>   failed_init:
>> @@ -1659,6 +1661,7 @@ module_init(netback_init);
>>   
>>   static void __exit netback_fini(void)
>>   {
>> +	xen_netbk_fi_fini();
>>   #ifdef CONFIG_DEBUG_FS
>>   	if (!IS_ERR_OR_NULL(xen_netback_dbg_root))
>>   		debugfs_remove_recursive(xen_netback_dbg_root);
>> diff --git a/drivers/net/xen-netback/netback_fi.c b/drivers/net/xen-netback/netback_fi.c
>> new file mode 100644
>> index 0000000..47541d0
>> --- /dev/null
>> +++ b/drivers/net/xen-netback/netback_fi.c
>> @@ -0,0 +1,119 @@
>> +/*
>> + * Fault injection interface for Xen backend network driver
>> + *
>> + * Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
>> + *
>> + * 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; or, when distributed
>> + * separately from the Linux kernel or incorporated into other
>> + * software packages, subject to the following license:
> SPDX again.

Will fix.

>
>> + *
>> + * Permission is hereby granted, free of charge, to any person obtaining a copy
>> + * of this source file (the "Software"), to deal in the Software without
>> + * restriction, including without limitation the rights to use, copy, modify,
>> + * merge, publish, distribute, sublicense, and/or sell copies of the Software,
>> + * and to permit persons to whom the Software is furnished to do so, subject to
>> + * the following conditions:
>> + *
>> + * The above copyright notice and this permission notice shall be included in
>> + * all copies or substantial portions of the Software.
>> + *
>> + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
>> + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
>> + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
>> + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
>> + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
>> + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
>> + * IN THE SOFTWARE.
>> + */
>> +
>> +#include "common.h"
>> +
>> +#include <linux/debugfs.h>
>> +
>> +#include <xen/fault_inject.h>
>> +#include "netback_fi.h"
>> +
>> +static struct dentry *vif_fi_dir;
>> +
>> +static const char *xenvif_fi_names[] = {
>> +};
>> +
>> +struct xenvif_fi {
>> +	struct dentry *dir;
>> +	struct xen_fi *faults[XENVIF_FI_MAX];
>> +};
>> +
>> +int xen_netbk_fi_init(void)
>> +{
>> +	vif_fi_dir = xen_fi_dir_create("xen-netback");
>> +	if (!vif_fi_dir)
>> +		return -ENOMEM;
>> +	return 0;
>> +}
>> +
>> +void xen_netbk_fi_fini(void)
>> +{
>> +	debugfs_remove_recursive(vif_fi_dir);
>> +}
>> +
>> +void xenvif_fi_fini(struct xenvif *vif)
>> +{
>> +	struct xenvif_fi *vfi = vif->fi_info;
>> +	int fi;
>> +
>> +	if (!vif->fi_info)
>> +		return;
>> +
>> +	vif->fi_info = NULL;
>> +
>> +	for (fi = 0; fi < XENVIF_FI_MAX; fi++)
>> +		xen_fi_del(vfi->faults[fi]);
>> +	debugfs_remove_recursive(vfi->dir);
>> +	kfree(vfi);
>> +}
>> +
>> +int xenvif_fi_init(struct xenvif *vif)
>> +{
>> +	struct dentry *parent;
>> +	struct xenvif_fi *vfi;
>> +	int fi, err = -ENOMEM;
>> +
>> +	parent = vif_fi_dir;
>> +	if (!parent)
>> +		return -ENOMEM;
>> +
>> +	vfi = kmalloc(sizeof(*vfi), GFP_KERNEL);
>> +	if (!vfi)
>> +		return -ENOMEM;
>> +
>> +	vfi->dir = debugfs_create_dir(vif->dev->name, parent);
>> +	if (!vfi->dir)
>> +		goto err_dir;
>> +
>> +	for (fi = 0; fi < XENVIF_FI_MAX; fi++) {
>> +		vfi->faults[fi] = xen_fi_dir_add(vfi->dir,
>> +				xenvif_fi_names[fi]);
> How does this work? xenvif_fi_names[] is an empty array and this is the
> only reference to it. Who is allocating the memory for that array?

Well, it works in the way one adds a var to enum (which is used as a key 
later) and a corresponding string into the array (which is used as a 
name for the fault directory in sysfs).

>> +		if (!vfi->faults[fi])
>> +			goto err_fault;
>> +	}
>> +
>> +	vif->fi_info = vfi;
>> +	return 0;
>> +
>> +err_fault:
>> +	for (; fi > 0; fi--)
>> +		xen_fi_del(vfi->faults[fi]);
> What about vfi->faults[0] ?

Thanks! Will fix.


>> +	debugfs_remove_recursive(vfi->dir);
>> +err_dir:
>> +	kfree(vfi);
>> +	return err;
>> +}
>> +
>> +bool xenvif_should_fail(struct xenvif *vif, xenvif_fi_t type)
>> +{
>> +	struct xenvif_fi *vfi = vif->fi_info;
>> +
>> +	return xen_should_fail(vfi->faults[type]);
>> +}
>> diff --git a/drivers/net/xen-netback/netback_fi.h b/drivers/net/xen-netback/netback_fi.h
>> new file mode 100644
>> index 0000000..895c6a6
>> --- /dev/null
>> +++ b/drivers/net/xen-netback/netback_fi.h
>> @@ -0,0 +1,35 @@
>> +#ifndef _XEN_NETBACK_FI_H
>> +#define _XEN_NETBACK_FI_H
>> +
>> +struct xen_fi;
> Why?

Ditto.

>> +
>> +typedef enum {
>> +	XENVIF_FI_MAX
>> +} xenvif_fi_t;
> It would have helped if you had added some users of the stuff you are
> adding here. This enum just looks weird this way.
>
it in pla
Yeah... Probably I should mark this thing as a RFC.

>> +
>> +#ifdef CONFIG_XEN_NETDEV_BACKEND_FAULT_INJECTION
>> +
>> +int xen_netbk_fi_init(void);
>> +void xen_netbk_fi_fini(void);
>> +
>> +void xenvif_fi_fini(struct xenvif *vif);
>> +int xenvif_fi_init(struct xenvif *vif);
>> +
>> +bool xenvif_should_fail(struct xenvif *vif, xenvif_fi_t type);
>> +
>> +#else
>> +
>> +static inline int xen_netbk_fi_init(void) { return 0; }
>> +static inline void xen_netbk_fi_fini(void) { }
>> +
>> +static inline void xenvif_fi_fini(struct xenvif *vif) { }
>> +static inline int xenvif_fi_init(struct xenvif *vif) { return 0; }
>> +
>> +static inline bool xenvif_should_fail(struct xenvif *vif, xenvif_fi_t type)
>> +{
>> +	return false;
>> +}
>> +
>> +#endif /* CONFIG_XEN_NETDEV_BACKEND_FAULT_INJECTION */
>> +
>> +#endif /* _XEN_NETBACK_FI_H */
>> diff --git a/drivers/net/xen-netback/xenbus.c b/drivers/net/xen-netback/xenbus.c
>> index e1aef25..c775ee0 100644
>> --- a/drivers/net/xen-netback/xenbus.c
>> +++ b/drivers/net/xen-netback/xenbus.c
>> @@ -21,6 +21,7 @@
>>   #include "common.h"
>>   #include <linux/vmalloc.h>
>>   #include <linux/rtnetlink.h>
>> +#include "netback_fi.h"
>>   
>>   struct backend_info {
>>   	struct xenbus_device *dev;
>> @@ -502,6 +503,7 @@ static void backend_disconnect(struct backend_info *be)
>>   #ifdef CONFIG_DEBUG_FS
>>   		xenvif_debugfs_delif(vif);
>>   #endif /* CONFIG_DEBUG_FS */
>> +		xenvif_fi_fini(vif);
>>   		xenvif_disconnect_data(vif);
>>   
>>   		/* At this point some of the handlers may still be active
>> @@ -1024,6 +1026,10 @@ static void connect(struct backend_info *be)
>>   		}
>>   	}
>>   
>> +	err = xenvif_fi_init(be->vif);
>> +	if (err)
>> +		goto err;
>> +
>>   #ifdef CONFIG_DEBUG_FS
>>   	xenvif_debugfs_addif(be->vif);
>>   #endif /* CONFIG_DEBUG_FS */
>>
> Without any user of that infrastructure I really can't say whether I
> want this.
>

The code we are using this faults for is not yet sent (we have it in plans).
Probably I'll send it once again after this code using it is sent.
Thanks anyway!

> Juergen
>

Amazon Development Center Germany GmbH
Berlin - Dresden - Aachen
main office: Krausenstr. 38, 10117 Berlin
Geschaeftsfuehrer: Dr. Ralf Herbrich, Christian Schlaeger
Ust-ID: DE289237879
Eingetragen am Amtsgericht Charlottenburg HRB 149173 B
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

Re: [PATCH 3/3] xen blkback: add fault injection facility

[staskins]

T24gMDQvMjAvMTggMTM6MjgsIEp1ZXJnZW4gR3Jvc3Mgd3JvdGU6Cj4gT24gMjAvMDQvMTggMTI6
NDcsIFN0YW5pc2xhdiBLaW5zYnVyc2tpaSB3cm90ZToKPj4gVGhpcyBwYXRjaCBhZGRzIHdyYXBw
ZXIgaGVscGVycyBhcm91bmQgZ2VuZXJpYyBYZW4gZmF1bHQgaW5qZWN0Cj4+IGZhY2lsaXR5Lgo+
PiBUaGUgbWFqb3IgcmVhc29uIGlzIHRvIGtlZXAgYWxsIHRoZSBtb2R1bGUgZmF1bHQgaW5qZWN0
aW9uIGRpcmVjdG9yaWVzCj4+IGluIGEgZGVkaWNhdGVkIHN1YmRpcmVjdG9yeSBpbnN0ZWFkIG9m
IFhlbiBmYXVsdCBpbmplY3Qgcm9vdC4KPj4KPj4gSU9XLCB3aGVuIHVzaW5nIHRoZXNlIGhlbHBl
cnMsIHBlci1kZXZpY2UgYW5kIG5hbWVkIGJ5IGRldmljZSBuYW1lCj4+IGZhdWx0IGluamVjdGlv
biBjb250cm9sIGRpcmVjdG9yaWVzIHdpbGwgYXBwZWFyIHVuZGVyIHRoZSBmb2xsb3dpbmcKPj4g
ZGlyZWN0b3J5Ogo+PiAtIC9zeXMva2VybmVsL2RlYnVnL3hlbi9mYXVsdF9pbmplY3QveGVuLWJs
a2JhY2svCj4+IGluc3RlYWQgb2Y6Cj4+IC0gL3N5cy9rZXJuZWwvZGVidWcveGVuL2ZhdWx0X2lu
amVjdC8KPj4KPj4gU2lnbmVkLW9mZi1ieTogU3RhbmlzbGF2IEtpbnNidXJza2lpIDxzdGFza2lu
c0BhbWF6b24uY29tPgo+PiBDQzogSmVucyBBeGJvZSA8YXhib2VAa2VybmVsLmRrPgo+PiBDQzog
S29ucmFkIFJ6ZXN6dXRlayBXaWxrIDxrb25yYWQud2lsa0BvcmFjbGUuY29tPgo+PiBDQzogIlJv
Z2VyIFBhdSBNb25uw6kiIDxyb2dlci5wYXVAY2l0cml4LmNvbT4KPj4gQ0M6IGxpbnV4LWtlcm5l
bEB2Z2VyLmtlcm5lbC5vcmcKPj4gQ0M6IGxpbnV4LWJsb2NrQHZnZXIua2VybmVsLm9yZwo+PiBD
QzogeGVuLWRldmVsQGxpc3RzLnhlbnByb2plY3Qub3JnCj4+IENDOiBTdGFuaXNsYXYgS2luc2J1
cnNraWkgPHN0YXNraW5zQGFtYXpvbi5jb20+Cj4+IENDOiBEYXZpZCBXb29kaG91c2UgPGR3bXdA
YW1hem9uLmNvLnVrPgo+IFRoaXMgaXMgYW4gZXhhY3QgY29weSBvZiB0aGUgbmV0YmFjayBwYXRj
aCBhcGFydCBmcm9tIHRoZSBuYW1lcy4KPgo+IEkgZG9uJ3QgbGlrZSBhZGRpbmcgbXVsdGlwbGUg
Y29waWVzIG9mIHRoZSBzYW1lIGNvZGluZyB0byB0aGUgdHJlZS4KClN1cmUsIHdpbGwgZGVkdXBw
bGljYXRlIHRoaXMuCgo+Cj4gSnVlcmdlbgo+CgpBbWF6b24gRGV2ZWxvcG1lbnQgQ2VudGVyIEdl
cm1hbnkgR21iSApCZXJsaW4gLSBEcmVzZGVuIC0gQWFjaGVuCm1haW4gb2ZmaWNlOiBLcmF1c2Vu
c3RyLiAzOCwgMTAxMTcgQmVybGluCkdlc2NoYWVmdHNmdWVocmVyOiBEci4gUmFsZiBIZXJicmlj
aCwgQ2hyaXN0aWFuIFNjaGxhZWdlcgpVc3QtSUQ6IERFMjg5MjM3ODc5CkVpbmdldHJhZ2VuIGFt
IEFtdHNnZXJpY2h0IENoYXJsb3R0ZW5idXJnIEhSQiAxNDkxNzMgQgo=

Re: [PATCH 3/3] xen blkback: add fault injection facility

[staskins]

On 04/20/18 13:28, Juergen Gross wrote:
> On 20/04/18 12:47, Stanislav Kinsburskii wrote:
>> This patch adds wrapper helpers around generic Xen fault inject
>> facility.
>> The major reason is to keep all the module fault injection directories
>> in a dedicated subdirectory instead of Xen fault inject root.
>>
>> IOW, when using these helpers, per-device and named by device name
>> fault injection control directories will appear under the following
>> directory:
>> - /sys/kernel/debug/xen/fault_inject/xen-blkback/
>> instead of:
>> - /sys/kernel/debug/xen/fault_inject/
>>
>> Signed-off-by: Stanislav Kinsburskii <staskins@amazon.com>
>> CC: Jens Axboe <axboe@kernel.dk>
>> CC: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
>> CC: "Roger Pau Monné" <roger.pau@citrix.com>
>> CC: linux-kernel@vger.kernel.org
>> CC: linux-block@vger.kernel.org
>> CC: xen-devel@lists.xenproject.org
>> CC: Stanislav Kinsburskii <staskins@amazon.com>
>> CC: David Woodhouse <dwmw@amazon.co.uk>
> This is an exact copy of the netback patch apart from the names.
>
> I don't like adding multiple copies of the same coding to the tree.

Sure, will dedupplicate this.

>
> Juergen
>

Amazon Development Center Germany GmbH
Berlin - Dresden - Aachen
main office: Krausenstr. 38, 10117 Berlin
Geschaeftsfuehrer: Dr. Ralf Herbrich, Christian Schlaeger
Ust-ID: DE289237879
Eingetragen am Amtsgericht Charlottenburg HRB 149173 B

Re: [PATCH 3/3] xen blkback: add fault injection facility

[staskins]

On 04/20/18 13:28, Juergen Gross wrote:
> On 20/04/18 12:47, Stanislav Kinsburskii wrote:
>> This patch adds wrapper helpers around generic Xen fault inject
>> facility.
>> The major reason is to keep all the module fault injection directories
>> in a dedicated subdirectory instead of Xen fault inject root.
>>
>> IOW, when using these helpers, per-device and named by device name
>> fault injection control directories will appear under the following
>> directory:
>> - /sys/kernel/debug/xen/fault_inject/xen-blkback/
>> instead of:
>> - /sys/kernel/debug/xen/fault_inject/
>>
>> Signed-off-by: Stanislav Kinsburskii <staskins@amazon.com>
>> CC: Jens Axboe <axboe@kernel.dk>
>> CC: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
>> CC: "Roger Pau Monné" <roger.pau@citrix.com>
>> CC: linux-kernel@vger.kernel.org
>> CC: linux-block@vger.kernel.org
>> CC: xen-devel@lists.xenproject.org
>> CC: Stanislav Kinsburskii <staskins@amazon.com>
>> CC: David Woodhouse <dwmw@amazon.co.uk>
> This is an exact copy of the netback patch apart from the names.
>
> I don't like adding multiple copies of the same coding to the tree.

Sure, will dedupplicate this.

>
> Juergen
>

Amazon Development Center Germany GmbH
Berlin - Dresden - Aachen
main office: Krausenstr. 38, 10117 Berlin
Geschaeftsfuehrer: Dr. Ralf Herbrich, Christian Schlaeger
Ust-ID: DE289237879
Eingetragen am Amtsgericht Charlottenburg HRB 149173 B
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

Re: [PATCH 2/3] xen netback: add fault injection facility

[Juergen Gross]

On 20/04/18 14:52, staskins@amazon.com wrote:
> On 04/20/18 13:25, Juergen Gross wrote:
>> On 20/04/18 12:47, Stanislav Kinsburskii wrote:
>>> +    for (fi = 0; fi < XENVIF_FI_MAX; fi++) {
>>> +        vfi->faults[fi] = xen_fi_dir_add(vfi->dir,
>>> +                xenvif_fi_names[fi]);
>> How does this work? xenvif_fi_names[] is an empty array and this is the
>> only reference to it. Who is allocating the memory for that array?
> 
> Well, it works in the way one adds a var to enum (which is used as a key
> later) and a corresponding string into the array (which is used as a
> name for the fault directory in sysfs).

Then you should size the array via XENVIF_FI_MAX.


Juergen

Re: [PATCH 2/3] xen netback: add fault injection facility

[Juergen Gross]

On 20/04/18 14:52, staskins@amazon.com wrote:
> On 04/20/18 13:25, Juergen Gross wrote:
>> On 20/04/18 12:47, Stanislav Kinsburskii wrote:
>>> +    for (fi = 0; fi < XENVIF_FI_MAX; fi++) {
>>> +        vfi->faults[fi] = xen_fi_dir_add(vfi->dir,
>>> +                xenvif_fi_names[fi]);
>> How does this work? xenvif_fi_names[] is an empty array and this is the
>> only reference to it. Who is allocating the memory for that array?
> 
> Well, it works in the way one adds a var to enum (which is used as a key
> later) and a corresponding string into the array (which is used as a
> name for the fault directory in sysfs).

Then you should size the array via XENVIF_FI_MAX.


Juergen

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

Re: [PATCH 2/3] xen netback: add fault injection facility

[staskins]

T24gMDQvMjAvMTggMTU6MDAsIEp1ZXJnZW4gR3Jvc3Mgd3JvdGU6Cj4gT24gMjAvMDQvMTggMTQ6
NTIsIHN0YXNraW5zQGFtYXpvbi5jb20gd3JvdGU6Cj4+IE9uIDA0LzIwLzE4IDEzOjI1LCBKdWVy
Z2VuIEdyb3NzIHdyb3RlOgo+Pj4gT24gMjAvMDQvMTggMTI6NDcsIFN0YW5pc2xhdiBLaW5zYnVy
c2tpaSB3cm90ZToKPj4+PiArwqDCoMKgIGZvciAoZmkgPSAwOyBmaSA8IFhFTlZJRl9GSV9NQVg7
IGZpKyspIHsKPj4+PiArwqDCoMKgwqDCoMKgwqAgdmZpLT5mYXVsdHNbZmldID0geGVuX2ZpX2Rp
cl9hZGQodmZpLT5kaXIsCj4+Pj4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB4ZW52
aWZfZmlfbmFtZXNbZmldKTsKPj4+IEhvdyBkb2VzIHRoaXMgd29yaz8geGVudmlmX2ZpX25hbWVz
W10gaXMgYW4gZW1wdHkgYXJyYXkgYW5kIHRoaXMgaXMgdGhlCj4+PiBvbmx5IHJlZmVyZW5jZSB0
byBpdC4gV2hvIGlzIGFsbG9jYXRpbmcgdGhlIG1lbW9yeSBmb3IgdGhhdCBhcnJheT8KPj4gV2Vs
bCwgaXQgd29ya3MgaW4gdGhlIHdheSBvbmUgYWRkcyBhIHZhciB0byBlbnVtICh3aGljaCBpcyB1
c2VkIGFzIGEga2V5Cj4+IGxhdGVyKSBhbmQgYSBjb3JyZXNwb25kaW5nIHN0cmluZyBpbnRvIHRo
ZSBhcnJheSAod2hpY2ggaXMgdXNlZCBhcyBhCj4+IG5hbWUgZm9yIHRoZSBmYXVsdCBkaXJlY3Rv
cnkgaW4gc3lzZnMpLgo+IFRoZW4geW91IHNob3VsZCBzaXplIHRoZSBhcnJheSB2aWEgWEVOVklG
X0ZJX01BWC4KCk1ha2VzIHNlbnNlLgpUaGFua3MhCgpBbWF6b24gRGV2ZWxvcG1lbnQgQ2VudGVy
IEdlcm1hbnkgR21iSApCZXJsaW4gLSBEcmVzZGVuIC0gQWFjaGVuCm1haW4gb2ZmaWNlOiBLcmF1
c2Vuc3RyLiAzOCwgMTAxMTcgQmVybGluCkdlc2NoYWVmdHNmdWVocmVyOiBEci4gUmFsZiBIZXJi
cmljaCwgQ2hyaXN0aWFuIFNjaGxhZWdlcgpVc3QtSUQ6IERFMjg5MjM3ODc5CkVpbmdldHJhZ2Vu
IGFtIEFtdHNnZXJpY2h0IENoYXJsb3R0ZW5idXJnIEhSQiAxNDkxNzMgQgo=

Re: [PATCH 2/3] xen netback: add fault injection facility

[staskins]

On 04/20/18 15:00, Juergen Gross wrote:
> On 20/04/18 14:52, staskins@amazon.com wrote:
>> On 04/20/18 13:25, Juergen Gross wrote:
>>> On 20/04/18 12:47, Stanislav Kinsburskii wrote:
>>>> +    for (fi = 0; fi < XENVIF_FI_MAX; fi++) {
>>>> +        vfi->faults[fi] = xen_fi_dir_add(vfi->dir,
>>>> +                xenvif_fi_names[fi]);
>>> How does this work? xenvif_fi_names[] is an empty array and this is the
>>> only reference to it. Who is allocating the memory for that array?
>> Well, it works in the way one adds a var to enum (which is used as a key
>> later) and a corresponding string into the array (which is used as a
>> name for the fault directory in sysfs).
> Then you should size the array via XENVIF_FI_MAX.

Makes sense.
Thanks!

Amazon Development Center Germany GmbH
Berlin - Dresden - Aachen
main office: Krausenstr. 38, 10117 Berlin
Geschaeftsfuehrer: Dr. Ralf Herbrich, Christian Schlaeger
Ust-ID: DE289237879
Eingetragen am Amtsgericht Charlottenburg HRB 149173 B

Re: [PATCH 2/3] xen netback: add fault injection facility

[staskins]

On 04/20/18 15:00, Juergen Gross wrote:
> On 20/04/18 14:52, staskins@amazon.com wrote:
>> On 04/20/18 13:25, Juergen Gross wrote:
>>> On 20/04/18 12:47, Stanislav Kinsburskii wrote:
>>>> +    for (fi = 0; fi < XENVIF_FI_MAX; fi++) {
>>>> +        vfi->faults[fi] = xen_fi_dir_add(vfi->dir,
>>>> +                xenvif_fi_names[fi]);
>>> How does this work? xenvif_fi_names[] is an empty array and this is the
>>> only reference to it. Who is allocating the memory for that array?
>> Well, it works in the way one adds a var to enum (which is used as a key
>> later) and a corresponding string into the array (which is used as a
>> name for the fault directory in sysfs).
> Then you should size the array via XENVIF_FI_MAX.

Makes sense.
Thanks!

Amazon Development Center Germany GmbH
Berlin - Dresden - Aachen
main office: Krausenstr. 38, 10117 Berlin
Geschaeftsfuehrer: Dr. Ralf Herbrich, Christian Schlaeger
Ust-ID: DE289237879
Eingetragen am Amtsgericht Charlottenburg HRB 149173 B
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

Re: [PATCH 3/3] xen blkback: add fault injection facility

[kbuild test robot]

[-- Attachment #1: Type: text/plain, Size: 2017 bytes --]

Hi Stanislav,

Thank you for the patch! Yet something to improve:

[auto build test ERROR on net-next/master]
[also build test ERROR on v4.17-rc1 next-20180420]
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system]

url:    https://github.com/0day-ci/linux/commits/Stanislav-Kinsburskii/Introduce-Xen-fault-injection-facility/20180422-201946
config: x86_64-allmodconfig (attached as .config)
compiler: gcc-7 (Debian 7.3.0-16) 7.3.0
reproduce:
        # save the attached .config to linux build tree
        make ARCH=x86_64 

All errors (new ones prefixed by >>):

   drivers/block//xen-blkback/blkback_fi.c: In function 'xen_blkif_fi_init':
>> drivers/block//xen-blkback/blkback_fi.c:87:51: error: dereferencing pointer to incomplete type 'struct backend_info'
     bfi->dir = debugfs_create_dir(dev_name(&blkif->be->dev->dev),
                                                      ^~

vim +87 drivers/block//xen-blkback/blkback_fi.c

    77	
    78	int xen_blkif_fi_init(struct xen_blkif *blkif)
    79	{
    80		struct xen_blkif_fi *bfi;
    81		int fi, err = -ENOMEM;
    82	
    83		bfi = kmalloc(sizeof(*bfi), GFP_KERNEL);
    84		if (!bfi)
    85			return -ENOMEM;
    86	
  > 87		bfi->dir = debugfs_create_dir(dev_name(&blkif->be->dev->dev),
    88					      blkif_fi_dir);
    89		if (!bfi->dir)
    90			goto err_dir;
    91	
    92		for (fi = 0; fi < XENBLKIF_FI_MAX; fi++) {
    93			bfi->faults[fi] = xen_fi_dir_add(bfi->dir,
    94							 xen_blkif_fi_names[fi]);
    95			if (!bfi->faults[fi])
    96				goto err_fault;
    97		}
    98	
    99		blkif->fi_info = bfi;
   100		return 0;
   101	
   102	err_fault:
   103		for (; fi > 0; fi--)
   104			xen_fi_del(bfi->faults[fi]);
   105		debugfs_remove_recursive(bfi->dir);
   106	err_dir:
   107		kfree(bfi);
   108		return err;
   109	}
   110	

---
0-DAY kernel test infrastructure                Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all                   Intel Corporation

[-- Attachment #2: .config.gz --]
[-- Type: application/gzip, Size: 63017 bytes --]

Re: [PATCH 3/3] xen blkback: add fault injection facility

[kbuild test robot]

[-- Attachment #1: Type: text/plain, Size: 2017 bytes --]

Hi Stanislav,

Thank you for the patch! Yet something to improve:

[auto build test ERROR on net-next/master]
[also build test ERROR on v4.17-rc1 next-20180420]
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system]

url:    https://github.com/0day-ci/linux/commits/Stanislav-Kinsburskii/Introduce-Xen-fault-injection-facility/20180422-201946
config: x86_64-allmodconfig (attached as .config)
compiler: gcc-7 (Debian 7.3.0-16) 7.3.0
reproduce:
        # save the attached .config to linux build tree
        make ARCH=x86_64 

All errors (new ones prefixed by >>):

   drivers/block//xen-blkback/blkback_fi.c: In function 'xen_blkif_fi_init':
>> drivers/block//xen-blkback/blkback_fi.c:87:51: error: dereferencing pointer to incomplete type 'struct backend_info'
     bfi->dir = debugfs_create_dir(dev_name(&blkif->be->dev->dev),
                                                      ^~

vim +87 drivers/block//xen-blkback/blkback_fi.c

    77	
    78	int xen_blkif_fi_init(struct xen_blkif *blkif)
    79	{
    80		struct xen_blkif_fi *bfi;
    81		int fi, err = -ENOMEM;
    82	
    83		bfi = kmalloc(sizeof(*bfi), GFP_KERNEL);
    84		if (!bfi)
    85			return -ENOMEM;
    86	
  > 87		bfi->dir = debugfs_create_dir(dev_name(&blkif->be->dev->dev),
    88					      blkif_fi_dir);
    89		if (!bfi->dir)
    90			goto err_dir;
    91	
    92		for (fi = 0; fi < XENBLKIF_FI_MAX; fi++) {
    93			bfi->faults[fi] = xen_fi_dir_add(bfi->dir,
    94							 xen_blkif_fi_names[fi]);
    95			if (!bfi->faults[fi])
    96				goto err_fault;
    97		}
    98	
    99		blkif->fi_info = bfi;
   100		return 0;
   101	
   102	err_fault:
   103		for (; fi > 0; fi--)
   104			xen_fi_del(bfi->faults[fi]);
   105		debugfs_remove_recursive(bfi->dir);
   106	err_dir:
   107		kfree(bfi);
   108		return err;
   109	}
   110	

---
0-DAY kernel test infrastructure                Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all                   Intel Corporation

[-- Attachment #2: .config.gz --]
[-- Type: application/gzip, Size: 63017 bytes --]

[-- Attachment #3: Type: text/plain, Size: 157 bytes --]

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel

Re: [PATCH 2/3] xen netback: add fault injection facility

[Wei Liu]

On Fri, Apr 20, 2018 at 10:47:31AM +0000, Stanislav Kinsburskii wrote:
>  
>  #include <linux/kthread.h>
>  #include <linux/if_vlan.h>
> @@ -1649,6 +1650,7 @@ static int __init netback_init(void)
>  			PTR_ERR(xen_netback_dbg_root));
>  #endif /* CONFIG_DEBUG_FS */
>  
> +	(void) xen_netbk_fi_init();

If you care about the return value, please propagate it to
netback_init's caller. Otherwise you can just make the function return
void.

> +
> +int xenvif_fi_init(struct xenvif *vif)
> +{
> +	struct dentry *parent;
> +	struct xenvif_fi *vfi;
> +	int fi, err = -ENOMEM;
> +
> +	parent = vif_fi_dir;
> +	if (!parent)
> +		return -ENOMEM;
> +
> +	vfi = kmalloc(sizeof(*vfi), GFP_KERNEL);
> +	if (!vfi)
> +		return -ENOMEM;
> +
> +	vfi->dir = debugfs_create_dir(vif->dev->name, parent);
> +	if (!vfi->dir)
> +		goto err_dir;
> +
> +	for (fi = 0; fi < XENVIF_FI_MAX; fi++) {
> +		vfi->faults[fi] = xen_fi_dir_add(vfi->dir,
> +				xenvif_fi_names[fi]);
> +		if (!vfi->faults[fi])
> +			goto err_fault;
> +	}
> +
> +	vif->fi_info = vfi;
> +	return 0;
> +
> +err_fault:
> +	for (; fi > 0; fi--)

fi >= 0

Wei.

Re: [PATCH 2/3] xen netback: add fault injection facility

[Wei Liu]

On Fri, Apr 20, 2018 at 10:47:31AM +0000, Stanislav Kinsburskii wrote:
>  
>  #include <linux/kthread.h>
>  #include <linux/if_vlan.h>
> @@ -1649,6 +1650,7 @@ static int __init netback_init(void)
>  			PTR_ERR(xen_netback_dbg_root));
>  #endif /* CONFIG_DEBUG_FS */
>  
> +	(void) xen_netbk_fi_init();

If you care about the return value, please propagate it to
netback_init's caller. Otherwise you can just make the function return
void.

> +
> +int xenvif_fi_init(struct xenvif *vif)
> +{
> +	struct dentry *parent;
> +	struct xenvif_fi *vfi;
> +	int fi, err = -ENOMEM;
> +
> +	parent = vif_fi_dir;
> +	if (!parent)
> +		return -ENOMEM;
> +
> +	vfi = kmalloc(sizeof(*vfi), GFP_KERNEL);
> +	if (!vfi)
> +		return -ENOMEM;
> +
> +	vfi->dir = debugfs_create_dir(vif->dev->name, parent);
> +	if (!vfi->dir)
> +		goto err_dir;
> +
> +	for (fi = 0; fi < XENVIF_FI_MAX; fi++) {
> +		vfi->faults[fi] = xen_fi_dir_add(vfi->dir,
> +				xenvif_fi_names[fi]);
> +		if (!vfi->faults[fi])
> +			goto err_fault;
> +	}
> +
> +	vif->fi_info = vfi;
> +	return 0;
> +
> +err_fault:
> +	for (; fi > 0; fi--)

fi >= 0

Wei.

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel