Refactor kernel code to satisfy Linux kernel code style

13 files changed, 1111 insertions, 1441 deletions

diff --git a/src/kernel/CMakeLists.txt b/src/kernel/CMakeLists.txt
index 1e51797..babcaf0 100644
--- a/src/kernel/CMakeLists.txt
+++ b/src/kernel/CMakeLists.txt
@@ -26,7 +26,14 @@ if(CMAKE_BUILD_TYPE MATCHES "Debug")
 endif(CMAKE_BUILD_TYPE MATCHES "Debug")
 
 # define list of options to ignore with the checkpatch.pl linter
-set(CHECKPATCH_IGNORE_WARNINGS "LINUX_VERSION_CODE")
+set(CHECKPATCH_IGNORE_WARNINGS "LINUX_VERSION_CODE"
+                               "CONSTANT_COMPARISON"
+                               "PREFER_PR_LEVEL"
+                               "TRAILING_SEMICOLON"
+                               "CONSIDER_KSTRTO"
+                               "UNNECESSARY_ELSE"
+                               "SPLIT_STRING"
+                               "STATIC_CONST_CHAR_ARRAY")
 
 # xloop main Linux kernel module
 set(KERNEL_MODULE_XLOOP_SOURCE_FILES ${CMAKE_CURRENT_SOURCE_DIR}/xloop_file_fmt.c
diff --git a/src/kernel/uapi_xloop.h b/src/kernel/uapi_xloop.h
index 1bf13c6..0d6849e 100644
--- a/src/kernel/uapi_xloop.h
+++ b/src/kernel/uapi_xloop.h
@@ -10,19 +10,17 @@
 #ifndef _UAPI_LINUX_XLOOP_H
 #define _UAPI_LINUX_XLOOP_H
 
-
-#define XLO_NAME_SIZE     64
-#define XLO_KEY_SIZE      32
-
+#define XLO_NAME_SIZE 64
+#define XLO_KEY_SIZE  32
 
 /*
  * xloop flags
  */
 enum {
-	XLO_FLAGS_READ_ONLY	=  1,
-	XLO_FLAGS_AUTOCLEAR	=  4,
-	XLO_FLAGS_PARTSCAN	=  8,
-	XLO_FLAGS_DIRECT_IO	= 16,
+	XLO_FLAGS_READ_ONLY =  1,
+	XLO_FLAGS_AUTOCLEAR =  4,
+	XLO_FLAGS_PARTSCAN  =  8,
+	XLO_FLAGS_DIRECT_IO = 16,
 };
 
 /* XLO_FLAGS that can be set using XLOOP_SET_STATUS(64) */
@@ -32,11 +30,11 @@ enum {
 #define XLOOP_SET_STATUS_CLEARABLE_FLAGS (XLO_FLAGS_AUTOCLEAR)
 
 /* XLO_FLAGS that can be set using XLOOP_CONFIGURE */
-#define XLOOP_CONFIGURE_SETTABLE_FLAGS (XLO_FLAGS_READ_ONLY | XLO_FLAGS_AUTOCLEAR \
-				       | XLO_FLAGS_PARTSCAN | XLO_FLAGS_DIRECT_IO)
+#define XLOOP_CONFIGURE_SETTABLE_FLAGS                                                                                 \
+	(XLO_FLAGS_READ_ONLY | XLO_FLAGS_AUTOCLEAR | XLO_FLAGS_PARTSCAN | XLO_FLAGS_DIRECT_IO)
 
-#include <asm/posix_types.h>  /* for __kernel_old_dev_t */
-#include <linux/types.h>	  /* for __u64 */
+#include <asm/posix_types.h> /* for __kernel_old_dev_t */
+#include <linux/types.h>     /* for __u64 */
 
 /* Backwards compatibility version */
 struct xloop_info {
@@ -56,20 +54,20 @@ struct xloop_info {
 };
 
 struct xloop_info64 {
-	__u64              xlo_device;                     /* ioctl r/o */
-	__u64              xlo_inode;                      /* ioctl r/o */
-	__u64              xlo_rdevice;                    /* ioctl r/o */
-	__u64              xlo_offset;
-	__u64              xlo_sizelimit;  /* bytes, 0 == max available */
-	__u32              xlo_number;                     /* ioctl r/o */
-	__u32              xlo_encrypt_type;
-	__u32              xlo_encrypt_key_size;           /* ioctl w/o */
-	__u32              xlo_flags;
-	__u8               xlo_file_name[XLO_NAME_SIZE];
-	__u8               xlo_crypt_name[XLO_NAME_SIZE];
-	__u8               xlo_encrypt_key[XLO_KEY_SIZE];  /* ioctl w/o */
-	__u64              xlo_init[2];
-	__u32              xlo_file_fmt_type;
+	__u64 xlo_device;                    /* ioctl r/o */
+	__u64 xlo_inode;                     /* ioctl r/o */
+	__u64 xlo_rdevice;                   /* ioctl r/o */
+	__u64 xlo_offset;
+	__u64 xlo_sizelimit;                 /* bytes, 0 == max available */
+	__u32 xlo_number;                    /* ioctl r/o */
+	__u32 xlo_encrypt_type;
+	__u32 xlo_encrypt_key_size;          /* ioctl w/o */
+	__u32 xlo_flags;
+	__u8  xlo_file_name[XLO_NAME_SIZE];
+	__u8  xlo_crypt_name[XLO_NAME_SIZE];
+	__u8  xlo_encrypt_key[XLO_KEY_SIZE]; /* ioctl w/o */
+	__u64 xlo_init[2];
+	__u32 xlo_file_fmt_type;
 };
 
 /**
@@ -84,24 +82,24 @@ struct xloop_info64 {
 struct xloop_config {
 	__u32               fd;
 	__u32               block_size;
-	struct xloop_info64	info;
+	struct xloop_info64 info;
 	__u64               __reserved[8];
 };
 
 /*
  * xloop filter types
  */
-#define XLO_CRYPT_NONE        0
-#define XLO_CRYPT_XOR         1
-#define XLO_CRYPT_DES         2
-#define XLO_CRYPT_FISH2       3  /* Twofish encryption */
-#define XLO_CRYPT_BLOW        4
-#define XLO_CRYPT_CAST128     5
-#define XLO_CRYPT_IDEA        6
-#define XLO_CRYPT_DUMMY       9
-#define XLO_CRYPT_SKIPJACK   10
-#define XLO_CRYPT_CRYPTOAPI  18
-#define MAX_XLO_CRYPT        20
+#define XLO_CRYPT_NONE       0
+#define XLO_CRYPT_XOR        1
+#define XLO_CRYPT_DES        2
+#define XLO_CRYPT_FISH2      3 /* Twofish encryption */
+#define XLO_CRYPT_BLOW       4
+#define XLO_CRYPT_CAST128    5
+#define XLO_CRYPT_IDEA       6
+#define XLO_CRYPT_DUMMY      9
+#define XLO_CRYPT_SKIPJACK  10
+#define XLO_CRYPT_CRYPTOAPI 18
+#define MAX_XLO_CRYPT       20
 
 /*
  * IOCTL commands --- we will commandeer 0x4C ('L')
@@ -119,7 +117,8 @@ struct xloop_config {
 #define XLOOP_CONFIGURE      0x4C0A
 
 /* /dev/xloop-control interface */
-#define XLOOP_CTL_ADD        0x4C80
-#define XLOOP_CTL_REMOVE     0x4C81
-#define XLOOP_CTL_GET_FREE   0x4C82
+#define XLOOP_CTL_ADD      0x4C80
+#define XLOOP_CTL_REMOVE   0x4C81
+#define XLOOP_CTL_GET_FREE 0x4C82
+
 #endif /* _UAPI_LINUX_XLOOP_H */
diff --git a/src/kernel/xloop_file_fmt.c b/src/kernel/xloop_file_fmt.c
index 6c4902f..5a70ad5 100644
--- a/src/kernel/xloop_file_fmt.c
+++ b/src/kernel/xloop_file_fmt.c
@@ -1,4 +1,4 @@
-/* SPDX-License-Identifier: GPL-2.0 */
+// SPDX-License-Identifier: GPL-2.0
 /*
  * xloop_file_fmt.c
  *
@@ -16,9 +16,7 @@
 #include "xloop_main.h"
 
 /* storage for all registered file format drivers */
-static struct xloop_file_fmt_driver *xloop_file_fmt_drivers[MAX_XLO_FILE_FMT] = {
-	NULL
-};
+static struct xloop_file_fmt_driver *xloop_file_fmt_drivers[MAX_XLO_FILE_FMT] = { NULL };
 
 int xloop_file_fmt_register_driver(struct xloop_file_fmt_driver *drv)
 {
@@ -85,12 +83,12 @@ EXPORT_SYMBOL(xloop_file_fmt_get_xlo);
 struct device *xloop_file_fmt_to_dev(struct xloop_file_fmt *xlo_fmt)
 {
 	struct xloop_device *xlo = xloop_file_fmt_get_xlo(xlo_fmt);
+
 	return xloop_device_to_dev(xlo);
 }
 EXPORT_SYMBOL(xloop_file_fmt_to_dev);
 
-int xloop_file_fmt_init(struct xloop_file_fmt *xlo_fmt,
-		       u32 file_fmt_type)
+int xloop_file_fmt_init(struct xloop_file_fmt *xlo_fmt, u32 file_fmt_type)
 {
 	struct xloop_file_fmt_ops *ops;
 	struct module *drv;
@@ -102,25 +100,22 @@ int xloop_file_fmt_init(struct xloop_file_fmt *xlo_fmt,
 	xlo_fmt->file_fmt_type = file_fmt_type;
 
 	if (xlo_fmt->file_fmt_state != file_fmt_uninitialized) {
-		dev_warn(xloop_file_fmt_to_dev(xlo_fmt), "file format is "
-			"initialized already\n");
+		dev_warn(xloop_file_fmt_to_dev(xlo_fmt), "file format is initialized already\n");
 		return -EINVAL;
 	}
 
 	/* check if new file format driver is registered */
 	if (xloop_file_fmt_drivers[xlo_fmt->file_fmt_type] == NULL) {
-		dev_err(xloop_file_fmt_to_dev(xlo_fmt), "file format driver is "
-			"not available\n");
+		dev_err(xloop_file_fmt_to_dev(xlo_fmt), "file format driver is not available\n");
 		return -ENODEV;
 	}
 
 	dev_info(xloop_file_fmt_to_dev(xlo_fmt), "use file format driver %s\n",
-		xloop_file_fmt_drivers[xlo_fmt->file_fmt_type]->name);
+		 xloop_file_fmt_drivers[xlo_fmt->file_fmt_type]->name);
 
 	drv = xloop_file_fmt_drivers[xlo_fmt->file_fmt_type]->owner;
 	if (!try_module_get(drv)) {
-		dev_err(xloop_file_fmt_to_dev(xlo_fmt), "file format driver %s can "
-			"not be accessed\n",
+		dev_err(xloop_file_fmt_to_dev(xlo_fmt), "file format driver %s can not be accessed\n",
 			xloop_file_fmt_drivers[xlo_fmt->file_fmt_type]->name);
 		return -ENODEV;
 	}
@@ -132,8 +127,10 @@ int xloop_file_fmt_init(struct xloop_file_fmt *xlo_fmt,
 			goto free_drv;
 	}
 
-	/* after increasing the refcount of file format driver module and
-	 * the successful initialization, the file format is initialized */
+	/*
+	 * after increasing the refcount of file format driver module and
+	 * the successful initialization, the file format is initialized
+	 */
 	xlo_fmt->file_fmt_state = file_fmt_initialized;
 
 	return ret;
@@ -150,8 +147,8 @@ void xloop_file_fmt_exit(struct xloop_file_fmt *xlo_fmt)
 	struct module *drv;
 
 	if (xlo_fmt->file_fmt_state != file_fmt_initialized) {
-		dev_warn(xloop_file_fmt_to_dev(xlo_fmt), "file format is "
-		"uninitialized already\n");
+		dev_warn(xloop_file_fmt_to_dev(xlo_fmt),
+					"file format is uninitialized already\n");
 		return;
 	}
 
@@ -162,19 +159,20 @@ void xloop_file_fmt_exit(struct xloop_file_fmt *xlo_fmt)
 	drv = xloop_file_fmt_drivers[xlo_fmt->file_fmt_type]->owner;
 	module_put(drv);
 
-	/* after decreasing the refcount of file format driver module,
-	 * the file format is uninitialized */
+	/*
+	 * after decreasing the refcount of file format driver module,
+	 * the file format is uninitialized
+	 */
 	xlo_fmt->file_fmt_state = file_fmt_uninitialized;
 }
 
-int xloop_file_fmt_read(struct xloop_file_fmt *xlo_fmt,
-		       struct request *rq)
+int xloop_file_fmt_read(struct xloop_file_fmt *xlo_fmt, struct request *rq)
 {
 	struct xloop_file_fmt_ops *ops;
 
 	if (unlikely(xlo_fmt->file_fmt_state != file_fmt_initialized)) {
-		dev_err_ratelimited(xloop_file_fmt_to_dev(xlo_fmt), "file format "
-			"is not initialized, can not read\n");
+		dev_err_ratelimited(xloop_file_fmt_to_dev(xlo_fmt),
+					"file format is not initialized, can not read\n");
 		return -EINVAL;
 	}
 
@@ -185,14 +183,13 @@ int xloop_file_fmt_read(struct xloop_file_fmt *xlo_fmt,
 		return -EIO;
 }
 
-int xloop_file_fmt_read_aio(struct xloop_file_fmt *xlo_fmt,
-			   struct request *rq)
+int xloop_file_fmt_read_aio(struct xloop_file_fmt *xlo_fmt, struct request *rq)
 {
 	struct xloop_file_fmt_ops *ops;
 
 	if (unlikely(xlo_fmt->file_fmt_state != file_fmt_initialized)) {
-		dev_err_ratelimited(xloop_file_fmt_to_dev(xlo_fmt), "file format "
-			"is not initialized, can not read aio\n");
+		dev_err_ratelimited(xloop_file_fmt_to_dev(xlo_fmt),
+				    "file format is not initialized, can not read aio\n");
 		return -EINVAL;
 	}
 
@@ -203,14 +200,13 @@ int xloop_file_fmt_read_aio(struct xloop_file_fmt *xlo_fmt,
 		return -EIO;
 }
 
-int xloop_file_fmt_write(struct xloop_file_fmt *xlo_fmt,
-			struct request *rq)
+int xloop_file_fmt_write(struct xloop_file_fmt *xlo_fmt, struct request *rq)
 {
 	struct xloop_file_fmt_ops *ops;
 
 	if (unlikely(xlo_fmt->file_fmt_state != file_fmt_initialized)) {
-		dev_err_ratelimited(xloop_file_fmt_to_dev(xlo_fmt), "file format "
-			"is not initialized, can not write\n");
+		dev_err_ratelimited(xloop_file_fmt_to_dev(xlo_fmt),
+					"file format is not initialized, can not write\n");
 		return -EINVAL;
 	}
 
@@ -221,14 +217,13 @@ int xloop_file_fmt_write(struct xloop_file_fmt *xlo_fmt,
 		return -EIO;
 }
 
-int xloop_file_fmt_write_aio(struct xloop_file_fmt *xlo_fmt,
-			    struct request *rq)
+int xloop_file_fmt_write_aio(struct xloop_file_fmt *xlo_fmt, struct request *rq)
 {
 	struct xloop_file_fmt_ops *ops;
 
 	if (unlikely(xlo_fmt->file_fmt_state != file_fmt_initialized)) {
-		dev_err_ratelimited(xloop_file_fmt_to_dev(xlo_fmt), "file format "
-			"is not initialized, can not write aio\n");
+		dev_err_ratelimited(xloop_file_fmt_to_dev(xlo_fmt),
+				    "file format is not initialized, can not write aio\n");
 		return -EINVAL;
 	}
 
@@ -239,14 +234,13 @@ int xloop_file_fmt_write_aio(struct xloop_file_fmt *xlo_fmt,
 		return -EIO;
 }
 
-int xloop_file_fmt_write_zeros(struct xloop_file_fmt *xlo_fmt,
-			  struct request *rq)
+int xloop_file_fmt_write_zeros(struct xloop_file_fmt *xlo_fmt, struct request *rq)
 {
 	struct xloop_file_fmt_ops *ops;
 
 	if (unlikely(xlo_fmt->file_fmt_state != file_fmt_initialized)) {
-		dev_err_ratelimited(xloop_file_fmt_to_dev(xlo_fmt), "file format "
-			"is not initialized, can not write zeros\n");
+		dev_err_ratelimited(xloop_file_fmt_to_dev(xlo_fmt),
+				    "file format is not initialized, can not write zeros\n");
 		return -EINVAL;
 	}
 
@@ -257,14 +251,13 @@ int xloop_file_fmt_write_zeros(struct xloop_file_fmt *xlo_fmt,
 		return -EIO;
 }
 
-int xloop_file_fmt_discard(struct xloop_file_fmt *xlo_fmt,
-			  struct request *rq)
+int xloop_file_fmt_discard(struct xloop_file_fmt *xlo_fmt, struct request *rq)
 {
 	struct xloop_file_fmt_ops *ops;
 
 	if (unlikely(xlo_fmt->file_fmt_state != file_fmt_initialized)) {
-		dev_err_ratelimited(xloop_file_fmt_to_dev(xlo_fmt), "file format "
-			"is not initialized, can not discard\n");
+		dev_err_ratelimited(xloop_file_fmt_to_dev(xlo_fmt),
+				    "file format is not initialized, can not discard\n");
 		return -EINVAL;
 	}
 
@@ -280,8 +273,8 @@ int xloop_file_fmt_flush(struct xloop_file_fmt *xlo_fmt)
 	struct xloop_file_fmt_ops *ops;
 
 	if (unlikely(xlo_fmt->file_fmt_state != file_fmt_initialized)) {
-		dev_err_ratelimited(xloop_file_fmt_to_dev(xlo_fmt), "file format "
-			"is not initialized, can not flush\n");
+		dev_err_ratelimited(xloop_file_fmt_to_dev(xlo_fmt),
+					"file format is not initialized, can not flush\n");
 		return -EINVAL;
 	}
 
@@ -292,14 +285,13 @@ int xloop_file_fmt_flush(struct xloop_file_fmt *xlo_fmt)
 	return 0;
 }
 
-loff_t xloop_file_fmt_sector_size(struct xloop_file_fmt *xlo_fmt,
-			struct file *file, loff_t offset, loff_t sizelimit)
+loff_t xloop_file_fmt_sector_size(struct xloop_file_fmt *xlo_fmt, struct file *file, loff_t offset, loff_t sizelimit)
 {
 	struct xloop_file_fmt_ops *ops;
 
 	if (unlikely(xlo_fmt->file_fmt_state != file_fmt_initialized)) {
-		dev_err_ratelimited(xloop_file_fmt_to_dev(xlo_fmt), "file format "
-			"is not initialized, can not read sector size\n");
+		dev_err_ratelimited(xloop_file_fmt_to_dev(xlo_fmt),
+				    "file format is not initialized, can not read sector size\n");
 		return 0;
 	}
 
@@ -310,21 +302,18 @@ loff_t xloop_file_fmt_sector_size(struct xloop_file_fmt *xlo_fmt,
 		return 0;
 }
 
-int xloop_file_fmt_change(struct xloop_file_fmt *xlo_fmt,
-			 u32 file_fmt_type_new)
+int xloop_file_fmt_change(struct xloop_file_fmt *xlo_fmt, u32 file_fmt_type_new)
 {
 	if (file_fmt_type_new > MAX_XLO_FILE_FMT)
 		return -EINVAL;
 
 	dev_info(xloop_file_fmt_to_dev(xlo_fmt), "change file format\n");
 
-	/* Unload the old file format driver if the file format is
-	 * initialized */
+	/* unload the old file format driver if the file format is initialized */
 	if (xlo_fmt->file_fmt_state == file_fmt_initialized)
 		xloop_file_fmt_exit(xlo_fmt);
 
-	/* Load the new file format driver because the file format is
-	 * uninitialized now */
+	/* Load the new file format driver because the file format is uninitialized now */
 	return xloop_file_fmt_init(xlo_fmt, file_fmt_type_new);
 }
 
@@ -346,8 +335,7 @@ ssize_t xloop_file_fmt_print_type(u32 file_fmt_type, char *file_fmt_name)
 		len = sprintf(file_fmt_name, "%s", "VMDK");
 		break;
 	default:
-		len = sprintf(file_fmt_name, "%s", "ERROR: Unsupported xloop "
-			"file format!");
+		len = sprintf(file_fmt_name, "%s", "ERROR: Unsupported xloop file format!");
 		break;
 	}
 
diff --git a/src/kernel/xloop_file_fmt.h b/src/kernel/xloop_file_fmt.h
index 20589c1..4c26495 100644
--- a/src/kernel/xloop_file_fmt.h
+++ b/src/kernel/xloop_file_fmt.h
@@ -14,11 +14,11 @@
 
 struct xloop_file_fmt;
 
-#define XLO_FILE_FMT_RAW         0
-#define XLO_FILE_FMT_QCOW        1
-#define XLO_FILE_FMT_VDI         2
-#define XLO_FILE_FMT_VMDK        3
-#define MAX_XLO_FILE_FMT         (XLO_FILE_FMT_VMDK + 1)
+#define XLO_FILE_FMT_RAW 0
+#define XLO_FILE_FMT_QCOW 1
+#define XLO_FILE_FMT_VDI 2
+#define XLO_FILE_FMT_VMDK 3
+#define MAX_XLO_FILE_FMT (XLO_FILE_FMT_VMDK + 1)
 
 /**
  * struct xloop_file_fmt_ops - File format subsystem operations
@@ -29,59 +29,52 @@ struct xloop_file_fmt_ops {
 	/**
 	 * @init: Initialization callback function
 	 */
-	int (*init) (struct xloop_file_fmt *xlo_fmt);
+	int (*init)(struct xloop_file_fmt *xlo_fmt);
 
 	/**
 	 * @exit: Release callback function
 	 */
-	void (*exit) (struct xloop_file_fmt *xlo_fmt);
+	void (*exit)(struct xloop_file_fmt *xlo_fmt);
 
 	/**
 	 * @read: Read IO callback function
 	 */
-	int (*read) (struct xloop_file_fmt *xlo_fmt,
-			struct request *rq);
+	int (*read)(struct xloop_file_fmt *xlo_fmt, struct request *rq);
 
 	/**
 	 * @write: Write IO callback function
 	 */
-	int (*write) (struct xloop_file_fmt *xlo_fmt,
-			struct request *rq);
+	int (*write)(struct xloop_file_fmt *xlo_fmt, struct request *rq);
 
 	/**
 	 * @read_aio: Asynchronous read IO callback function
 	 */
-	int (*read_aio) (struct xloop_file_fmt *xlo_fmt,
-			struct request *rq);
+	int (*read_aio)(struct xloop_file_fmt *xlo_fmt, struct request *rq);
 
 	/**
 	 * @write_aio: Asynchronous write IO callback function
 	 */
-	int (*write_aio) (struct xloop_file_fmt *xlo_fmt,
-			struct request *rq);
+	int (*write_aio)(struct xloop_file_fmt *xlo_fmt, struct request *rq);
 
 	/**
 	 * @zero: Zero (discard) IO callback function
 	 */
-	int (*write_zeros) (struct xloop_file_fmt *xlo_fmt,
-			struct request *rq);
+	int (*write_zeros)(struct xloop_file_fmt *xlo_fmt, struct request *rq);
 
 	/**
 	 * @discard: Discard IO callback function
 	 */
-	int (*discard) (struct xloop_file_fmt *xlo_fmt,
-			struct request *rq);
+	int (*discard)(struct xloop_file_fmt *xlo_fmt, struct request *rq);
 
 	/**
 	 * @flush: Flush callback function
 	 */
-	int (*flush) (struct xloop_file_fmt *xlo_fmt);
+	int (*flush)(struct xloop_file_fmt *xlo_fmt);
 
 	/**
 	 * @sector_size: Get sector size callback function
 	 */
-	loff_t (*sector_size) (struct xloop_file_fmt *xlo_fmt,
-				struct file *file, loff_t offset, loff_t sizelimit);
+	loff_t (*sector_size)(struct xloop_file_fmt *xlo_fmt, struct file *file, loff_t offset, loff_t sizelimit);
 };
 
 /**
@@ -141,10 +134,7 @@ struct xloop_file_fmt_driver {
  *    | initialized   -------> uninitialized -------> initialized |
  *    +-----------------------------------------------------------+
  */
-enum {
-	file_fmt_uninitialized = 0,
-	file_fmt_initialized
-};
+enum { file_fmt_uninitialized = 0, file_fmt_initialized };
 
 /**
  * struct xloop_file_fmt - xloop file format
@@ -173,7 +163,6 @@ struct xloop_file_fmt {
 	void *private_data;
 };
 
-
 /* subsystem functions for the driver implementation */
 
 /**
@@ -194,7 +183,6 @@ extern int xloop_file_fmt_register_driver(struct xloop_file_fmt_driver *drv);
  */
 extern void xloop_file_fmt_unregister_driver(struct xloop_file_fmt_driver *drv);
 
-
 /* subsystem functions for subsystem usage */
 
 /**
@@ -220,8 +208,7 @@ extern void xloop_file_fmt_free(struct xloop_file_fmt *xlo_fmt);
  *
  * The link to the xloop device @xlo is set in the xloop file format @xlo_fmt.
  */
-extern int xloop_file_fmt_set_xlo(struct xloop_file_fmt *xlo_fmt,
-				struct xloop_device *xlo);
+extern int xloop_file_fmt_set_xlo(struct xloop_file_fmt *xlo_fmt, struct xloop_device *xlo);
 
 /**
  * xloop_file_fmt_get_xlo - Get the xloop file format's xloop device
@@ -250,8 +237,7 @@ extern inline struct device *xloop_file_fmt_to_dev(struct xloop_file_fmt *xlo_fm
  * format driver for the specified file format is available an error is
  * returned.
  */
-extern int xloop_file_fmt_init(struct xloop_file_fmt *xlo_fmt,
-			      u32 file_fmt_type);
+extern int xloop_file_fmt_init(struct xloop_file_fmt *xlo_fmt, u32 file_fmt_type);
 
 /**
  * xloop_file_fmt_exit - Release a xloop file format
@@ -270,8 +256,7 @@ extern void xloop_file_fmt_exit(struct xloop_file_fmt *xlo_fmt);
  * @rq to the xloop file format subsystem. The subsystem calls the registered
  * callback function of the suitable xloop file format driver.
  */
-extern int xloop_file_fmt_read(struct xloop_file_fmt *xlo_fmt,
-			      struct request *rq);
+extern int xloop_file_fmt_read(struct xloop_file_fmt *xlo_fmt, struct request *rq);
 
 /**
  * xloop_file_fmt_read_aio - Read IO from a xloop file format asynchronously
@@ -283,8 +268,7 @@ extern int xloop_file_fmt_read(struct xloop_file_fmt *xlo_fmt,
  * calls the registered callback function of the suitable xloop file format
  * driver.
  */
-extern int xloop_file_fmt_read_aio(struct xloop_file_fmt *xlo_fmt,
-				  struct request *rq);
+extern int xloop_file_fmt_read_aio(struct xloop_file_fmt *xlo_fmt, struct request *rq);
 
 /**
  * xloop_file_fmt_write - Write IO to a xloop file format
@@ -295,8 +279,7 @@ extern int xloop_file_fmt_read_aio(struct xloop_file_fmt *xlo_fmt,
  * @rq to the xloop file format subsystem. The subsystem calls the registered
  * callback function of the suitable xloop file format driver.
  */
-extern int xloop_file_fmt_write(struct xloop_file_fmt *xlo_fmt,
-			       struct request *rq);
+extern int xloop_file_fmt_write(struct xloop_file_fmt *xlo_fmt, struct request *rq);
 
 /**
  * xloop_file_fmt_write_aio - Write IO to a xloop file format asynchronously
@@ -308,8 +291,7 @@ extern int xloop_file_fmt_write(struct xloop_file_fmt *xlo_fmt,
  * calls the registered callback function of the suitable xloop file format
  * driver.
  */
-extern int xloop_file_fmt_write_aio(struct xloop_file_fmt *xlo_fmt,
-				   struct request *rq);
+extern int xloop_file_fmt_write_aio(struct xloop_file_fmt *xlo_fmt, struct request *rq);
 
 /**
  * xloop_file_fmt_write_zeros - Zero (discard) IO on a xloop file format
@@ -320,8 +302,7 @@ extern int xloop_file_fmt_write_aio(struct xloop_file_fmt *xlo_fmt,
  * zeros request @rq to the xloop file format subsystem. The subsystem calls the
  * registered callback function of the suitable xloop file format driver.
  */
-extern int xloop_file_fmt_write_zeros(struct xloop_file_fmt *xlo_fmt,
-				 struct request *rq);
+extern int xloop_file_fmt_write_zeros(struct xloop_file_fmt *xlo_fmt, struct request *rq);
 
 /**
  * xloop_file_fmt_discard - Discard IO on a xloop file format
@@ -332,8 +313,7 @@ extern int xloop_file_fmt_write_zeros(struct xloop_file_fmt *xlo_fmt,
  * request @rq to the xloop file format subsystem. The subsystem calls the
  * registered callback function of the suitable xloop file format driver.
  */
-extern int xloop_file_fmt_discard(struct xloop_file_fmt *xlo_fmt,
-				 struct request *rq);
+extern int xloop_file_fmt_discard(struct xloop_file_fmt *xlo_fmt, struct request *rq);
 
 /**
  * xloop_file_fmt_flush - Flush a xloop file format
@@ -355,8 +335,8 @@ extern int xloop_file_fmt_flush(struct xloop_file_fmt *xlo_fmt);
  * If the xloop file format implements a sparse disk image format, then this
  * function returns the virtual sector size.
  */
-extern loff_t xloop_file_fmt_sector_size(struct xloop_file_fmt *xlo_fmt,
-				struct file *file, loff_t offset, loff_t sizelimit);
+extern loff_t xloop_file_fmt_sector_size(struct xloop_file_fmt *xlo_fmt, struct file *file, loff_t offset,
+					 loff_t sizelimit);
 
 /**
  * xloop_file_fmt_change - Change the xloop file format's type
@@ -368,9 +348,7 @@ extern loff_t xloop_file_fmt_sector_size(struct xloop_file_fmt *xlo_fmt,
  * of its resources before the xloop file format @xlo_fmt is initialized and set
  * up with the new file format @file_fmt_type_new.
  */
-extern int xloop_file_fmt_change(struct xloop_file_fmt *xlo_fmt,
-				u32 file_fmt_type_new);
-
+extern int xloop_file_fmt_change(struct xloop_file_fmt *xlo_fmt, u32 file_fmt_type_new);
 
 /* helper functions of the subsystem */
 
@@ -382,7 +360,6 @@ extern int xloop_file_fmt_change(struct xloop_file_fmt *xlo_fmt,
  * Converts the specified numeric @file_fmt_type value into a human readable
  * string stating the file format as string in @file_fmt_name.
  */
-extern ssize_t xloop_file_fmt_print_type(u32 file_fmt_type,
-					char *file_fmt_name);
+extern ssize_t xloop_file_fmt_print_type(u32 file_fmt_type, char *file_fmt_name);
 
 #endif
diff --git a/src/kernel/xloop_file_fmt_qcow_cache.c b/src/kernel/xloop_file_fmt_qcow_cache.c
index 14f0b75..d9701b6 100644
--- a/src/kernel/xloop_file_fmt_qcow_cache.c
+++ b/src/kernel/xloop_file_fmt_qcow_cache.c
@@ -1,4 +1,4 @@
-/* SPDX-License-Identifier: GPL-2.0 */
+// SPDX-License-Identifier: GPL-2.0
 /*
  * xloop_file_fmt_qcow_cache.c
  *
@@ -26,20 +26,19 @@
 #include "xloop_file_fmt_qcow_main.h"
 #include "xloop_file_fmt_qcow_cache.h"
 
-static inline void *__xloop_file_fmt_qcow_cache_get_table_addr(
-	struct xloop_file_fmt_qcow_cache *c, int table)
+static inline void *__xloop_file_fmt_qcow_cache_get_table_addr(struct xloop_file_fmt_qcow_cache *c, int table)
 {
-	return (u8 *) c->table_array + (size_t) table * c->table_size;
+	return (u8 *)c->table_array + (size_t)table * c->table_size;
 }
 
-static inline int __xloop_file_fmt_qcow_cache_get_table_idx(
-	struct xloop_file_fmt_qcow_cache *c, void *table)
+static inline int __xloop_file_fmt_qcow_cache_get_table_idx(struct xloop_file_fmt_qcow_cache *c, void *table)
 {
-	ptrdiff_t table_offset = (u8 *) table - (u8 *) c->table_array;
+	ptrdiff_t table_offset = (u8 *)table - (u8 *)c->table_array;
 	int idx = div_s64(table_offset, c->table_size);
 
 #ifdef ASSERT
 	s32 rem_table_offset_mod_table_size;
+
 	div_s64_rem(table_offset, c->table_size, &rem_table_offset_mod_table_size);
 	ASSERT(idx >= 0 && idx < c->size && rem_table_offset_mod_table_size == 0);
 #endif
@@ -47,8 +46,8 @@ static inline int __xloop_file_fmt_qcow_cache_get_table_idx(
 	return idx;
 }
 
-static inline const char *__xloop_file_fmt_qcow_cache_get_name(
-	struct xloop_file_fmt *xlo_fmt, struct xloop_file_fmt_qcow_cache *c)
+static inline const char *__xloop_file_fmt_qcow_cache_get_name(struct xloop_file_fmt *xlo_fmt,
+							       struct xloop_file_fmt_qcow_cache *c)
 {
 	struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
 
@@ -62,8 +61,8 @@ static inline const char *__xloop_file_fmt_qcow_cache_get_name(
 	}
 }
 
-struct xloop_file_fmt_qcow_cache *xloop_file_fmt_qcow_cache_create(
-	struct xloop_file_fmt *xlo_fmt, int num_tables, unsigned table_size)
+struct xloop_file_fmt_qcow_cache *xloop_file_fmt_qcow_cache_create(struct xloop_file_fmt *xlo_fmt, int num_tables,
+								   unsigned int table_size)
 {
 #ifdef CONFIG_DEBUG_DRIVER
 	struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
@@ -76,14 +75,12 @@ struct xloop_file_fmt_qcow_cache *xloop_file_fmt_qcow_cache_create(
 	ASSERT(table_size <= qcow_data->cluster_size);
 
 	c = kzalloc(sizeof(*c), GFP_KERNEL);
-	if (!c) {
+	if (!c)
 		return NULL;
-	}
 
 	c->size = num_tables;
 	c->table_size = table_size;
-	c->entries = vzalloc(sizeof(struct xloop_file_fmt_qcow_cache_table) *
-		num_tables);
+	c->entries = vzalloc(sizeof(struct xloop_file_fmt_qcow_cache_table) * num_tables);
 	c->table_array = vzalloc(num_tables * c->table_size);
 
 	if (!c->entries || !c->table_array) {
@@ -102,30 +99,27 @@ void xloop_file_fmt_qcow_cache_destroy(struct xloop_file_fmt *xlo_fmt)
 	struct xloop_file_fmt_qcow_cache *c = qcow_data->l2_table_cache;
 	int i;
 
-	for (i = 0; i < c->size; i++) {
+	for (i = 0; i < c->size; i++)
 		ASSERT(c->entries[i].ref == 0);
-	}
 
 	vfree(c->table_array);
 	vfree(c->entries);
 	kfree(c);
 }
 
-static int __xloop_file_fmt_qcow_cache_entry_flush(
-	struct xloop_file_fmt *xlo_fmt, struct xloop_file_fmt_qcow_cache *c, int i)
+static int __xloop_file_fmt_qcow_cache_entry_flush(struct xloop_file_fmt *xlo_fmt, struct xloop_file_fmt_qcow_cache *c,
+						   int i)
 {
 	if (!c->entries[i].dirty || !c->entries[i].offset) {
 		return 0;
 	} else {
-		dev_err_ratelimited(xloop_file_fmt_to_dev(xlo_fmt), "flush dirty "
-			"cache tables is not supported yet\n");
-		return -ENOSYS;
+		dev_err_ratelimited(xloop_file_fmt_to_dev(xlo_fmt), "flush dirty cache tables is not supported yet\n");
+		return -EINVAL;
 	}
 }
 
-static int __xloop_file_fmt_qcow_cache_do_get(struct xloop_file_fmt *xlo_fmt,
-	struct xloop_file_fmt_qcow_cache *c, u64 offset, void **table,
-	bool read_from_disk)
+static int __xloop_file_fmt_qcow_cache_do_get(struct xloop_file_fmt *xlo_fmt, struct xloop_file_fmt_qcow_cache *c,
+					      u64 offset, void **table, bool read_from_disk)
 {
 	struct xloop_device *xlo = xloop_file_fmt_get_xlo(xlo_fmt);
 	int i;
@@ -140,9 +134,9 @@ static int __xloop_file_fmt_qcow_cache_do_get(struct xloop_file_fmt *xlo_fmt,
 	ASSERT(offset != 0);
 
 	if (!IS_ALIGNED(offset, c->table_size)) {
-		dev_err_ratelimited(xloop_file_fmt_to_dev(xlo_fmt), "cannot get entry "
-			"from %s cache: offset %llx is unaligned\n", 
-			__xloop_file_fmt_qcow_cache_get_name(xlo_fmt, c), offset);
+		dev_err_ratelimited(xloop_file_fmt_to_dev(xlo_fmt),
+				    "cannot get entry from %s cache: offset %llx is unaligned\n",
+				    __xloop_file_fmt_qcow_cache_get_name(xlo_fmt, c), offset);
 		return -EIO;
 	}
 
@@ -151,41 +145,37 @@ static int __xloop_file_fmt_qcow_cache_do_get(struct xloop_file_fmt *xlo_fmt,
 	div_u64_rem(offset_div_table_size, c->size, &lookup_index);
 	i = lookup_index;
 	do {
-		const struct xloop_file_fmt_qcow_cache_table *t =
-			&c->entries[i];
-		if (t->offset == offset) {
+		const struct xloop_file_fmt_qcow_cache_table *t = &c->entries[i];
+
+		if (t->offset == offset)
 			goto found;
-		}
+
 		if (t->ref == 0 && t->lru_counter < min_lru_counter) {
 			min_lru_counter = t->lru_counter;
 			min_lru_index = i;
 		}
-		if (++i == c->size) {
+		if (++i == c->size)
 			i = 0;
-		}
+
 	} while (i != lookup_index);
 
 	if (min_lru_index == -1) {
 		BUG();
-		panic("Oops: This can't happen in current synchronous code, "
-			"but leave the check here as a reminder for whoever "
-			"starts using AIO with the QCOW cache");
+		panic("Oops: This can't happen in current synchronous code while using AIO with the QCOW cache\n");
 	}
 
 	/* Cache miss: write a table back and replace it */
 	i = min_lru_index;
 
 	ret = __xloop_file_fmt_qcow_cache_entry_flush(xlo_fmt, c, i);
-	if (ret < 0) {
+	if (ret < 0)
 		return ret;
-	}
 
 	c->entries[i].offset = 0;
 	if (read_from_disk) {
 		read_offset = offset;
-		len = kernel_read(xlo->xlo_backing_file,
-			__xloop_file_fmt_qcow_cache_get_table_addr(c, i),
-			c->table_size, &read_offset);
+		len = kernel_read(xlo->xlo_backing_file, __xloop_file_fmt_qcow_cache_get_table_addr(c, i),
+				  c->table_size, &read_offset);
 		if (len < 0) {
 			len = ret;
 			return ret;
@@ -202,14 +192,12 @@ found:
 	return 0;
 }
 
-int xloop_file_fmt_qcow_cache_get(struct xloop_file_fmt *xlo_fmt, u64 offset,
-	void **table)
+int xloop_file_fmt_qcow_cache_get(struct xloop_file_fmt *xlo_fmt, u64 offset, void **table)
 {
 	struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
 	struct xloop_file_fmt_qcow_cache *c = qcow_data->l2_table_cache;
 
-	return __xloop_file_fmt_qcow_cache_do_get(xlo_fmt, c, offset, table,
-		true);
+	return __xloop_file_fmt_qcow_cache_do_get(xlo_fmt, c, offset, table, true);
 }
 
 void xloop_file_fmt_qcow_cache_put(struct xloop_file_fmt *xlo_fmt, void **table)
@@ -221,9 +209,8 @@ void xloop_file_fmt_qcow_cache_put(struct xloop_file_fmt *xlo_fmt, void **table)
 	c->entries[i].ref--;
 	*table = NULL;
 
-	if (c->entries[i].ref == 0) {
+	if (c->entries[i].ref == 0)
 		c->entries[i].lru_counter = ++c->lru_counter;
-	}
 
 	ASSERT(c->entries[i].ref >= 0);
 }
diff --git a/src/kernel/xloop_file_fmt_qcow_cache.h b/src/kernel/xloop_file_fmt_qcow_cache.h
index 527d4ae..213a8b4 100644
--- a/src/kernel/xloop_file_fmt_qcow_cache.h
+++ b/src/kernel/xloop_file_fmt_qcow_cache.h
@@ -34,18 +34,13 @@ struct xloop_file_fmt_qcow_cache {
 	u64 cache_clean_lru_counter;
 };
 
-extern struct xloop_file_fmt_qcow_cache *xloop_file_fmt_qcow_cache_create(
-	struct xloop_file_fmt *xlo_fmt,
-	int num_tables,
-	unsigned table_size);
+extern struct xloop_file_fmt_qcow_cache *xloop_file_fmt_qcow_cache_create(struct xloop_file_fmt *xlo_fmt,
+									  int num_tables, unsigned int table_size);
 
 extern void xloop_file_fmt_qcow_cache_destroy(struct xloop_file_fmt *xlo_fmt);
 
-extern int xloop_file_fmt_qcow_cache_get(struct xloop_file_fmt *xlo_fmt,
-					u64 offset,
-					void **table);
+extern int xloop_file_fmt_qcow_cache_get(struct xloop_file_fmt *xlo_fmt, u64 offset, void **table);
 
-extern void xloop_file_fmt_qcow_cache_put(struct xloop_file_fmt *xlo_fmt,
-					 void **table);
+extern void xloop_file_fmt_qcow_cache_put(struct xloop_file_fmt *xlo_fmt, void **table);
 
 #endif
diff --git a/src/kernel/xloop_file_fmt_qcow_cluster.c b/src/kernel/xloop_file_fmt_qcow_cluster.c
index 8394c76..6f11923 100644
--- a/src/kernel/xloop_file_fmt_qcow_cluster.c
+++ b/src/kernel/xloop_file_fmt_qcow_cluster.c
@@ -1,4 +1,4 @@
-/* SPDX-License-Identifier: GPL-2.0 */
+// SPDX-License-Identifier: GPL-2.0
 /*
  * xloop_file_fmt_qcow_cluster.c
  *
@@ -34,19 +34,17 @@
  * the cache is used; otherwise the L2 slice is loaded from the image
  * file.
  */
-static int __xloop_file_fmt_qcow_cluster_l2_load(struct xloop_file_fmt *xlo_fmt,
-	u64 offset, u64 l2_offset, u64 **l2_slice)
+static int __xloop_file_fmt_qcow_cluster_l2_load(struct xloop_file_fmt *xlo_fmt, u64 offset, u64 l2_offset,
+						 u64 **l2_slice)
 {
 	struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
 
-	int start_of_slice = xloop_file_fmt_qcow_l2_entry_size(qcow_data) * (
-		xloop_file_fmt_qcow_offset_to_l2_index(qcow_data, offset) -
-		xloop_file_fmt_qcow_offset_to_l2_slice_index(qcow_data, offset)
-	);
+	int start_of_slice = xloop_file_fmt_qcow_l2_entry_size(qcow_data) *
+			     (xloop_file_fmt_qcow_offset_to_l2_index(qcow_data, offset) -
+			      xloop_file_fmt_qcow_offset_to_l2_slice_index(qcow_data, offset));
 
 	ASSERT(qcow_data->l2_table_cache != NULL);
-	return xloop_file_fmt_qcow_cache_get(xlo_fmt, l2_offset + start_of_slice,
-		(void **) l2_slice);
+	return xloop_file_fmt_qcow_cache_get(xlo_fmt, l2_offset + start_of_slice, (void **)l2_slice);
 }
 
 /*
@@ -61,45 +59,41 @@ static int __xloop_file_fmt_qcow_cluster_l2_load(struct xloop_file_fmt *xlo_fmt,
  * If the L2 entry is invalid return -errno and set @type to
  * QCOW_SUBCLUSTER_INVALID.
  */
-static int __xloop_file_fmt_qcow_get_subcluster_range_type(
-	struct xloop_file_fmt *xlo_fmt, u64 l2_entry, u64 l2_bitmap,
-	unsigned int sc_from, enum xloop_file_fmt_qcow_subcluster_type *type)
+static int __xloop_file_fmt_qcow_get_subcluster_range_type(struct xloop_file_fmt *xlo_fmt, u64 l2_entry, u64 l2_bitmap,
+							   unsigned int sc_from,
+							   enum xloop_file_fmt_qcow_subcluster_type *type)
 {
-    struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
-    u32 val;
-
-    *type = xloop_file_fmt_qcow_get_subcluster_type(xlo_fmt, l2_entry,
-		l2_bitmap, sc_from);
-
-    if (*type == QCOW_SUBCLUSTER_INVALID) {
-        return -EINVAL;
-    } else if (!xloop_file_fmt_qcow_has_subclusters(qcow_data) || 
-		*type == QCOW_SUBCLUSTER_COMPRESSED) {
-        return qcow_data->subclusters_per_cluster - sc_from;
-    }
-
-    switch (*type) {
-    case QCOW_SUBCLUSTER_NORMAL:
-        val = l2_bitmap | QCOW_OFLAG_SUB_ALLOC_RANGE(0, sc_from);
-        return __builtin_ctz(~val) - sc_from;
-
-    case QCOW_SUBCLUSTER_ZERO_PLAIN:
-    case QCOW_SUBCLUSTER_ZERO_ALLOC:
-        val = (l2_bitmap | QCOW_OFLAG_SUB_ZERO_RANGE(0, sc_from)) >> 32;
-        return __builtin_ctz(~val) - sc_from;
-
-    case QCOW_SUBCLUSTER_UNALLOCATED_PLAIN:
-    case QCOW_SUBCLUSTER_UNALLOCATED_ALLOC:
-        val = ((l2_bitmap >> 32) | l2_bitmap)
-            & ~QCOW_OFLAG_SUB_ALLOC_RANGE(0, sc_from);
-        return __builtin_ctz(val) - sc_from;
-
-    default:
-        /* not reachable */
-        ASSERT(false);
+	struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
+	u32 val;
+
+	*type = xloop_file_fmt_qcow_get_subcluster_type(xlo_fmt, l2_entry, l2_bitmap, sc_from);
+
+	if (*type == QCOW_SUBCLUSTER_INVALID)
+		return -EINVAL;
+	else if (!xloop_file_fmt_qcow_has_subclusters(qcow_data) || *type == QCOW_SUBCLUSTER_COMPRESSED)
+		return qcow_data->subclusters_per_cluster - sc_from;
+
+	switch (*type) {
+	case QCOW_SUBCLUSTER_NORMAL:
+		val = l2_bitmap | QCOW_OFLAG_SUB_ALLOC_RANGE(0, sc_from);
+		return __builtin_ctz(~val) - sc_from;
+
+	case QCOW_SUBCLUSTER_ZERO_PLAIN:
+	case QCOW_SUBCLUSTER_ZERO_ALLOC:
+		val = (l2_bitmap | QCOW_OFLAG_SUB_ZERO_RANGE(0, sc_from)) >> 32;
+		return __builtin_ctz(~val) - sc_from;
+
+	case QCOW_SUBCLUSTER_UNALLOCATED_PLAIN:
+	case QCOW_SUBCLUSTER_UNALLOCATED_ALLOC:
+		val = ((l2_bitmap >> 32) | l2_bitmap) & ~QCOW_OFLAG_SUB_ALLOC_RANGE(0, sc_from);
+		return __builtin_ctz(val) - sc_from;
+
+	default:
+		/* not reachable */
+		ASSERT(false);
 		*type = QCOW_SUBCLUSTER_INVALID;
 		return 0;
-    }
+	}
 }
 
 /*
@@ -115,58 +109,52 @@ static int __xloop_file_fmt_qcow_get_subcluster_range_type(
  * On failure return -errno and update @l2_index to point to the
  * invalid entry.
  */
-static int __xloop_file_fmt_qcow_count_contiguous_subclusters(
-	struct xloop_file_fmt *xlo_fmt, int nb_clusters, unsigned int sc_index,
-	u64 *l2_slice, unsigned int *l2_index)
+static int __xloop_file_fmt_qcow_count_contiguous_subclusters(struct xloop_file_fmt *xlo_fmt, int nb_clusters,
+							      unsigned int sc_index, u64 *l2_slice,
+							      unsigned int *l2_index)
 {
-    struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
-    int i, count = 0;
-    bool check_offset = false;
-    u64 expected_offset = 0;
-    enum xloop_file_fmt_qcow_subcluster_type expected_type = 
-		QCOW_SUBCLUSTER_NORMAL;
+	struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
+	int i, count = 0;
+	bool check_offset = false;
+	u64 expected_offset = 0;
+	enum xloop_file_fmt_qcow_subcluster_type expected_type = QCOW_SUBCLUSTER_NORMAL;
 	enum xloop_file_fmt_qcow_subcluster_type type;
 
-    ASSERT(*l2_index + nb_clusters <= qcow_data->l2_slice_size);
-
-    for (i = 0; i < nb_clusters; i++) {
-        unsigned int first_sc = (i == 0) ? sc_index : 0;
-        u64 l2_entry = xloop_file_fmt_qcow_get_l2_entry(qcow_data, l2_slice,
-			*l2_index + i);
-        u64 l2_bitmap = xloop_file_fmt_qcow_get_l2_bitmap(qcow_data, l2_slice,
-			*l2_index + i);
-        int ret = __xloop_file_fmt_qcow_get_subcluster_range_type(xlo_fmt,
-			l2_entry, l2_bitmap, first_sc, &type);
-        if (ret < 0) {
-            *l2_index += i; /* Point to the invalid entry */
-            return -EIO;
-        }
-        if (i == 0) {
-            if (type == QCOW_SUBCLUSTER_COMPRESSED) {
-                /* Compressed clusters are always processed one by one */
-                return ret;
-            }
-            expected_type = type;
-            expected_offset = l2_entry & QCOW_L2E_OFFSET_MASK;
-            check_offset = (type == QCOW_SUBCLUSTER_NORMAL ||
-                            type == QCOW_SUBCLUSTER_ZERO_ALLOC ||
-                            type == QCOW_SUBCLUSTER_UNALLOCATED_ALLOC);
-        } else if (type != expected_type) {
-            break;
-        } else if (check_offset) {
-            expected_offset += qcow_data->cluster_size;
-            if (expected_offset != (l2_entry & QCOW_L2E_OFFSET_MASK)) {
-                break;
-            }
-        }
-        count += ret;
-        /* Stop if there are type changes before the end of the cluster */
-        if (first_sc + ret < qcow_data->subclusters_per_cluster) {
-            break;
-        }
-    }
-
-    return count;
+	ASSERT(*l2_index + nb_clusters <= qcow_data->l2_slice_size);
+
+	for (i = 0; i < nb_clusters; i++) {
+		unsigned int first_sc = (i == 0) ? sc_index : 0;
+		u64 l2_entry = xloop_file_fmt_qcow_get_l2_entry(qcow_data, l2_slice, *l2_index + i);
+		u64 l2_bitmap = xloop_file_fmt_qcow_get_l2_bitmap(qcow_data, l2_slice, *l2_index + i);
+		int ret =
+			__xloop_file_fmt_qcow_get_subcluster_range_type(xlo_fmt, l2_entry, l2_bitmap, first_sc, &type);
+		if (ret < 0) {
+			*l2_index += i; /* Point to the invalid entry */
+			return -EIO;
+		}
+		if (i == 0) {
+			if (type == QCOW_SUBCLUSTER_COMPRESSED) {
+				/* Compressed clusters are always processed one by one */
+				return ret;
+			}
+			expected_type = type;
+			expected_offset = l2_entry & QCOW_L2E_OFFSET_MASK;
+			check_offset = (type == QCOW_SUBCLUSTER_NORMAL || type == QCOW_SUBCLUSTER_ZERO_ALLOC ||
+					type == QCOW_SUBCLUSTER_UNALLOCATED_ALLOC);
+		} else if (type != expected_type) {
+			break;
+		} else if (check_offset) {
+			expected_offset += qcow_data->cluster_size;
+			if (expected_offset != (l2_entry & QCOW_L2E_OFFSET_MASK))
+				break;
+		}
+		count += ret;
+		/* Stop if there are type changes before the end of the cluster */
+		if (first_sc + ret < qcow_data->subclusters_per_cluster)
+			break;
+	}
+
+	return count;
 }
 
 /*
@@ -190,9 +178,8 @@ static int __xloop_file_fmt_qcow_count_contiguous_subclusters(
  *
  * Returns 0 on success, -errno in error cases.
  */
-int xloop_file_fmt_qcow_get_host_offset(struct xloop_file_fmt *xlo_fmt,
-	u64 offset, unsigned int *bytes, u64 *host_offset,
-	enum xloop_file_fmt_qcow_subcluster_type *subcluster_type)
+int xloop_file_fmt_qcow_get_host_offset(struct xloop_file_fmt *xlo_fmt, u64 offset, unsigned int *bytes,
+					u64 *host_offset, enum xloop_file_fmt_qcow_subcluster_type *subcluster_type)
 {
 	struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
 	unsigned int l2_index, sc_index;
@@ -204,21 +191,20 @@ int xloop_file_fmt_qcow_get_host_offset(struct xloop_file_fmt *xlo_fmt,
 	int ret;
 	u64 host_cluster_offset;
 
-	offset_in_cluster = xloop_file_fmt_qcow_offset_into_cluster(qcow_data,
-		offset);
-	bytes_needed = (u64) *bytes + offset_in_cluster;
+	offset_in_cluster = xloop_file_fmt_qcow_offset_into_cluster(qcow_data, offset);
+	bytes_needed = (u64)*bytes + offset_in_cluster;
 
-	/* compute how many bytes there are between the start of the cluster
+	/*
+	 * compute how many bytes there are between the start of the cluster
 	 * containing offset and the end of the l2 slice that contains
-	 * the entry pointing to it */
-	bytes_available = ((u64)(
-		qcow_data->l2_slice_size -
-		xloop_file_fmt_qcow_offset_to_l2_slice_index(qcow_data, offset))
-	) << qcow_data->cluster_bits;
+	 * the entry pointing to it
+	 */
+	bytes_available =
+		((u64)(qcow_data->l2_slice_size - xloop_file_fmt_qcow_offset_to_l2_slice_index(qcow_data, offset)))
+		<< qcow_data->cluster_bits;
 
-	if (bytes_needed > bytes_available) {
+	if (bytes_needed > bytes_available)
 		bytes_needed = bytes_available;
-	}
 
 	*host_offset = 0;
 
@@ -236,52 +222,45 @@ int xloop_file_fmt_qcow_get_host_offset(struct xloop_file_fmt *xlo_fmt,
 	}
 
 	if (xloop_file_fmt_qcow_offset_into_cluster(qcow_data, l2_offset)) {
-		dev_err_ratelimited(xloop_file_fmt_to_dev(xlo_fmt), "L2 table offset "
-			"%llx unaligned (L1 index: %llx)", l2_offset, l1_index);
+		dev_err_ratelimited(xloop_file_fmt_to_dev(xlo_fmt), "L2 table offset %llx unaligned (L1 index: %llx)",
+				    l2_offset, l1_index);
 		return -EIO;
 	}
 
 	/* load the l2 slice in memory */
-	ret = __xloop_file_fmt_qcow_cluster_l2_load(xlo_fmt, offset, l2_offset,
-		&l2_slice);
-	if (ret < 0) {
+	ret = __xloop_file_fmt_qcow_cluster_l2_load(xlo_fmt, offset, l2_offset, &l2_slice);
+	if (ret < 0)
 		return ret;
-	}
 
 	/* find the cluster offset for the given disk offset */
-	l2_index = xloop_file_fmt_qcow_offset_to_l2_slice_index(qcow_data,
-		offset);
+	l2_index = xloop_file_fmt_qcow_offset_to_l2_slice_index(qcow_data, offset);
 	sc_index = xloop_file_fmt_qcow_offset_to_sc_index(qcow_data, offset);
-    l2_entry = xloop_file_fmt_qcow_get_l2_entry(qcow_data, l2_slice,
-		l2_index);
-    l2_bitmap = xloop_file_fmt_qcow_get_l2_bitmap(qcow_data, l2_slice, 
-		l2_index);
-
-	nb_clusters = xloop_file_fmt_qcow_size_to_clusters(qcow_data,
-		bytes_needed);
-	/* bytes_needed <= *bytes + offset_in_cluster, both of which are
+	l2_entry = xloop_file_fmt_qcow_get_l2_entry(qcow_data, l2_slice, l2_index);
+	l2_bitmap = xloop_file_fmt_qcow_get_l2_bitmap(qcow_data, l2_slice, l2_index);
+
+	nb_clusters = xloop_file_fmt_qcow_size_to_clusters(qcow_data, bytes_needed);
+	/*
+	 * bytes_needed <= *bytes + offset_in_cluster, both of which are
 	 * unsigned integers; the minimum cluster size is 512, so this
-	 * assertion is always true */
+	 * assertion is always true
+	 */
 	ASSERT(nb_clusters <= INT_MAX);
 
-	type = xloop_file_fmt_qcow_get_subcluster_type(xlo_fmt, l2_entry,
-		l2_bitmap, sc_index);
-	if (qcow_data->qcow_version < 3 && (
-			type == QCOW_SUBCLUSTER_ZERO_PLAIN ||
-			type == QCOW_SUBCLUSTER_ZERO_ALLOC)) {
-		dev_err_ratelimited(xloop_file_fmt_to_dev(xlo_fmt), "zero cluster "
-			"entry found in pre-v3 image (L2 offset: %llx, L2 index: %x)\n",
-			l2_offset, l2_index);
+	type = xloop_file_fmt_qcow_get_subcluster_type(xlo_fmt, l2_entry, l2_bitmap, sc_index);
+	if (qcow_data->qcow_version < 3 && (type == QCOW_SUBCLUSTER_ZERO_PLAIN || type == QCOW_SUBCLUSTER_ZERO_ALLOC)) {
+		dev_err_ratelimited(xloop_file_fmt_to_dev(xlo_fmt),
+				    "zero cluster entry found in pre-v3 image (L2 offset: %llx, L2 index: %x)\n",
+				    l2_offset, l2_index);
 		ret = -EIO;
 		goto fail;
 	}
 	switch (type) {
-    case QCOW_SUBCLUSTER_INVALID:
-        break; /* This is handled by count_contiguous_subclusters() below */
+	case QCOW_SUBCLUSTER_INVALID:
+		break; /* This is handled by count_contiguous_subclusters() below */
 	case QCOW_SUBCLUSTER_COMPRESSED:
 		if (xloop_file_fmt_qcow_has_data_file(qcow_data)) {
-			dev_err_ratelimited(xloop_file_fmt_to_dev(xlo_fmt), "compressed "
-				"cluster entry found in image with external data file "
+			dev_err_ratelimited(xloop_file_fmt_to_dev(xlo_fmt),
+				"compressed cluster entry found in image with external data file "
 				"(L2 offset: %llx, L2 index: %x)\n", l2_offset, l2_index);
 			ret = -EIO;
 			goto fail;
@@ -296,20 +275,17 @@ int xloop_file_fmt_qcow_get_host_offset(struct xloop_file_fmt *xlo_fmt,
 	case QCOW_SUBCLUSTER_UNALLOCATED_ALLOC:
 		host_cluster_offset = l2_entry & QCOW_L2E_OFFSET_MASK;
 		*host_offset = host_cluster_offset + offset_in_cluster;
-		if (xloop_file_fmt_qcow_offset_into_cluster(qcow_data,
-			host_cluster_offset)) {
-			dev_err_ratelimited(xloop_file_fmt_to_dev(xlo_fmt), "cluster "
-				"allocation offset %llx unaligned (L2 offset: %llx, "
-				"L2 index: %x)\n", host_cluster_offset, l2_offset, l2_index);
+		if (xloop_file_fmt_qcow_offset_into_cluster(qcow_data, host_cluster_offset)) {
+			dev_err_ratelimited(xloop_file_fmt_to_dev(xlo_fmt),
+				"cluster allocation offset %llx unaligned (L2 offset: %llx, L2 index: %x)\n",
+				host_cluster_offset, l2_offset, l2_index);
 			ret = -EIO;
 			goto fail;
 		}
-		if (xloop_file_fmt_qcow_has_data_file(qcow_data) &&
-			*host_offset != offset) {
-			dev_err_ratelimited(xloop_file_fmt_to_dev(xlo_fmt), "external "
-				"data file host cluster offset %llx  does not match guest "
-				"cluster offset: %llx, L2 index: %x)\n", host_cluster_offset,
-				offset - offset_in_cluster, l2_index);
+		if (xloop_file_fmt_qcow_has_data_file(qcow_data) && *host_offset != offset) {
+			dev_err_ratelimited(xloop_file_fmt_to_dev(xlo_fmt),
+				"external data file host cluster offset %llx does not match guest cluster offset: "
+				"%llx, L2 index: %x)\n", host_cluster_offset, offset - offset_in_cluster, l2_index);
 			ret = -EIO;
 			goto fail;
 		}
@@ -318,28 +294,28 @@ int xloop_file_fmt_qcow_get_host_offset(struct xloop_file_fmt *xlo_fmt,
 		BUG();
 	}
 
-	sc = __xloop_file_fmt_qcow_count_contiguous_subclusters(xlo_fmt,
-		nb_clusters, sc_index, l2_slice, &l2_index);
+	sc = __xloop_file_fmt_qcow_count_contiguous_subclusters(xlo_fmt, nb_clusters, sc_index, l2_slice, &l2_index);
 
 	if (sc < 0) {
-        dev_err_ratelimited(xloop_file_fmt_to_dev(xlo_fmt), "invalid cluster "
-			"entry found (L2 offset: %#llx, L2 index: %#x)", l2_offset,
-			l2_index);
-        ret = -EIO;
-        goto fail;
-    }
-	xloop_file_fmt_qcow_cache_put(xlo_fmt, (void **) &l2_slice);
+		dev_err_ratelimited(xloop_file_fmt_to_dev(xlo_fmt),
+				    "invalid cluster entry found (L2 offset: %#llx, L2 index: %#x)", l2_offset,
+				    l2_index);
+		ret = -EIO;
+		goto fail;
+	}
+	xloop_file_fmt_qcow_cache_put(xlo_fmt, (void **)&l2_slice);
 
-	bytes_available = ((s64) sc + sc_index) << qcow_data->subcluster_bits;
+	bytes_available = ((s64)sc + sc_index) << qcow_data->subcluster_bits;
 
 out:
-	if (bytes_available > bytes_needed) {
+	if (bytes_available > bytes_needed)
 		bytes_available = bytes_needed;
-	}
 
-	/* bytes_available <= bytes_needed <= *bytes + offset_in_cluster;
+	/*
+	 * bytes_available <= bytes_needed <= *bytes + offset_in_cluster;
 	 * subtracting offset_in_cluster will therefore definitely yield
-	 * something not exceeding UINT_MAX */
+	 * something not exceeding UINT_MAX
+	 */
 	ASSERT(bytes_available - offset_in_cluster <= UINT_MAX);
 	*bytes = bytes_available - offset_in_cluster;
 
@@ -348,6 +324,6 @@ out:
 	return 0;
 
 fail:
-	xloop_file_fmt_qcow_cache_put(xlo_fmt, (void **) &l2_slice);
+	xloop_file_fmt_qcow_cache_put(xlo_fmt, (void **)&l2_slice);
 	return ret;
 }
diff --git a/src/kernel/xloop_file_fmt_qcow_cluster.h b/src/kernel/xloop_file_fmt_qcow_cluster.h
index a3716f5..8be0592 100644
--- a/src/kernel/xloop_file_fmt_qcow_cluster.h
+++ b/src/kernel/xloop_file_fmt_qcow_cluster.h
@@ -15,8 +15,8 @@
 
 #include "xloop_file_fmt.h"
 
-extern int xloop_file_fmt_qcow_get_host_offset(struct xloop_file_fmt *xlo_fmt,
-	u64 offset, unsigned int *bytes, u64 *host_offset,
-	enum xloop_file_fmt_qcow_subcluster_type *subcluster_type);
+extern int xloop_file_fmt_qcow_get_host_offset(struct xloop_file_fmt *xlo_fmt, u64 offset, unsigned int *bytes,
+					       u64 *host_offset,
+					       enum xloop_file_fmt_qcow_subcluster_type *subcluster_type);
 
 #endif
diff --git a/src/kernel/xloop_file_fmt_qcow_main.c b/src/kernel/xloop_file_fmt_qcow_main.c
index 376273d..e642160 100644
--- a/src/kernel/xloop_file_fmt_qcow_main.c
+++ b/src/kernel/xloop_file_fmt_qcow_main.c
@@ -1,4 +1,4 @@
-/* SPDX-License-Identifier: GPL-2.0 */
+// SPDX-License-Identifier: GPL-2.0
 /*
  * xloop_file_fmt_qcow.c
  *
@@ -36,15 +36,15 @@
 #include "xloop_file_fmt_qcow_cluster.h"
 
 #ifdef CONFIG_ZSTD_DECOMPRESS
-#define ZSTD_WINDOWLOG_LIMIT_DEFAULT  27
-#define ZSTD_MAXWINDOWSIZE  ((U32_C(1) << ZSTD_WINDOWLOG_LIMIT_DEFAULT) + 1)
+#define ZSTD_WINDOWLOG_LIMIT_DEFAULT 27
+#define ZSTD_MAXWINDOWSIZE ((U32_C(1) << ZSTD_WINDOWLOG_LIMIT_DEFAULT) + 1)
 #endif
 
-typedef ssize_t (*qcow_file_fmt_decompress_fn)(struct xloop_file_fmt *xlo_fmt,
-	void *dest, size_t dest_size, const void *src, size_t src_size);
+typedef ssize_t (*qcow_file_fmt_decompress_fn)(struct xloop_file_fmt *xlo_fmt, void *dest, size_t dest_size,
+					       const void *src, size_t src_size);
 
-static int __qcow_file_fmt_header_read(struct xloop_file_fmt *xlo_fmt,
-	struct file *file, struct xloop_file_fmt_qcow_header *header)
+static int __qcow_file_fmt_header_read(struct xloop_file_fmt *xlo_fmt, struct file *file,
+				       struct xloop_file_fmt_qcow_header *header)
 {
 	ssize_t len;
 	loff_t offset;
@@ -54,8 +54,7 @@ static int __qcow_file_fmt_header_read(struct xloop_file_fmt *xlo_fmt,
 	offset = 0;
 	len = kernel_read(file, header, sizeof(*header), &offset);
 	if (len < 0) {
-		dev_err(xloop_file_fmt_to_dev(xlo_fmt), "could not read QCOW "
-			"header\n");
+		dev_err(xloop_file_fmt_to_dev(xlo_fmt), "could not read QCOW header\n");
 		return len;
 	}
 
@@ -68,40 +67,33 @@ static int __qcow_file_fmt_header_read(struct xloop_file_fmt *xlo_fmt,
 	header->crypt_method = be32_to_cpu(header->crypt_method);
 	header->l1_size = be32_to_cpu(header->l1_size);
 	header->l1_table_offset = be64_to_cpu(header->l1_table_offset);
-	header->refcount_table_offset =
-		be64_to_cpu(header->refcount_table_offset);
-	header->refcount_table_clusters =
-		be32_to_cpu(header->refcount_table_clusters);
+	header->refcount_table_offset = be64_to_cpu(header->refcount_table_offset);
+	header->refcount_table_clusters = be32_to_cpu(header->refcount_table_clusters);
 	header->nb_snapshots = be32_to_cpu(header->nb_snapshots);
 	header->snapshots_offset = be64_to_cpu(header->snapshots_offset);
 
 	/* check QCOW file format and header version */
 	if (header->magic != QCOW_MAGIC) {
-		dev_err(xloop_file_fmt_to_dev(xlo_fmt), "image is not in QCOW "
-			"format\n");
+		dev_err(xloop_file_fmt_to_dev(xlo_fmt), "image is not in QCOW format\n");
 		return -EINVAL;
 	}
 
 	if (header->version < 2 || header->version > 3) {
-		dev_err(xloop_file_fmt_to_dev(xlo_fmt), "unsupported QCOW "
-			"version %d\n", header->version);
+		dev_err(xloop_file_fmt_to_dev(xlo_fmt), "unsupported QCOW version %d\n", header->version);
 		return -ENOTSUPP;
 	}
 
 	/* initialize version 3 header fields */
 	if (header->version == 2) {
-		header->incompatible_features =  0;
-		header->compatible_features   =  0;
-		header->autoclear_features    =  0;
-		header->refcount_order        =  4;
-		header->header_length         = 72;
+		header->incompatible_features = 0;
+		header->compatible_features = 0;
+		header->autoclear_features = 0;
+		header->refcount_order = 4;
+		header->header_length = 72;
 	} else {
-		header->incompatible_features =
-			be64_to_cpu(header->incompatible_features);
-		header->compatible_features =
-			be64_to_cpu(header->compatible_features);
-		header->autoclear_features =
-			be64_to_cpu(header->autoclear_features);
+		header->incompatible_features = be64_to_cpu(header->incompatible_features);
+		header->compatible_features = be64_to_cpu(header->compatible_features);
+		header->autoclear_features = be64_to_cpu(header->autoclear_features);
 		header->refcount_order = be32_to_cpu(header->refcount_order);
 		header->header_length = be32_to_cpu(header->header_length);
 
@@ -114,9 +106,8 @@ static int __qcow_file_fmt_header_read(struct xloop_file_fmt *xlo_fmt,
 	return ret;
 }
 
-static int __qcow_file_fmt_validate_table(struct xloop_file_fmt *xlo_fmt,
-	u64 offset, u64 entries, size_t entry_len, s64 max_size_bytes,
-	const char *table_name)
+static int __qcow_file_fmt_validate_table(struct xloop_file_fmt *xlo_fmt, u64 offset, u64 entries, size_t entry_len,
+					  s64 max_size_bytes, const char *table_name)
 {
 	struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
 
@@ -125,24 +116,24 @@ static int __qcow_file_fmt_validate_table(struct xloop_file_fmt *xlo_fmt,
 		return -EFBIG;
 	}
 
-	/* Use signed S64_MAX as the maximum even for u64 header fields,
-	 * because values will be passed to qemu functions taking s64. */
-	if ((S64_MAX - entries * entry_len < offset) || (
-		xloop_file_fmt_qcow_offset_into_cluster(qcow_data, offset) != 0)
-	) {
-		dev_err(xloop_file_fmt_to_dev(xlo_fmt), "%s offset invalid",
-			table_name);
+	/*
+	 * Use signed S64_MAX as the maximum even for u64 header fields,
+	 * because values will be passed to qemu functions taking s64.
+	 */
+	if ((S64_MAX - entries * entry_len < offset) ||
+	    (xloop_file_fmt_qcow_offset_into_cluster(qcow_data, offset) != 0)) {
+		dev_err(xloop_file_fmt_to_dev(xlo_fmt), "%s offset invalid", table_name);
 		return -EINVAL;
 	}
 
 	return 0;
 }
 
-static inline loff_t __qcow_file_fmt_rq_get_pos(struct xloop_file_fmt *xlo_fmt,
-						struct request *rq)
+static inline loff_t __qcow_file_fmt_rq_get_pos(struct xloop_file_fmt *xlo_fmt, struct request *rq)
 {
 	struct xloop_device *xlo = xloop_file_fmt_get_xlo(xlo_fmt);
-	return ((loff_t) blk_rq_pos(rq) << 9) + xlo->xlo_offset;
+
+	return ((loff_t)blk_rq_pos(rq) << 9) + xlo->xlo_offset;
 }
 
 static int __qcow_file_fmt_compression_init(struct xloop_file_fmt *xlo_fmt)
@@ -168,10 +159,10 @@ static int __qcow_file_fmt_compression_init(struct xloop_file_fmt *xlo_fmt)
 
 	/* set up ZLIB decompression stream */
 	ret = zlib_inflateInit2(qcow_data->zlib_dstrm, -12);
-    if (ret != Z_OK) {
-        ret = -EIO;
+	if (ret != Z_OK) {
+		ret = -EIO;
 		goto out_free_zlib_dworkspace;
-    }
+	}
 
 #ifdef CONFIG_ZSTD_DECOMPRESS
 	/* create workspace for ZSTD decompression stream */
@@ -183,8 +174,7 @@ static int __qcow_file_fmt_compression_init(struct xloop_file_fmt *xlo_fmt)
 	}
 
 	/* set up ZSTD decompression stream */
-	qcow_data->zstd_dstrm = ZSTD_initDStream(ZSTD_MAXWINDOWSIZE,
-		qcow_data->zstd_dworkspace, workspace_size);
+	qcow_data->zstd_dstrm = ZSTD_initDStream(ZSTD_MAXWINDOWSIZE, qcow_data->zstd_dworkspace, workspace_size);
 	if (!qcow_data->zstd_dstrm) {
 		ret = -EINVAL;
 		goto out_free_zstd_dworkspace;
@@ -237,85 +227,53 @@ static void __qcow_file_fmt_compression_exit(struct xloop_file_fmt *xlo_fmt)
 
 #ifdef CONFIG_DEBUG_FS
 static void __qcow_file_fmt_header_to_buf(struct xloop_file_fmt *xlo_fmt,
-	const struct xloop_file_fmt_qcow_header *header)
+					  const struct xloop_file_fmt_qcow_header *header)
 {
 	struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
 	char *header_buf = qcow_data->dbgfs_file_qcow_header_buf;
 	ssize_t len = 0;
 
-	len += sprintf(header_buf + len, "magic: %d\n",
-		header->magic);
-	len += sprintf(header_buf + len, "version: %d\n",
-		header->version);
-	len += sprintf(header_buf + len, "backing_file_offset: %lld\n",
-		header->backing_file_offset);
-	len += sprintf(header_buf + len, "backing_file_size: %d\n",
-		header->backing_file_size);
-	len += sprintf(header_buf + len, "cluster_bits: %d\n",
-		header->cluster_bits);
-	len += sprintf(header_buf + len, "size: %lld\n",
-		header->size);
-	len += sprintf(header_buf + len, "crypt_method: %d\n",
-		header->crypt_method);
-	len += sprintf(header_buf + len, "l1_size: %d\n",
-		header->l1_size);
-	len += sprintf(header_buf + len, "l1_table_offset: %lld\n",
-		header->l1_table_offset);
-	len += sprintf(header_buf + len, "refcount_table_offset: %lld\n",
-		header->refcount_table_offset);
-	len += sprintf(header_buf + len, "refcount_table_clusters: %d\n",
-		header->refcount_table_clusters);
-	len += sprintf(header_buf + len, "nb_snapshots: %d\n",
-		header->nb_snapshots);
-	len += sprintf(header_buf + len, "snapshots_offset: %lld\n",
-		header->snapshots_offset);
+	len += sprintf(header_buf + len, "magic: %d\n", header->magic);
+	len += sprintf(header_buf + len, "version: %d\n", header->version);
+	len += sprintf(header_buf + len, "backing_file_offset: %lld\n", header->backing_file_offset);
+	len += sprintf(header_buf + len, "backing_file_size: %d\n", header->backing_file_size);
+	len += sprintf(header_buf + len, "cluster_bits: %d\n", header->cluster_bits);
+	len += sprintf(header_buf + len, "size: %lld\n", header->size);
+	len += sprintf(header_buf + len, "crypt_method: %d\n", header->crypt_method);
+	len += sprintf(header_buf + len, "l1_size: %d\n", header->l1_size);
+	len += sprintf(header_buf + len, "l1_table_offset: %lld\n", header->l1_table_offset);
+	len += sprintf(header_buf + len, "refcount_table_offset: %lld\n", header->refcount_table_offset);
+	len += sprintf(header_buf + len, "refcount_table_clusters: %d\n", header->refcount_table_clusters);
+	len += sprintf(header_buf + len, "nb_snapshots: %d\n", header->nb_snapshots);
+	len += sprintf(header_buf + len, "snapshots_offset: %lld\n", header->snapshots_offset);
 
 	if (header->version == 3) {
-		len += sprintf(header_buf + len,
-			"incompatible_features: %lld\n",
-			header->incompatible_features);
-		len += sprintf(header_buf + len,
-			"compatible_features: %lld\n",
-			header->compatible_features);
-		len += sprintf(header_buf + len,
-			"autoclear_features: %lld\n",
-			header->autoclear_features);
-		len += sprintf(header_buf + len,
-			"refcount_order: %d\n",
-			header->refcount_order);
-		len += sprintf(header_buf + len,
-			"header_length: %d\n",
-			header->header_length);
+		len += sprintf(header_buf + len, "incompatible_features: %lld\n", header->incompatible_features);
+		len += sprintf(header_buf + len, "compatible_features: %lld\n", header->compatible_features);
+		len += sprintf(header_buf + len, "autoclear_features: %lld\n", header->autoclear_features);
+		len += sprintf(header_buf + len, "refcount_order: %d\n", header->refcount_order);
+		len += sprintf(header_buf + len, "header_length: %d\n", header->header_length);
 	}
 
-	if (header->header_length > offsetof(struct xloop_file_fmt_qcow_header,
-		compression_type)) {
-		len += sprintf(header_buf + len,
-			"compression_type: %d\n",
-			header->compression_type);
-    } 
+	if (header->header_length > offsetof(struct xloop_file_fmt_qcow_header, compression_type))
+		len += sprintf(header_buf + len, "compression_type: %d\n", header->compression_type);
 
 	ASSERT(len < QCOW_HEADER_BUF_LEN);
 }
 
-static ssize_t __qcow_file_fmt_dbgfs_hdr_read(struct file *file,
-	char __user *buf, size_t size, loff_t *ppos)
+static ssize_t __qcow_file_fmt_dbgfs_hdr_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
 {
 	struct xloop_file_fmt *xlo_fmt = file->private_data;
 	struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
 	char *header_buf = qcow_data->dbgfs_file_qcow_header_buf;
 
-	return simple_read_from_buffer(buf, size, ppos, header_buf,
-		strlen(header_buf));
+	return simple_read_from_buffer(buf, size, ppos, header_buf, strlen(header_buf));
 }
 
-static const struct file_operations qcow_file_fmt_dbgfs_hdr_fops = {
-	.open = simple_open,
-	.read = __qcow_file_fmt_dbgfs_hdr_read
-};
+static const struct file_operations qcow_file_fmt_dbgfs_hdr_fops = { .open = simple_open,
+								     .read = __qcow_file_fmt_dbgfs_hdr_read };
 
-static ssize_t __qcow_file_fmt_dbgfs_ofs_read(struct file *file,
-	char __user *buf, size_t size, loff_t *ppos)
+static ssize_t __qcow_file_fmt_dbgfs_ofs_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
 {
 	struct xloop_file_fmt *xlo_fmt = file->private_data;
 	struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
@@ -337,44 +295,37 @@ static ssize_t __qcow_file_fmt_dbgfs_ofs_read(struct file *file,
 	mutex_unlock(&qcow_data->dbgfs_qcow_offset_mutex);
 
 	/* calculate and print the cluster offset */
-	ret = xloop_file_fmt_qcow_get_host_offset(xlo_fmt,
-		offset, &cur_bytes, &host_offset, &type);
+	ret = xloop_file_fmt_qcow_get_host_offset(xlo_fmt, offset, &cur_bytes, &host_offset, &type);
 	if (ret < 0)
 		return -EINVAL;
 
-	offset_in_cluster = xloop_file_fmt_qcow_offset_into_cluster(qcow_data,
-		offset);
+	offset_in_cluster = xloop_file_fmt_qcow_offset_into_cluster(qcow_data, offset);
 
 	len = sprintf(qcow_data->dbgfs_file_qcow_cluster_buf,
-	              "cluster type: %s\n"
-		          "cluster offset host: %lld\n"
-				  "cluster offset guest: %lld\n"
-				  "cluster offset in-cluster: %lld\n",
-				  xloop_file_fmt_qcow_get_subcluster_name(type),
-				  host_offset, offset, offset_in_cluster);
-
-    if (type == QCOW_SUBCLUSTER_COMPRESSED) {
-        coffset = host_offset & qcow_data->cluster_offset_mask;
-        nb_csectors = ((host_offset >> qcow_data->csize_shift) & 
-			qcow_data->csize_mask) + 1;
-        csize = nb_csectors * QCOW_COMPRESSED_SECTOR_SIZE -
-            (coffset & ~QCOW_COMPRESSED_SECTOR_MASK);
+		      "cluster type: %s\n"
+		      "cluster offset host: %lld\n"
+		      "cluster offset guest: %lld\n"
+		      "cluster offset in-cluster: %lld\n",
+		      xloop_file_fmt_qcow_get_subcluster_name(type), host_offset, offset, offset_in_cluster);
+
+	if (type == QCOW_SUBCLUSTER_COMPRESSED) {
+		coffset = host_offset & qcow_data->cluster_offset_mask;
+		nb_csectors = ((host_offset >> qcow_data->csize_shift) & qcow_data->csize_mask) + 1;
+		csize = nb_csectors * QCOW_COMPRESSED_SECTOR_SIZE - (coffset & ~QCOW_COMPRESSED_SECTOR_MASK);
 
 		len += sprintf(qcow_data->dbgfs_file_qcow_cluster_buf + len,
-                       "cluster compressed offset: %lld\n"
-					   "cluster compressed sectors: %d\n"
-					   "cluster compressed size: %d\n",
-					   coffset, nb_csectors, csize);
-    }
+			       "cluster compressed offset: %lld\n"
+			       "cluster compressed sectors: %d\n"
+			       "cluster compressed size: %d\n",
+			       coffset, nb_csectors, csize);
+	}
 
 	ASSERT(len < QCOW_CLUSTER_BUF_LEN);
 
-	return simple_read_from_buffer(buf, size, ppos,
-		qcow_data->dbgfs_file_qcow_cluster_buf, len);
+	return simple_read_from_buffer(buf, size, ppos, qcow_data->dbgfs_file_qcow_cluster_buf, len);
 }
 
-static ssize_t __qcow_file_fmt_dbgfs_ofs_write(struct file *file,
-	const char __user *buf, size_t size, loff_t *ppos)
+static ssize_t __qcow_file_fmt_dbgfs_ofs_write(struct file *file, const char __user *buf, size_t size, loff_t *ppos)
 {
 	struct xloop_file_fmt *xlo_fmt = file->private_data;
 	struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
@@ -384,8 +335,7 @@ static ssize_t __qcow_file_fmt_dbgfs_ofs_write(struct file *file,
 	if (*ppos > QCOW_OFFSET_BUF_LEN || size > QCOW_OFFSET_BUF_LEN)
 		return -EINVAL;
 
-	len = simple_write_to_buffer(qcow_data->dbgfs_file_qcow_offset_buf,
-		QCOW_OFFSET_BUF_LEN, ppos, buf, size);
+	len = simple_write_to_buffer(qcow_data->dbgfs_file_qcow_offset_buf, QCOW_OFFSET_BUF_LEN, ppos, buf, size);
 	if (len < 0)
 		return len;
 
@@ -395,8 +345,7 @@ static ssize_t __qcow_file_fmt_dbgfs_ofs_write(struct file *file,
 	if (ret)
 		return ret;
 
-	ret = kstrtou64(qcow_data->dbgfs_file_qcow_offset_buf, 10,
-		&qcow_data->dbgfs_qcow_offset);
+	ret = kstrtou64(qcow_data->dbgfs_file_qcow_offset_buf, 10, &qcow_data->dbgfs_qcow_offset);
 	if (ret < 0)
 		goto out;
 
@@ -406,11 +355,9 @@ out:
 	return ret;
 }
 
-static const struct file_operations qcow_file_fmt_dbgfs_ofs_fops = {
-	.open = simple_open,
-	.read = __qcow_file_fmt_dbgfs_ofs_read,
-	.write = __qcow_file_fmt_dbgfs_ofs_write
-};
+static const struct file_operations qcow_file_fmt_dbgfs_ofs_fops = { .open = simple_open,
+								     .read = __qcow_file_fmt_dbgfs_ofs_read,
+								     .write = __qcow_file_fmt_dbgfs_ofs_write };
 
 static int __qcow_file_fmt_dbgfs_init(struct xloop_file_fmt *xlo_fmt)
 {
@@ -424,17 +371,15 @@ static int __qcow_file_fmt_dbgfs_init(struct xloop_file_fmt *xlo_fmt)
 		goto out;
 	}
 
-	qcow_data->dbgfs_file_qcow_header = debugfs_create_file("header",
-		S_IRUGO, qcow_data->dbgfs_dir, xlo_fmt,
-		&qcow_file_fmt_dbgfs_hdr_fops);
+	qcow_data->dbgfs_file_qcow_header =
+		debugfs_create_file("header", 0444, qcow_data->dbgfs_dir, xlo_fmt, &qcow_file_fmt_dbgfs_hdr_fops);
 	if (IS_ERR_OR_NULL(qcow_data->dbgfs_file_qcow_header)) {
 		ret = -ENODEV;
 		goto out_free_dbgfs_dir;
 	}
 
-	qcow_data->dbgfs_file_qcow_offset = debugfs_create_file("offset",
-		S_IRUGO | S_IWUSR, qcow_data->dbgfs_dir, xlo_fmt,
-		&qcow_file_fmt_dbgfs_ofs_fops);
+	qcow_data->dbgfs_file_qcow_offset = debugfs_create_file("offset", 0644, qcow_data->dbgfs_dir,
+								xlo_fmt, &qcow_file_fmt_dbgfs_ofs_fops);
 	if (IS_ERR_OR_NULL(qcow_data->dbgfs_file_qcow_offset)) {
 		qcow_data->dbgfs_file_qcow_offset = NULL;
 		ret = -ENODEV;
@@ -460,55 +405,50 @@ static void __qcow_file_fmt_dbgfs_exit(struct xloop_file_fmt *xlo_fmt)
 {
 	struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
 
-	if (qcow_data->dbgfs_file_qcow_offset)
-		debugfs_remove(qcow_data->dbgfs_file_qcow_offset);
+	debugfs_remove(qcow_data->dbgfs_file_qcow_offset);
 
 	mutex_destroy(&qcow_data->dbgfs_qcow_offset_mutex);
 
-	if (qcow_data->dbgfs_file_qcow_header)
-		debugfs_remove(qcow_data->dbgfs_file_qcow_header);
+	debugfs_remove(qcow_data->dbgfs_file_qcow_header);
 
-	if (qcow_data->dbgfs_dir)
-		debugfs_remove(qcow_data->dbgfs_dir);
+	debugfs_remove(qcow_data->dbgfs_dir);
 }
 #endif
 
-static int __qcow_file_fmt_validate_compression_type(
-	struct xloop_file_fmt *xlo_fmt)
+static int __qcow_file_fmt_validate_compression_type(struct xloop_file_fmt *xlo_fmt)
 {
 	struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
 
-    switch (qcow_data->compression_type) {
-    case QCOW_COMPRESSION_TYPE_ZLIB:
+	switch (qcow_data->compression_type) {
+	case QCOW_COMPRESSION_TYPE_ZLIB:
 #ifdef CONFIG_ZSTD_DECOMPRESS
-    case QCOW_COMPRESSION_TYPE_ZSTD:
+	case QCOW_COMPRESSION_TYPE_ZSTD:
 #endif
-        break;
-    default:
-        dev_err(xloop_file_fmt_to_dev(xlo_fmt), "unknown compression type: %u",
-			qcow_data->compression_type);
-        return -ENOTSUPP;
-    }
-
-    /*
-     * if the compression type differs from QCOW_COMPRESSION_TYPE_ZLIB
-     * the incompatible feature flag must be set
-     */
-    if (qcow_data->compression_type == QCOW_COMPRESSION_TYPE_ZLIB) {
-        if (qcow_data->incompatible_features & QCOW_INCOMPAT_COMPRESSION) {
-            dev_err(xloop_file_fmt_to_dev(xlo_fmt), "compression type "
-				"incompatible feature bit must not be set\n");
-            return -EINVAL;
-        }
-    } else {
-        if (!(qcow_data->incompatible_features & QCOW_INCOMPAT_COMPRESSION)) {
-            dev_err(xloop_file_fmt_to_dev(xlo_fmt), "compression type "
-				"incompatible feature bit must be set\n");
-            return -EINVAL;
-        }
-    }
-
-    return 0;
+		break;
+	default:
+		dev_err(xloop_file_fmt_to_dev(xlo_fmt), "unknown compression type: %u", qcow_data->compression_type);
+		return -ENOTSUPP;
+	}
+
+	/*
+	 * if the compression type differs from QCOW_COMPRESSION_TYPE_ZLIB
+	 * the incompatible feature flag must be set
+	 */
+	if (qcow_data->compression_type == QCOW_COMPRESSION_TYPE_ZLIB) {
+		if (qcow_data->incompatible_features & QCOW_INCOMPAT_COMPRESSION) {
+			dev_err(xloop_file_fmt_to_dev(xlo_fmt),
+				"compression type incompatible feature bit must not be set\n");
+			return -EINVAL;
+		}
+	} else {
+		if (!(qcow_data->incompatible_features & QCOW_INCOMPAT_COMPRESSION)) {
+			dev_err(xloop_file_fmt_to_dev(xlo_fmt),
+				"compression type incompatible feature bit must be set\n");
+			return -EINVAL;
+		}
+	}
+
+	return 0;
 }
 
 static int qcow_file_fmt_init(struct xloop_file_fmt *xlo_fmt)
@@ -539,8 +479,10 @@ static int qcow_file_fmt_init(struct xloop_file_fmt *xlo_fmt)
 	if (ret)
 		goto free_qcow_data;
 
-	/* save information of the header fields in human readable format in
-	 * a file buffer to access it with debugfs */
+	/*
+	 * save information of the header fields in human readable format in
+	 * a file buffer to access it with debugfs
+	 */
 #ifdef CONFIG_DEBUG_FS
 	__qcow_file_fmt_header_to_buf(xlo_fmt, &header);
 #endif
@@ -548,10 +490,8 @@ static int qcow_file_fmt_init(struct xloop_file_fmt *xlo_fmt)
 	qcow_data->qcow_version = header.version;
 
 	/* Initialise cluster size */
-	if (header.cluster_bits < QCOW_MIN_CLUSTER_BITS
-		|| header.cluster_bits > QCOW_MAX_CLUSTER_BITS) {
-		dev_err(xloop_file_fmt_to_dev(xlo_fmt), "unsupported cluster size: "
-			"2^%d\n", header.cluster_bits);
+	if (header.cluster_bits < QCOW_MIN_CLUSTER_BITS || header.cluster_bits > QCOW_MAX_CLUSTER_BITS) {
+		dev_err(xloop_file_fmt_to_dev(xlo_fmt), "unsupported cluster size: 2^%d\n", header.cluster_bits);
 		ret = -EINVAL;
 		goto free_qcow_data;
 	}
@@ -560,22 +500,19 @@ static int qcow_file_fmt_init(struct xloop_file_fmt *xlo_fmt)
 	qcow_data->cluster_size = 1 << qcow_data->cluster_bits;
 
 	if (header.header_length > qcow_data->cluster_size) {
-		dev_err(xloop_file_fmt_to_dev(xlo_fmt), "QCOW header exceeds cluster "
-			"size\n");
+		dev_err(xloop_file_fmt_to_dev(xlo_fmt), "QCOW header exceeds cluster size\n");
 		ret = -EINVAL;
 		goto free_qcow_data;
 	}
 
 	if (header.backing_file_offset > qcow_data->cluster_size) {
-		dev_err(xloop_file_fmt_to_dev(xlo_fmt), "invalid backing file "
-			"offset\n");
+		dev_err(xloop_file_fmt_to_dev(xlo_fmt), "invalid backing file offset\n");
 		ret = -EINVAL;
 		goto free_qcow_data;
 	}
 
 	if (header.backing_file_offset) {
-		dev_err(xloop_file_fmt_to_dev(xlo_fmt), "backing file support not "
-			"available\n");
+		dev_err(xloop_file_fmt_to_dev(xlo_fmt), "backing file support not available\n");
 		ret = -ENOTSUPP;
 		goto free_qcow_data;
 	}
@@ -585,69 +522,61 @@ static int qcow_file_fmt_init(struct xloop_file_fmt *xlo_fmt)
 	qcow_data->compatible_features = header.compatible_features;
 	qcow_data->autoclear_features = header.autoclear_features;
 
-    /*
-     * Handle compression type
-     * Older qcow2 images don't contain the compression type header.
-     * Distinguish them by the header length and use
-     * the only valid (default) compression type in that case
-     */
-    if (header.header_length > offsetof(struct xloop_file_fmt_qcow_header,
-		compression_type)) {
-        qcow_data->compression_type = header.compression_type;
-    } else {
-        qcow_data->compression_type = QCOW_COMPRESSION_TYPE_ZLIB;
-    }
-
-    ret = __qcow_file_fmt_validate_compression_type(xlo_fmt);
-    if (ret) {
-        goto free_qcow_data;
-    }
+	/*
+	 * Handle compression type
+	 * Older qcow2 images don't contain the compression type header.
+	 * Distinguish them by the header length and use
+	 * the only valid (default) compression type in that case
+	 */
+	if (header.header_length > offsetof(struct xloop_file_fmt_qcow_header, compression_type))
+		qcow_data->compression_type = header.compression_type;
+	else
+		qcow_data->compression_type = QCOW_COMPRESSION_TYPE_ZLIB;
+
+	ret = __qcow_file_fmt_validate_compression_type(xlo_fmt);
+	if (ret)
+		goto free_qcow_data;
 
 	/* check for incompatible features */
 	if (qcow_data->incompatible_features & QCOW_INCOMPAT_DIRTY) {
-		dev_err(xloop_file_fmt_to_dev(xlo_fmt), "image contains inconsistent "
-			"refcounts\n");
+		dev_err(xloop_file_fmt_to_dev(xlo_fmt), "image contains inconsistent refcounts\n");
 		ret = -EACCES;
 		goto free_qcow_data;
 	}
 
 	if (qcow_data->incompatible_features & QCOW_INCOMPAT_CORRUPT) {
-		dev_err(xloop_file_fmt_to_dev(xlo_fmt), "image is corrupt; cannot be "
-			"opened read/write\n");
+		dev_err(xloop_file_fmt_to_dev(xlo_fmt), "image is corrupt; cannot be opened read/write\n");
 		ret = -EACCES;
 		goto free_qcow_data;
 	}
 
 	if (qcow_data->incompatible_features & QCOW_INCOMPAT_DATA_FILE) {
-		dev_err(xloop_file_fmt_to_dev(xlo_fmt), "data-file is required for "
-			"this image\n");
+		dev_err(xloop_file_fmt_to_dev(xlo_fmt), "data-file is required for this image\n");
 		ret = -EINVAL;
 		goto free_qcow_data;
 	}
 
 	qcow_data->subclusters_per_cluster =
-		xloop_file_fmt_qcow_has_subclusters(qcow_data) ? 
-		QCOW_EXTL2_SUBCLUSTERS_PER_CLUSTER : 1;
-    qcow_data->subcluster_size = 
-		qcow_data->cluster_size / qcow_data->subclusters_per_cluster;
-	/* 
+		xloop_file_fmt_qcow_has_subclusters(qcow_data) ? QCOW_EXTL2_SUBCLUSTERS_PER_CLUSTER : 1;
+	qcow_data->subcluster_size = qcow_data->cluster_size / qcow_data->subclusters_per_cluster;
+	/*
 	 * check if subcluster_size is non-zero to avoid unknown results of
 	 * __builtin_ctz
 	 */
 	ASSERT(qcow_data->subcluster_size != 0);
-    qcow_data->subcluster_bits = __builtin_ctz(qcow_data->subcluster_size);
+	qcow_data->subcluster_bits = __builtin_ctz(qcow_data->subcluster_size);
 
-    if (qcow_data->subcluster_size < (1 << QCOW_MIN_CLUSTER_BITS)) {
-        dev_err(xloop_file_fmt_to_dev(xlo_fmt), "unsupported subcluster "
-			"size: %d\n", qcow_data->subcluster_size);
-        ret = -EINVAL;
-        goto free_qcow_data;
-    }
+	if (qcow_data->subcluster_size < (1 << QCOW_MIN_CLUSTER_BITS)) {
+		dev_err(xloop_file_fmt_to_dev(xlo_fmt), "unsupported subcluster size: %d\n",
+			qcow_data->subcluster_size);
+		ret = -EINVAL;
+		goto free_qcow_data;
+	}
 
 	/* Check support for various header values */
 	if (header.refcount_order > 6) {
-		dev_err(xloop_file_fmt_to_dev(xlo_fmt), "reference count entry width "
-			"too large; may not exceed 64 bits\n");
+		dev_err(xloop_file_fmt_to_dev(xlo_fmt),
+			"reference count entry width too large; may not exceed 64 bits\n");
 		ret = -EINVAL;
 		goto free_qcow_data;
 	}
@@ -658,23 +587,20 @@ static int qcow_file_fmt_init(struct xloop_file_fmt *xlo_fmt)
 
 	qcow_data->crypt_method_header = header.crypt_method;
 	if (qcow_data->crypt_method_header) {
-		dev_err(xloop_file_fmt_to_dev(xlo_fmt), "encryption support not "
-			"available\n");
+		dev_err(xloop_file_fmt_to_dev(xlo_fmt), "encryption support not available\n");
 		ret = -ENOTSUPP;
 		goto free_qcow_data;
 	}
 
-	/* 
+	/*
 	 * check if xloop_file_fmt_qcow_l2_entry_size(qcow_data) is non-zero to
 	 * avoid unknown results of __builtin_ctz
 	 */
 	ASSERT(xloop_file_fmt_qcow_l2_entry_size(qcow_data) != 0);
-	qcow_data->l2_bits = qcow_data->cluster_bits - 
-		__builtin_ctz(xloop_file_fmt_qcow_l2_entry_size(qcow_data));
+	qcow_data->l2_bits = qcow_data->cluster_bits - __builtin_ctz(xloop_file_fmt_qcow_l2_entry_size(qcow_data));
 	qcow_data->l2_size = 1 << qcow_data->l2_bits;
 	/* 2^(qcow_data->refcount_order - 3) is the refcount width in bytes */
-	qcow_data->refcount_block_bits = qcow_data->cluster_bits -
-		(qcow_data->refcount_order - 3);
+	qcow_data->refcount_block_bits = qcow_data->cluster_bits - (qcow_data->refcount_order - 3);
 	qcow_data->refcount_block_size = 1 << qcow_data->refcount_block_bits;
 	qcow_data->size = header.size;
 	qcow_data->csize_shift = (62 - (qcow_data->cluster_bits - 8));
@@ -682,49 +608,42 @@ static int qcow_file_fmt_init(struct xloop_file_fmt *xlo_fmt)
 	qcow_data->cluster_offset_mask = (1LL << qcow_data->csize_shift) - 1;
 
 	qcow_data->refcount_table_offset = header.refcount_table_offset;
-	qcow_data->refcount_table_size = header.refcount_table_clusters <<
-		(qcow_data->cluster_bits - 3);
+	qcow_data->refcount_table_size = header.refcount_table_clusters << (qcow_data->cluster_bits - 3);
 
 	if (header.refcount_table_clusters == 0) {
-		dev_err(xloop_file_fmt_to_dev(xlo_fmt), "image does not contain a "
-			"reference count table\n");
+		dev_err(xloop_file_fmt_to_dev(xlo_fmt), "image does not contain a reference count table\n");
 		ret = -EINVAL;
 		goto free_qcow_data;
 	}
 
-	ret = __qcow_file_fmt_validate_table(xlo_fmt,
-		qcow_data->refcount_table_offset,
-		header.refcount_table_clusters, qcow_data->cluster_size,
-		QCOW_MAX_REFTABLE_SIZE, "Reference count table");
-	if (ret < 0) {
+	ret = __qcow_file_fmt_validate_table(xlo_fmt, qcow_data->refcount_table_offset, header.refcount_table_clusters,
+					     qcow_data->cluster_size, QCOW_MAX_REFTABLE_SIZE, "Reference count table");
+	if (ret < 0)
 		goto free_qcow_data;
-	}
 
-	/* The total size in bytes of the snapshot table is checked in
+	/*
+	 * The total size in bytes of the snapshot table is checked in
 	 * qcow2_read_snapshots() because the size of each snapshot is
 	 * variable and we don't know it yet.
-	 * Here we only check the offset and number of snapshots. */
-	ret = __qcow_file_fmt_validate_table(xlo_fmt, header.snapshots_offset,
-		header.nb_snapshots,
-		sizeof(struct xloop_file_fmt_qcow_snapshot_header),
-		sizeof(struct xloop_file_fmt_qcow_snapshot_header) *
-		QCOW_MAX_SNAPSHOTS, "Snapshot table");
-	if (ret < 0) {
+	 * Here we only check the offset and number of snapshots.
+	 */
+	ret = __qcow_file_fmt_validate_table(xlo_fmt, header.snapshots_offset, header.nb_snapshots,
+					     sizeof(struct xloop_file_fmt_qcow_snapshot_header),
+					     sizeof(struct xloop_file_fmt_qcow_snapshot_header) * QCOW_MAX_SNAPSHOTS,
+					     "Snapshot table");
+	if (ret < 0)
 		goto free_qcow_data;
-	}
 
 	/* read the level 1 table */
-	ret = __qcow_file_fmt_validate_table(xlo_fmt, header.l1_table_offset,
-		header.l1_size, QCOW_L1E_SIZE, QCOW_MAX_L1_SIZE,
-		"Active L1 table");
-	if (ret < 0) {
+	ret = __qcow_file_fmt_validate_table(xlo_fmt, header.l1_table_offset, header.l1_size, QCOW_L1E_SIZE,
+					     QCOW_MAX_L1_SIZE, "Active L1 table");
+	if (ret < 0)
 		goto free_qcow_data;
-	}
+
 	qcow_data->l1_size = header.l1_size;
 	qcow_data->l1_table_offset = header.l1_table_offset;
 
-	l1_vm_state_index = xloop_file_fmt_qcow_size_to_l1(qcow_data,
-		header.size);
+	l1_vm_state_index = xloop_file_fmt_qcow_size_to_l1(qcow_data, header.size);
 	if (l1_vm_state_index > INT_MAX) {
 		dev_err(xloop_file_fmt_to_dev(xlo_fmt), "image is too big\n");
 		ret = -EFBIG;
@@ -732,8 +651,7 @@ static int qcow_file_fmt_init(struct xloop_file_fmt *xlo_fmt)
 	}
 	qcow_data->l1_vm_state_index = l1_vm_state_index;
 
-	/* the L1 table must contain at least enough entries to put header.size
-	 * bytes */
+	/* the L1 table must contain at least enough entries to put header.size bytes */
 	if (qcow_data->l1_size < qcow_data->l1_vm_state_index) {
 		dev_err(xloop_file_fmt_to_dev(xlo_fmt), "L1 table is too small\n");
 		ret = -EINVAL;
@@ -741,27 +659,20 @@ static int qcow_file_fmt_init(struct xloop_file_fmt *xlo_fmt)
 	}
 
 	if (qcow_data->l1_size > 0) {
-		qcow_data->l1_table = vzalloc(round_up(qcow_data->l1_size *
-			QCOW_L1E_SIZE, 512));
+		qcow_data->l1_table = vzalloc(round_up(qcow_data->l1_size * QCOW_L1E_SIZE, 512));
 		if (qcow_data->l1_table == NULL) {
-			dev_err(xloop_file_fmt_to_dev(xlo_fmt), "could not allocate "
-				"L1 table\n");
 			ret = -ENOMEM;
 			goto free_qcow_data;
 		}
-		len = kernel_read(xlo->xlo_backing_file, qcow_data->l1_table,
-			qcow_data->l1_size * QCOW_L1E_SIZE,
-			&qcow_data->l1_table_offset);
+		len = kernel_read(xlo->xlo_backing_file, qcow_data->l1_table, qcow_data->l1_size * QCOW_L1E_SIZE,
+				  &qcow_data->l1_table_offset);
 		if (len < 0) {
-			dev_err(xloop_file_fmt_to_dev(xlo_fmt), "could not read "
-				"L1 table\n");
+			dev_err(xloop_file_fmt_to_dev(xlo_fmt), "could not read L1 table\n");
 			ret = len;
 			goto free_l1_table;
 		}
-		for (i = 0; i < qcow_data->l1_size; i++) {
-			qcow_data->l1_table[i] =
-				be64_to_cpu(qcow_data->l1_table[i]);
-		}
+		for (i = 0; i < qcow_data->l1_size; i++)
+			qcow_data->l1_table[i] = be64_to_cpu(qcow_data->l1_table[i]);
 	}
 
 	/* Internal snapshots */
@@ -769,8 +680,7 @@ static int qcow_file_fmt_init(struct xloop_file_fmt *xlo_fmt)
 	qcow_data->nb_snapshots = header.nb_snapshots;
 
 	if (qcow_data->nb_snapshots > 0) {
-		dev_err(xloop_file_fmt_to_dev(xlo_fmt), "snapshots support not "
-			"available\n");
+		dev_err(xloop_file_fmt_to_dev(xlo_fmt), "snapshots support not available\n");
 		ret = -ENOTSUPP;
 		goto free_l1_table;
 	}
@@ -778,9 +688,7 @@ static int qcow_file_fmt_init(struct xloop_file_fmt *xlo_fmt)
 	/* create cache for L2 */
 	virtual_disk_size = qcow_data->size;
 	max_l2_entries = DIV64_U64_ROUND_UP(virtual_disk_size, qcow_data->cluster_size);
-	max_l2_cache = round_up(
-		max_l2_entries * xloop_file_fmt_qcow_l2_entry_size(qcow_data), 
-		qcow_data->cluster_size);
+	max_l2_cache = round_up(max_l2_entries * xloop_file_fmt_qcow_l2_entry_size(qcow_data), qcow_data->cluster_size);
 
 	/* define the maximum L2 cache size */
 	l2_cache_max_setting = QCOW_DEFAULT_L2_CACHE_MAX_SIZE;
@@ -789,13 +697,12 @@ static int qcow_file_fmt_init(struct xloop_file_fmt *xlo_fmt)
 	l2_cache_size = min(max_l2_cache, l2_cache_max_setting);
 
 	/* determine the size of a cache entry */
-	l2_cache_entry_size = min(qcow_data->cluster_size, (int)PAGE_SIZE);
+	l2_cache_entry_size = min_t(int, qcow_data->cluster_size, PAGE_SIZE);
 
 	/* calculate the number of cache tables */
 	l2_cache_size = div_u64(l2_cache_size, l2_cache_entry_size);
-	if (l2_cache_size < QCOW_MIN_L2_CACHE_SIZE) {
+	if (l2_cache_size < QCOW_MIN_L2_CACHE_SIZE)
 		l2_cache_size = QCOW_MIN_L2_CACHE_SIZE;
-	}
 
 	if (l2_cache_size > INT_MAX) {
 		dev_err(xloop_file_fmt_to_dev(xlo_fmt), "L2 cache size too big\n");
@@ -803,11 +710,9 @@ static int qcow_file_fmt_init(struct xloop_file_fmt *xlo_fmt)
 		goto free_l1_table;
 	}
 
-	qcow_data->l2_slice_size = div_u64(l2_cache_entry_size,
-		xloop_file_fmt_qcow_l2_entry_size(qcow_data));
+	qcow_data->l2_slice_size = div_u64(l2_cache_entry_size, xloop_file_fmt_qcow_l2_entry_size(qcow_data));
 
-	qcow_data->l2_table_cache = xloop_file_fmt_qcow_cache_create(xlo_fmt,
-		l2_cache_size, l2_cache_entry_size);
+	qcow_data->l2_table_cache = xloop_file_fmt_qcow_cache_create(xlo_fmt, l2_cache_size, l2_cache_entry_size);
 	if (!qcow_data->l2_table_cache) {
 		ret = -ENOMEM;
 		goto free_l1_table;
@@ -847,18 +752,14 @@ static void qcow_file_fmt_exit(struct xloop_file_fmt *xlo_fmt)
 
 	__qcow_file_fmt_compression_exit(xlo_fmt);
 
-	if (qcow_data->l1_table) {
+	if (qcow_data->l1_table)
 		vfree(qcow_data->l1_table);
-	}
 
-	if (qcow_data->l2_table_cache) {
+	if (qcow_data->l2_table_cache)
 		xloop_file_fmt_qcow_cache_destroy(xlo_fmt);
-	}
 
-	if (qcow_data) {
-		kfree(qcow_data);
-		xlo_fmt->private_data = NULL;
-	}
+	kfree(qcow_data);
+	xlo_fmt->private_data = NULL;
 }
 
 /*
@@ -874,11 +775,8 @@ static void qcow_file_fmt_exit(struct xloop_file_fmt *xlo_fmt)
  * Returns: 0 on success
  *          -EIO on fail
  */
-static ssize_t __qcow_file_fmt_zlib_decompress(struct xloop_file_fmt *xlo_fmt,
-						 void *dest,
-						 size_t dest_size,
-						 const void *src,
-						 size_t src_size)
+static ssize_t __qcow_file_fmt_zlib_decompress(struct xloop_file_fmt *xlo_fmt, void *dest, size_t dest_size,
+					       const void *src, size_t src_size)
 {
 	struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
 	u8 zerostuff = 0;
@@ -901,8 +799,7 @@ static ssize_t __qcow_file_fmt_zlib_decompress(struct xloop_file_fmt *xlo_fmt,
 	 * byte when being used in the (undocumented) raw deflate mode.
 	 * (From USAGI).
 	 */
-	if (ret == Z_OK && !qcow_data->zlib_dstrm->avail_in && 
-			qcow_data->zlib_dstrm->avail_out) {
+	if (ret == Z_OK && !qcow_data->zlib_dstrm->avail_in && qcow_data->zlib_dstrm->avail_out) {
 		qcow_data->zlib_dstrm->next_in = &zerostuff;
 		qcow_data->zlib_dstrm->avail_in = 1;
 		ret = zlib_inflate(qcow_data->zlib_dstrm, Z_FINISH);
@@ -930,83 +827,71 @@ out:
  * Returns: 0 on success
  *          -EIO on any error
  */
-static ssize_t __qcow_file_fmt_zstd_decompress(struct xloop_file_fmt *xlo_fmt,
-						 void *dest,
-						 size_t dest_size,
-						 const void *src,
-						 size_t src_size)
+static ssize_t __qcow_file_fmt_zstd_decompress(struct xloop_file_fmt *xlo_fmt, void *dest, size_t dest_size,
+					       const void *src, size_t src_size)
 {
 	struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
 	size_t zstd_ret = 0;
-    ssize_t ret = 0;
+	ssize_t ret = 0;
 
-    ZSTD_outBuffer output = {
-        .dst = dest,
-        .size = dest_size,
-        .pos = 0
-    };
+	ZSTD_outBuffer output = { .dst = dest, .size = dest_size, .pos = 0 };
 
-    ZSTD_inBuffer input = {
-        .src = src,
-        .size = src_size,
-        .pos = 0
-    };
+	ZSTD_inBuffer input = { .src = src, .size = src_size, .pos = 0 };
 
 	zstd_ret = ZSTD_resetDStream(qcow_data->zstd_dstrm);
 
-    if (ZSTD_isError(zstd_ret)) {
-        ret = -EIO;
+	if (ZSTD_isError(zstd_ret)) {
+		ret = -EIO;
 		goto out;
-    }
+	}
+
+	/*
+	 * The compressed stream from the input buffer may consist of more
+	 * than one zstd frame. So we iterate until we get a fully
+	 * uncompressed cluster.
+	 * From zstd docs related to ZSTD_decompressStream:
+	 * "return : 0 when a frame is completely decoded and fully flushed"
+	 * We suppose that this means: each time ZSTD_decompressStream reads
+	 * only ONE full frame and returns 0 if and only if that frame
+	 * is completely decoded and flushed. Only after returning 0,
+	 * ZSTD_decompressStream reads another ONE full frame.
+	 */
+	while (output.pos < output.size) {
+		size_t last_in_pos = input.pos;
+		size_t last_out_pos = output.pos;
+
+		zstd_ret = ZSTD_decompressStream(qcow_data->zstd_dstrm, &output, &input);
 
+		if (ZSTD_isError(zstd_ret)) {
+			ret = -EIO;
+			break;
+		}
+
+	/*
+	 * The ZSTD manual is vague about what to do if it reads
+	 * the buffer partially, and we don't want to get stuck
+	 * in an infinite loop where ZSTD_decompressStream
+	 * returns > 0 waiting for another input chunk. So, we add
+	 * a check which ensures that the loop makes some progress
+	 * on each step.
+	 */
+		if (last_in_pos >= input.pos && last_out_pos >= output.pos) {
+			ret = -EIO;
+			break;
+		}
+	}
 	/*
-     * The compressed stream from the input buffer may consist of more
-     * than one zstd frame. So we iterate until we get a fully
-     * uncompressed cluster.
-     * From zstd docs related to ZSTD_decompressStream:
-     * "return : 0 when a frame is completely decoded and fully flushed"
-     * We suppose that this means: each time ZSTD_decompressStream reads
-     * only ONE full frame and returns 0 if and only if that frame
-     * is completely decoded and flushed. Only after returning 0,
-     * ZSTD_decompressStream reads another ONE full frame.
-     */
-    while (output.pos < output.size) {
-        size_t last_in_pos = input.pos;
-        size_t last_out_pos = output.pos;
-        zstd_ret = ZSTD_decompressStream(qcow_data->zstd_dstrm, &output, &input);
-
-        if (ZSTD_isError(zstd_ret)) {
-            ret = -EIO;
-            break;
-        }
-
-        /*
-         * The ZSTD manual is vague about what to do if it reads
-         * the buffer partially, and we don't want to get stuck
-         * in an infinite loop where ZSTD_decompressStream
-         * returns > 0 waiting for another input chunk. So, we add
-         * a check which ensures that the loop makes some progress
-         * on each step.
-         */
-        if (last_in_pos >= input.pos &&
-            last_out_pos >= output.pos) {
-            ret = -EIO;
-            break;
-        }
-    }
-    /*
-     * Make sure that we have the frame fully flushed here
-     * if not, we somehow managed to get uncompressed cluster
-     * greater then the cluster size, possibly because of its
-     * damage.
-     */
-    if (zstd_ret > 0) {
-        ret = -EIO;
-    }
+	 * Make sure that we have the frame fully flushed here
+	 * if not, we somehow managed to get uncompressed cluster
+	 * greater then the cluster size, possibly because of its
+	 * damage.
+	 */
+	if (zstd_ret > 0)
+		ret = -EIO;
 
 out:
-    ASSERT(ret == 0 || ret == -EIO);
-    return ret;
+	ASSERT(ret == 0 || ret == -EIO);
+	return ret;
 }
 #endif
 
@@ -1023,39 +908,31 @@ out:
  * Returns: compressed size on success
  *          a negative error code on failure
  */
-static ssize_t __qcow_file_fmt_buffer_decompress(struct xloop_file_fmt *xlo_fmt,
-						 void *dest,
-						 size_t dest_size,
-						 const void *src,
-						 size_t src_size)
+static ssize_t __qcow_file_fmt_buffer_decompress(struct xloop_file_fmt *xlo_fmt, void *dest, size_t dest_size,
+						 const void *src, size_t src_size)
 {
-    struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
-    qcow_file_fmt_decompress_fn decompress_fn;
+	struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
+	qcow_file_fmt_decompress_fn decompress_fn;
 
-    switch (qcow_data->compression_type) {
-    case QCOW_COMPRESSION_TYPE_ZLIB:
-        decompress_fn = __qcow_file_fmt_zlib_decompress;
-        break;
+	switch (qcow_data->compression_type) {
+	case QCOW_COMPRESSION_TYPE_ZLIB:
+		decompress_fn = __qcow_file_fmt_zlib_decompress;
+		break;
 
 #ifdef CONFIG_ZSTD_DECOMPRESS
-    case QCOW_COMPRESSION_TYPE_ZSTD:
-        decompress_fn = __qcow_file_fmt_zstd_decompress;
-        break;
+	case QCOW_COMPRESSION_TYPE_ZSTD:
+		decompress_fn = __qcow_file_fmt_zstd_decompress;
+		break;
 #endif
-    default:
-        return -EINVAL;
-    }
+	default:
+		return -EINVAL;
+	}
 
-    return decompress_fn(xlo_fmt, dest, dest_size, src, src_size);
+	return decompress_fn(xlo_fmt, dest, dest_size, src, src_size);
 }
 
-
-static int __qcow_file_fmt_read_compressed(struct xloop_file_fmt *xlo_fmt,
-					   struct bio_vec *bvec,
-					   u64 file_cluster_offset,
-					   u64 offset,
-					   u64 bytes,
-					   u64 bytes_done)
+static int __qcow_file_fmt_read_compressed(struct xloop_file_fmt *xlo_fmt, struct bio_vec *bvec,
+					   u64 file_cluster_offset, u64 offset, u64 bytes, u64 bytes_done)
 {
 	struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
 	struct xloop_device *xlo = xloop_file_fmt_get_xlo(xlo_fmt);
@@ -1065,15 +942,11 @@ static int __qcow_file_fmt_read_compressed(struct xloop_file_fmt *xlo_fmt,
 	ssize_t len;
 	void *data;
 	unsigned long irq_flags;
-	int offset_in_cluster = xloop_file_fmt_qcow_offset_into_cluster(
-		qcow_data, offset);
+	int offset_in_cluster = xloop_file_fmt_qcow_offset_into_cluster(qcow_data, offset);
 
 	coffset = file_cluster_offset & qcow_data->cluster_offset_mask;
-	nb_csectors = ((file_cluster_offset >> qcow_data->csize_shift) &
-		qcow_data->csize_mask) + 1;
-	csize = nb_csectors * QCOW_COMPRESSED_SECTOR_SIZE -
-		(coffset & ~QCOW_COMPRESSED_SECTOR_MASK);
-
+	nb_csectors = ((file_cluster_offset >> qcow_data->csize_shift) & qcow_data->csize_mask) + 1;
+	csize = nb_csectors * QCOW_COMPRESSED_SECTOR_SIZE - (coffset & ~QCOW_COMPRESSED_SECTOR_MASK);
 
 	if (qcow_data->cmp_last_coffset != coffset) {
 		in_buf = vmalloc(csize);
@@ -1089,8 +962,8 @@ static int __qcow_file_fmt_read_compressed(struct xloop_file_fmt *xlo_fmt,
 			goto out_free_in_buf;
 		}
 
-		if (__qcow_file_fmt_buffer_decompress(xlo_fmt, qcow_data->cmp_out_buf,
-			qcow_data->cluster_size, in_buf, csize) < 0) {
+		if (__qcow_file_fmt_buffer_decompress(xlo_fmt, qcow_data->cmp_out_buf, qcow_data->cluster_size, in_buf,
+						      csize) < 0) {
 			qcow_data->cmp_last_coffset = ULLONG_MAX;
 			ret = -EIO;
 			goto out_free_in_buf;
@@ -1109,9 +982,7 @@ out_free_in_buf:
 	return ret;
 }
 
-static int __qcow_file_fmt_read_bvec(struct xloop_file_fmt *xlo_fmt,
-				     struct bio_vec *bvec,
-				     loff_t *ppos)
+static int __qcow_file_fmt_read_bvec(struct xloop_file_fmt *xlo_fmt, struct bio_vec *bvec, loff_t *ppos)
 {
 	struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
 	struct xloop_device *xlo = xloop_file_fmt_get_xlo(xlo_fmt);
@@ -1130,18 +1001,14 @@ static int __qcow_file_fmt_read_bvec(struct xloop_file_fmt *xlo_fmt,
 	bytes = bvec->bv_len;
 
 	while (bytes != 0) {
-
 		/* prepare next request */
 		cur_bytes = bytes;
 
-		ret = xloop_file_fmt_qcow_get_host_offset(xlo_fmt, *ppos,
-			&cur_bytes, &host_offset, &type);
-		if (ret < 0) {
+		ret = xloop_file_fmt_qcow_get_host_offset(xlo_fmt, *ppos, &cur_bytes, &host_offset, &type);
+		if (ret < 0)
 			goto fail;
-		}
 
-		offset_in_cluster = xloop_file_fmt_qcow_offset_into_cluster(
-			qcow_data, *ppos);
+		offset_in_cluster = xloop_file_fmt_qcow_offset_into_cluster(qcow_data, *ppos);
 
 		switch (type) {
 		case QCOW_SUBCLUSTER_ZERO_PLAIN:
@@ -1155,11 +1022,9 @@ static int __qcow_file_fmt_read_bvec(struct xloop_file_fmt *xlo_fmt,
 			break;
 
 		case QCOW_SUBCLUSTER_COMPRESSED:
-			ret = __qcow_file_fmt_read_compressed(xlo_fmt, bvec,
-				host_offset, *ppos, cur_bytes, bytes_done);
-			if (ret < 0) {
+			ret = __qcow_file_fmt_read_compressed(xlo_fmt, bvec, host_offset, *ppos, cur_bytes, bytes_done);
+			if (ret < 0)
 				goto fail;
-			}
 
 			break;
 
@@ -1167,8 +1032,7 @@ static int __qcow_file_fmt_read_bvec(struct xloop_file_fmt *xlo_fmt,
 			pos_read = host_offset;
 
 			data = bvec_kmap_irq(bvec, &irq_flags) + bytes_done;
-			len = kernel_read(xlo->xlo_backing_file, data, cur_bytes,
-				&pos_read);
+			len = kernel_read(xlo->xlo_backing_file, data, cur_bytes, &pos_read);
 			flush_dcache_page(bvec->bv_page);
 			bvec_kunmap_irq(data, &irq_flags);
 
@@ -1194,8 +1058,7 @@ fail:
 	return ret;
 }
 
-static int qcow_file_fmt_read(struct xloop_file_fmt *xlo_fmt,
-			      struct request *rq)
+static int qcow_file_fmt_read(struct xloop_file_fmt *xlo_fmt, struct request *rq)
 {
 	struct bio_vec bvec;
 	struct req_iterator iter;
@@ -1215,8 +1078,8 @@ static int qcow_file_fmt_read(struct xloop_file_fmt *xlo_fmt,
 	return ret;
 }
 
-static loff_t qcow_file_fmt_sector_size(struct xloop_file_fmt *xlo_fmt,
-				struct file *file, loff_t offset, loff_t sizelimit)
+static loff_t qcow_file_fmt_sector_size(struct xloop_file_fmt *xlo_fmt, struct file *file, loff_t offset,
+					loff_t sizelimit)
 {
 	struct xloop_file_fmt_qcow_header header;
 	loff_t xloopsize;
@@ -1245,23 +1108,23 @@ static loff_t qcow_file_fmt_sector_size(struct xloop_file_fmt *xlo_fmt,
 }
 
 static struct xloop_file_fmt_ops qcow_file_fmt_ops = {
-	.init = qcow_file_fmt_init,
-	.exit = qcow_file_fmt_exit,
-	.read = qcow_file_fmt_read,
-	.write = NULL,
-	.read_aio = NULL,
-	.write_aio = NULL,
+	.init        = qcow_file_fmt_init,
+	.exit        = qcow_file_fmt_exit,
+	.read        = qcow_file_fmt_read,
+	.write       = NULL,
+	.read_aio    = NULL,
+	.write_aio   = NULL,
 	.write_zeros = NULL,
-	.discard = NULL,
-	.flush = NULL,
+	.discard     = NULL,
+	.flush       = NULL,
 	.sector_size = qcow_file_fmt_sector_size,
 };
 
 static struct xloop_file_fmt_driver qcow_file_fmt_driver = {
-	.name = "QCOW",
+	.name          = "QCOW",
 	.file_fmt_type = XLO_FILE_FMT_QCOW,
-	.ops = &qcow_file_fmt_ops,
-	.owner = THIS_MODULE,
+	.ops           = &qcow_file_fmt_ops,
+	.owner         = THIS_MODULE,
 };
 
 static int __init xloop_file_fmt_qcow_init(void)
diff --git a/src/kernel/xloop_file_fmt_qcow_main.h b/src/kernel/xloop_file_fmt_qcow_main.h
index 023c679..4556e3c 100644
--- a/src/kernel/xloop_file_fmt_qcow_main.h
+++ b/src/kernel/xloop_file_fmt_qcow_main.h
@@ -30,16 +30,17 @@
 #include "xloop_file_fmt.h"
 
 #ifdef CONFIG_DEBUG_DRIVER
-#define ASSERT(x)  							\
-do {									\
-	if (!(x)) {							\
-		printk(KERN_EMERG "assertion failed %s: %d: %s\n",	\
-		       __FILE__, __LINE__, #x);				\
-		BUG();							\
-	}								\
-} while (0)
+#define ASSERT(x)                                                                                                      \
+	do {                                                                                                           \
+		if (!(x)) {                                                                                            \
+			printk(KERN_EMERG "assertion failed %s: %d: %s\n", __FILE__, __LINE__, #x);                    \
+			BUG();                                                                                         \
+		}                                                                                                      \
+	} while (0)
 #else
-#define ASSERT(x) do { } while (0)
+#define ASSERT(x)                                                                                                      \
+	do {                                                                                                           \
+	} while (0)
 #endif
 
 #define KiB (1024)
@@ -48,28 +49,36 @@ do {									\
 #define QCOW_MAGIC (('Q' << 24) | ('F' << 16) | ('I' << 8) | 0xfb)
 
 #define QCOW_CRYPT_NONE 0
-#define QCOW_CRYPT_AES  1
+#define QCOW_CRYPT_AES 1
 #define QCOW_CRYPT_LUKS 2
 
 #define QCOW_MAX_CRYPT_CLUSTERS 32
 #define QCOW_MAX_SNAPSHOTS 65536
 
-/* Field widths in QCOW mean normal cluster offsets cannot reach
+/*
+ * Field widths in QCOW mean normal cluster offsets cannot reach
  * 64PB; depending on cluster size, compressed clusters can have a
  * smaller limit (64PB for up to 16k clusters, then ramps down to
- * 512TB for 2M clusters).  */
+ * 512TB for 2M clusters).
+ */
 #define QCOW_MAX_CLUSTER_OFFSET ((1ULL << 56) - 1)
 
-/* 8 MB refcount table is enough for 2 PB images at 64k cluster size
- * (128 GB for 512 byte clusters, 2 EB for 2 MB clusters) */
+/*
+ * 8 MB refcount table is enough for 2 PB images at 64k cluster size
+ * (128 GB for 512 byte clusters, 2 EB for 2 MB clusters)
+ */
 #define QCOW_MAX_REFTABLE_SIZE (8 * MiB)
 
-/* 32 MB L1 table is enough for 2 PB images at 64k cluster size
- * (128 GB for 512 byte clusters, 2 EB for 2 MB clusters) */
+/*
+ * 32 MB L1 table is enough for 2 PB images at 64k cluster size
+ * (128 GB for 512 byte clusters, 2 EB for 2 MB clusters)
+ */
 #define QCOW_MAX_L1_SIZE (32 * MiB)
 
-/* Allow for an average of 1k per snapshot table entry, should be plenty of
- * space for snapshot names and IDs */
+/*
+ * Allow for an average of 1k per snapshot table entry, should be plenty of
+ * space for snapshot names and IDs
+ */
 #define QCOW_MAX_SNAPSHOTS_SIZE (1024 * QCOW_MAX_SNAPSHOTS)
 
 /* Bitmap header extension constraints */
@@ -77,7 +86,7 @@ do {									\
 #define QCOW_MAX_BITMAP_DIRECTORY_SIZE (1024 * QCOW_MAX_BITMAPS)
 
 /* indicate that the refcount of the referenced cluster is exactly one. */
-#define QCOW_OFLAG_COPIED     (1ULL << 63)
+#define QCOW_OFLAG_COPIED (1ULL << 63)
 /* indicate that the cluster is compressed (they never have the copied flag) */
 #define QCOW_OFLAG_COMPRESSED (1ULL << 62)
 /* The cluster reads as all zeros */
@@ -86,22 +95,20 @@ do {									\
 #define QCOW_EXTL2_SUBCLUSTERS_PER_CLUSTER 32
 
 /* The subcluster X [0..31] is allocated */
-#define QCOW_OFLAG_SUB_ALLOC(X)   (1ULL << (X))
+#define QCOW_OFLAG_SUB_ALLOC(X) (1ULL << (X))
 /* The subcluster X [0..31] reads as zeroes */
-#define QCOW_OFLAG_SUB_ZERO(X)    (QCOW_OFLAG_SUB_ALLOC(X) << 32)
+#define QCOW_OFLAG_SUB_ZERO(X) (QCOW_OFLAG_SUB_ALLOC(X) << 32)
 /* Subclusters [X, Y) (0 <= X <= Y <= 32) are allocated */
-#define QCOW_OFLAG_SUB_ALLOC_RANGE(X, Y) \
-    (QCOW_OFLAG_SUB_ALLOC(Y) - QCOW_OFLAG_SUB_ALLOC(X))
+#define QCOW_OFLAG_SUB_ALLOC_RANGE(X, Y) (QCOW_OFLAG_SUB_ALLOC(Y) - QCOW_OFLAG_SUB_ALLOC(X))
 /* Subclusters [X, Y) (0 <= X <= Y <= 32) read as zeroes */
-#define QCOW_OFLAG_SUB_ZERO_RANGE(X, Y) \
-    (QCOW_OFLAG_SUB_ALLOC_RANGE(X, Y) << 32)
+#define QCOW_OFLAG_SUB_ZERO_RANGE(X, Y) (QCOW_OFLAG_SUB_ALLOC_RANGE(X, Y) << 32)
 /* L2 entry bitmap with all allocation bits set */
-#define QCOW_L2_BITMAP_ALL_ALLOC  (QCOW_OFLAG_SUB_ALLOC_RANGE(0, 32))
+#define QCOW_L2_BITMAP_ALL_ALLOC (QCOW_OFLAG_SUB_ALLOC_RANGE(0, 32))
 /* L2 entry bitmap with all "read as zeroes" bits set */
 #define QCOW_L2_BITMAP_ALL_ZEROES (QCOW_OFLAG_SUB_ZERO_RANGE(0, 32))
 
 /* Size of normal and extended L2 entries */
-#define QCOW_L2E_SIZE_NORMAL   (sizeof(u64))
+#define QCOW_L2E_SIZE_NORMAL (sizeof(u64))
 #define QCOW_L2E_SIZE_EXTENDED (sizeof(u64) * 2)
 
 /* Size of L1 table entries */
@@ -124,15 +131,17 @@ do {									\
 #define QCOW_MIN_REFCOUNT_CACHE_SIZE 4 /* clusters */
 
 #define QCOW_DEFAULT_L2_CACHE_MAX_SIZE (32 * MiB)
-#define QCOW_DEFAULT_CACHE_CLEAN_INTERVAL 600  /* seconds */
+#define QCOW_DEFAULT_CACHE_CLEAN_INTERVAL 600 /* seconds */
 
 #define QCOW_DEFAULT_CLUSTER_SIZE 65536
 
 /* Buffer size for debugfs file buffer to display QCOW header information */
 #define QCOW_HEADER_BUF_LEN 1024
 
-/* Buffer size for debugfs file buffer to receive and display offset and
- * cluster offset information */
+/*
+ * Buffer size for debugfs file buffer to receive and display offset and
+ * cluster offset information
+ */
 #define QCOW_OFFSET_BUF_LEN 32
 #define QCOW_CLUSTER_BUF_LEN 256
 
@@ -160,57 +169,54 @@ struct xloop_file_fmt_qcow_header {
 	u32 header_length;
 
 	/* Additional fields */
-    u8 compression_type;
+	u8 compression_type;
 
-    /* header must be a multiple of 8 */
-    u8 padding[7];
-} __attribute__((packed));
+	/* header must be a multiple of 8 */
+	u8 padding[7];
+} __packed;
 
 struct xloop_file_fmt_qcow_snapshot_header {
 	/* header is 8 byte aligned */
-	u64 l1_table_offset;
+	u64  l1_table_offset;
 
-	u32 l1_size;
-	u16 id_str_size;
-	u16 name_size;
+	u32  l1_size;
+	u16  id_str_size;
+	u16  name_size;
 
-	u32 date_sec;
-	u32 date_nsec;
+	u32  date_sec;
+	u32  date_nsec;
 
-	u64 vm_clock_nsec;
+	u64  vm_clock_nsec;
 
-	u32 vm_state_size;
+	u32  vm_state_size;
 
-    /* Size of all extra data, including QCowSnapshotExtraData if available */
-    u32 extra_data_size;
-    /* Data beyond QCowSnapshotExtraData, if any */
-    void *unknown_extra_data;
-} __attribute__((packed));
+	/* Size of all extra data, including QCowSnapshotExtraData if available */
+	u32  extra_data_size;
+	/* Data beyond QCowSnapshotExtraData, if any */
+	void *unknown_extra_data;
+} __packed;
 
 enum {
-	QCOW_FEAT_TYPE_INCOMPATIBLE    = 0,
-	QCOW_FEAT_TYPE_COMPATIBLE      = 1,
-	QCOW_FEAT_TYPE_AUTOCLEAR       = 2,
+	QCOW_FEAT_TYPE_INCOMPATIBLE = 0,
+	QCOW_FEAT_TYPE_COMPATIBLE   = 1,
+	QCOW_FEAT_TYPE_AUTOCLEAR    = 2,
 };
 
 /* incompatible feature bits */
 enum {
-	QCOW_INCOMPAT_DIRTY_BITNR      = 0,
-	QCOW_INCOMPAT_CORRUPT_BITNR    = 1,
-	QCOW_INCOMPAT_DATA_FILE_BITNR  = 2,
+	QCOW_INCOMPAT_DIRTY_BITNR       = 0,
+	QCOW_INCOMPAT_CORRUPT_BITNR     = 1,
+	QCOW_INCOMPAT_DATA_FILE_BITNR   = 2,
 	QCOW_INCOMPAT_COMPRESSION_BITNR = 3,
-    QCOW_INCOMPAT_EXTL2_BITNR      = 4,
-	QCOW_INCOMPAT_DIRTY            = 1 << QCOW_INCOMPAT_DIRTY_BITNR,
-	QCOW_INCOMPAT_CORRUPT          = 1 << QCOW_INCOMPAT_CORRUPT_BITNR,
-	QCOW_INCOMPAT_DATA_FILE        = 1 << QCOW_INCOMPAT_DATA_FILE_BITNR,
-    QCOW_INCOMPAT_COMPRESSION      = 1 << QCOW_INCOMPAT_COMPRESSION_BITNR,
-    QCOW_INCOMPAT_EXTL2            = 1 << QCOW_INCOMPAT_EXTL2_BITNR,
-
-	QCOW_INCOMPAT_MASK             = QCOW_INCOMPAT_DIRTY
-					| QCOW_INCOMPAT_CORRUPT
-					| QCOW_INCOMPAT_DATA_FILE
-					| QCOW_INCOMPAT_COMPRESSION
-					| QCOW_INCOMPAT_EXTL2,
+	QCOW_INCOMPAT_EXTL2_BITNR       = 4,
+	QCOW_INCOMPAT_DIRTY             = 1 << QCOW_INCOMPAT_DIRTY_BITNR,
+	QCOW_INCOMPAT_CORRUPT           = 1 << QCOW_INCOMPAT_CORRUPT_BITNR,
+	QCOW_INCOMPAT_DATA_FILE         = 1 << QCOW_INCOMPAT_DATA_FILE_BITNR,
+	QCOW_INCOMPAT_COMPRESSION       = 1 << QCOW_INCOMPAT_COMPRESSION_BITNR,
+	QCOW_INCOMPAT_EXTL2             = 1 << QCOW_INCOMPAT_EXTL2_BITNR,
+
+	QCOW_INCOMPAT_MASK              = QCOW_INCOMPAT_DIRTY | QCOW_INCOMPAT_CORRUPT | QCOW_INCOMPAT_DATA_FILE |
+						QCOW_INCOMPAT_COMPRESSION | QCOW_INCOMPAT_EXTL2,
 };
 
 /* compatible feature bits */
@@ -228,8 +234,7 @@ enum {
 	QCOW_AUTOCLEAR_BITMAPS             = 1 << QCOW_AUTOCLEAR_BITMAPS_BITNR,
 	QCOW_AUTOCLEAR_DATA_FILE_RAW       = 1 << QCOW_AUTOCLEAR_DATA_FILE_RAW_BITNR,
 
-	QCOW_AUTOCLEAR_MASK                = QCOW_AUTOCLEAR_BITMAPS |
-						QCOW_AUTOCLEAR_DATA_FILE_RAW,
+	QCOW_AUTOCLEAR_MASK                = QCOW_AUTOCLEAR_BITMAPS | QCOW_AUTOCLEAR_DATA_FILE_RAW,
 };
 
 enum xloop_file_fmt_qcow_compression_type {
@@ -238,85 +243,85 @@ enum xloop_file_fmt_qcow_compression_type {
 };
 
 struct xloop_file_fmt_qcow_data {
-	u64 size;
-	int cluster_bits;
-	int cluster_size;
-	int l2_slice_size;
-	int subcluster_bits;
-    int subcluster_size;
-    int subclusters_per_cluster;
-	int l2_bits;
-	int l2_size;
-	int l1_size;
-	int l1_vm_state_index;
-	int refcount_block_bits;
-	int refcount_block_size;
-	int csize_shift;
-	int csize_mask;
-	u64 cluster_offset_mask;
-	u64 l1_table_offset;
-	u64 *l1_table;
+	u64           size;
+	int           cluster_bits;
+	int           cluster_size;
+	int           l2_slice_size;
+	int           subcluster_bits;
+	int           subcluster_size;
+	int           subclusters_per_cluster;
+	int           l2_bits;
+	int           l2_size;
+	int           l1_size;
+	int           l1_vm_state_index;
+	int           refcount_block_bits;
+	int           refcount_block_size;
+	int           csize_shift;
+	int           csize_mask;
+	u64           cluster_offset_mask;
+	u64           l1_table_offset;
+	u64           *l1_table;
 
 	struct xloop_file_fmt_qcow_cache *l2_table_cache;
 	struct xloop_file_fmt_qcow_cache *refcount_block_cache;
 
-	u64 *refcount_table;
-	u64 refcount_table_offset;
-	u32 refcount_table_size;
-	u32 max_refcount_table_index; /* Last used entry in refcount_table */
-	u64 free_cluster_index;
-	u64 free_byte_offset;
+	u64           *refcount_table;
+	u64           refcount_table_offset;
+	u32           refcount_table_size;
+	u32           max_refcount_table_index; /* Last used entry in refcount_table */
+	u64           free_cluster_index;
+	u64           free_byte_offset;
 
-	u32 crypt_method_header;
-	u64 snapshots_offset;
-	int snapshots_size;
-	unsigned int nb_snapshots;
+	u32           crypt_method_header;
+	u64           snapshots_offset;
+	int           snapshots_size;
+	unsigned int  nb_snapshots;
 
-	u32 nb_bitmaps;
-	u64 bitmap_directory_size;
-	u64 bitmap_directory_offset;
+	u32           nb_bitmaps;
+	u64           bitmap_directory_size;
+	u64           bitmap_directory_offset;
 
-	int qcow_version;
-	bool use_lazy_refcounts;
-	int refcount_order;
-	int refcount_bits;
-	u64 refcount_max;
+	int           qcow_version;
+	bool          use_lazy_refcounts;
+	int           refcount_order;
+	int           refcount_bits;
+	u64           refcount_max;
 
-	u64 incompatible_features;
-	u64 compatible_features;
-	u64 autoclear_features;
+	u64           incompatible_features;
+	u64           compatible_features;
+	u64           autoclear_features;
 
 	/* ZLIB specific data */
-	z_streamp zlib_dstrm;
+	z_streamp     zlib_dstrm;
 
 	/* ZSTD specific data */
 #ifdef CONFIG_ZSTD_DECOMPRESS
-	void *zstd_dworkspace;
-	ZSTD_DStream *zstd_dstrm;
+	void          *zstd_dworkspace;
+	ZSTD_DStream  *zstd_dstrm;
 #endif
 
 	/* used to cache last compressed QCOW cluster */
-	u8 *cmp_out_buf;
-	u64 cmp_last_coffset;
-
-    /*
-     * Compression type used for the image. Default: 0 - ZLIB
-     * The image compression type is set on image creation.
-     * For now, the only way to change the compression type
-     * is to convert the image with the desired compression type set.
-     */
-    enum xloop_file_fmt_qcow_compression_type compression_type;
+	u8            *cmp_out_buf;
+	u64           cmp_last_coffset;
+
+	/*
+	 * Compression type used for the image. Default: 0 - ZLIB
+	 * The image compression type is set on image creation.
+	 * For now, the only way to change the compression type
+	 * is to convert the image with the desired compression type set.
+	 */
+	enum xloop_file_fmt_qcow_compression_type compression_type;
 
 	/* debugfs entries */
 #ifdef CONFIG_DEBUG_FS
 	struct dentry *dbgfs_dir;
 	struct dentry *dbgfs_file_qcow_header;
-	char dbgfs_file_qcow_header_buf[QCOW_HEADER_BUF_LEN];
+	char          dbgfs_file_qcow_header_buf[QCOW_HEADER_BUF_LEN];
 	struct dentry *dbgfs_file_qcow_offset;
-	char dbgfs_file_qcow_offset_buf[QCOW_OFFSET_BUF_LEN];
-	char dbgfs_file_qcow_cluster_buf[QCOW_CLUSTER_BUF_LEN];
-	u64 dbgfs_qcow_offset;
-	struct mutex dbgfs_qcow_offset_mutex;
+	char          dbgfs_file_qcow_offset_buf[QCOW_OFFSET_BUF_LEN];
+	char          dbgfs_file_qcow_cluster_buf[QCOW_CLUSTER_BUF_LEN];
+	u64           dbgfs_qcow_offset;
+	struct mutex  dbgfs_qcow_offset_mutex;
 #endif
 };
 
@@ -325,10 +330,10 @@ struct xloop_file_fmt_qcow_cow_region {
 	 * Offset of the COW region in bytes from the start of the first
 	 * cluster touched by the request.
 	 */
-	unsigned offset;
+	unsigned int offset;
 
 	/** Number of bytes to copy */
-	unsigned nb_bytes;
+	unsigned int nb_bytes;
 };
 
 /*
@@ -368,13 +373,13 @@ enum xloop_file_fmt_qcow_cluster_type {
 };
 
 enum xloop_file_fmt_qcow_subcluster_type {
-    QCOW_SUBCLUSTER_UNALLOCATED_PLAIN,
-    QCOW_SUBCLUSTER_UNALLOCATED_ALLOC,
-    QCOW_SUBCLUSTER_ZERO_PLAIN,
-    QCOW_SUBCLUSTER_ZERO_ALLOC,
-    QCOW_SUBCLUSTER_NORMAL,
-    QCOW_SUBCLUSTER_COMPRESSED,
-    QCOW_SUBCLUSTER_INVALID,
+	QCOW_SUBCLUSTER_UNALLOCATED_PLAIN,
+	QCOW_SUBCLUSTER_UNALLOCATED_ALLOC,
+	QCOW_SUBCLUSTER_ZERO_PLAIN,
+	QCOW_SUBCLUSTER_ZERO_ALLOC,
+	QCOW_SUBCLUSTER_NORMAL,
+	QCOW_SUBCLUSTER_COMPRESSED,
+	QCOW_SUBCLUSTER_INVALID,
 };
 
 enum xloop_file_fmt_qcow_metadata_overlap {
@@ -390,173 +395,146 @@ enum xloop_file_fmt_qcow_metadata_overlap {
 
 	QCOW_OL_MAX_BITNR              = 9,
 
-	QCOW_OL_NONE             = 0,
-	QCOW_OL_MAIN_HEADER      = (1 << QCOW_OL_MAIN_HEADER_BITNR),
-	QCOW_OL_ACTIVE_L1        = (1 << QCOW_OL_ACTIVE_L1_BITNR),
-	QCOW_OL_ACTIVE_L2        = (1 << QCOW_OL_ACTIVE_L2_BITNR),
-	QCOW_OL_REFCOUNT_TABLE   = (1 << QCOW_OL_REFCOUNT_TABLE_BITNR),
-	QCOW_OL_REFCOUNT_BLOCK   = (1 << QCOW_OL_REFCOUNT_BLOCK_BITNR),
-	QCOW_OL_SNAPSHOT_TABLE   = (1 << QCOW_OL_SNAPSHOT_TABLE_BITNR),
-	QCOW_OL_INACTIVE_L1      = (1 << QCOW_OL_INACTIVE_L1_BITNR),
-	/* NOTE: Checking overlaps with inactive L2 tables will result in bdrv
-	 * reads. */
-	QCOW_OL_INACTIVE_L2      = (1 << QCOW_OL_INACTIVE_L2_BITNR),
-	QCOW_OL_BITMAP_DIRECTORY = (1 << QCOW_OL_BITMAP_DIRECTORY_BITNR),
+	QCOW_OL_NONE                   = 0,
+	QCOW_OL_MAIN_HEADER            = (1 << QCOW_OL_MAIN_HEADER_BITNR),
+	QCOW_OL_ACTIVE_L1              = (1 << QCOW_OL_ACTIVE_L1_BITNR),
+	QCOW_OL_ACTIVE_L2              = (1 << QCOW_OL_ACTIVE_L2_BITNR),
+	QCOW_OL_REFCOUNT_TABLE         = (1 << QCOW_OL_REFCOUNT_TABLE_BITNR),
+	QCOW_OL_REFCOUNT_BLOCK         = (1 << QCOW_OL_REFCOUNT_BLOCK_BITNR),
+	QCOW_OL_SNAPSHOT_TABLE         = (1 << QCOW_OL_SNAPSHOT_TABLE_BITNR),
+	QCOW_OL_INACTIVE_L1            = (1 << QCOW_OL_INACTIVE_L1_BITNR),
+	/* NOTE: Checking overlaps with inactive L2 tables will result in bdrv reads. */
+	QCOW_OL_INACTIVE_L2            = (1 << QCOW_OL_INACTIVE_L2_BITNR),
+	QCOW_OL_BITMAP_DIRECTORY       = (1 << QCOW_OL_BITMAP_DIRECTORY_BITNR),
 };
 
 /* Perform all overlap checks which can be done in constant time */
-#define QCOW_OL_CONSTANT \
-	(QCOW_OL_MAIN_HEADER | QCOW_OL_ACTIVE_L1 | QCOW_OL_REFCOUNT_TABLE | \
-		QCOW_OL_SNAPSHOT_TABLE | QCOW_OL_BITMAP_DIRECTORY)
+#define QCOW_OL_CONSTANT                                                                                               \
+	(QCOW_OL_MAIN_HEADER | QCOW_OL_ACTIVE_L1 | QCOW_OL_REFCOUNT_TABLE | QCOW_OL_SNAPSHOT_TABLE |                   \
+	 QCOW_OL_BITMAP_DIRECTORY)
 
 /* Perform all overlap checks which don't require disk access */
-#define QCOW_OL_CACHED \
-	(QCOW_OL_CONSTANT | QCOW_OL_ACTIVE_L2 | QCOW_OL_REFCOUNT_BLOCK | \
-		QCOW_OL_INACTIVE_L1)
+#define QCOW_OL_CACHED (QCOW_OL_CONSTANT | QCOW_OL_ACTIVE_L2 | QCOW_OL_REFCOUNT_BLOCK | QCOW_OL_INACTIVE_L1)
 
 /* Perform all overlap checks */
-#define QCOW_OL_ALL \
-	(QCOW_OL_CACHED | QCOW_OL_INACTIVE_L2)
+#define QCOW_OL_ALL (QCOW_OL_CACHED | QCOW_OL_INACTIVE_L2)
 
 #define QCOW_L1E_OFFSET_MASK 0x00fffffffffffe00ULL
 #define QCOW_L2E_OFFSET_MASK 0x00fffffffffffe00ULL
 #define QCOW_L2E_COMPRESSED_OFFSET_SIZE_MASK 0x3fffffffffffffffULL
 
-static inline bool xloop_file_fmt_qcow_has_subclusters(
-	struct xloop_file_fmt_qcow_data *qcow_data)
+static inline bool xloop_file_fmt_qcow_has_subclusters(struct xloop_file_fmt_qcow_data *qcow_data)
 {
-    return qcow_data->incompatible_features & QCOW_INCOMPAT_EXTL2;
+	return qcow_data->incompatible_features & QCOW_INCOMPAT_EXTL2;
 }
 
-static inline size_t xloop_file_fmt_qcow_l2_entry_size(
-	struct xloop_file_fmt_qcow_data *qcow_data)
+static inline size_t xloop_file_fmt_qcow_l2_entry_size(struct xloop_file_fmt_qcow_data *qcow_data)
 {
-    return xloop_file_fmt_qcow_has_subclusters(qcow_data) ? 
-		QCOW_L2E_SIZE_EXTENDED : QCOW_L2E_SIZE_NORMAL;
+	return xloop_file_fmt_qcow_has_subclusters(qcow_data) ? QCOW_L2E_SIZE_EXTENDED : QCOW_L2E_SIZE_NORMAL;
 }
 
-static inline u64 xloop_file_fmt_qcow_get_l2_entry(
-	struct xloop_file_fmt_qcow_data *qcow_data, u64 *l2_slice, int idx)
+static inline u64 xloop_file_fmt_qcow_get_l2_entry(struct xloop_file_fmt_qcow_data *qcow_data, u64 *l2_slice, int idx)
 {
-    idx *= xloop_file_fmt_qcow_l2_entry_size(qcow_data) / sizeof(u64);
-    return be64_to_cpu(l2_slice[idx]);
+	idx *= xloop_file_fmt_qcow_l2_entry_size(qcow_data) / sizeof(u64);
+	return be64_to_cpu(l2_slice[idx]);
 }
 
-static inline u64 xloop_file_fmt_qcow_get_l2_bitmap(
-	struct xloop_file_fmt_qcow_data *qcow_data, u64 *l2_slice, int idx)
+static inline u64 xloop_file_fmt_qcow_get_l2_bitmap(struct xloop_file_fmt_qcow_data *qcow_data, u64 *l2_slice, int idx)
 {
-    if (xloop_file_fmt_qcow_has_subclusters(qcow_data)) {
-        idx *= xloop_file_fmt_qcow_l2_entry_size(qcow_data) / sizeof(u64);
-        return be64_to_cpu(l2_slice[idx + 1]);
-    } else {
-        return 0; /* For convenience only; this value has no meaning. */
-    }
+	if (xloop_file_fmt_qcow_has_subclusters(qcow_data)) {
+		idx *= xloop_file_fmt_qcow_l2_entry_size(qcow_data) / sizeof(u64);
+		return be64_to_cpu(l2_slice[idx + 1]);
+	} else {
+		return 0; /* For convenience only; this value has no meaning. */
+	}
 }
 
-static inline bool xloop_file_fmt_qcow_has_data_file(
-	struct xloop_file_fmt_qcow_data *qcow_data)
+static inline bool xloop_file_fmt_qcow_has_data_file(struct xloop_file_fmt_qcow_data *qcow_data)
 {
 	/* At the moment, there is no support for copy on write! */
 	return false;
 }
 
-static inline bool xloop_file_fmt_qcow_data_file_is_raw(
-	struct xloop_file_fmt_qcow_data *qcow_data)
+static inline bool xloop_file_fmt_qcow_data_file_is_raw(struct xloop_file_fmt_qcow_data *qcow_data)
 {
-	return !!(qcow_data->autoclear_features &
-		QCOW_AUTOCLEAR_DATA_FILE_RAW);
+	return !!(qcow_data->autoclear_features & QCOW_AUTOCLEAR_DATA_FILE_RAW);
 }
 
-static inline s64 xloop_file_fmt_qcow_start_of_cluster(
-	struct xloop_file_fmt_qcow_data *qcow_data, s64 offset)
+static inline s64 xloop_file_fmt_qcow_start_of_cluster(struct xloop_file_fmt_qcow_data *qcow_data, s64 offset)
 {
 	return offset & ~(qcow_data->cluster_size - 1);
 }
 
-static inline s64 xloop_file_fmt_qcow_offset_into_cluster(
-	struct xloop_file_fmt_qcow_data *qcow_data, s64 offset)
+static inline s64 xloop_file_fmt_qcow_offset_into_cluster(struct xloop_file_fmt_qcow_data *qcow_data, s64 offset)
 {
 	return offset & (qcow_data->cluster_size - 1);
 }
 
-static inline s64 xloop_file_fmt_qcow_offset_into_subcluster(
-	struct xloop_file_fmt_qcow_data *qcow_data, s64 offset)
+static inline s64 xloop_file_fmt_qcow_offset_into_subcluster(struct xloop_file_fmt_qcow_data *qcow_data, s64 offset)
 {
 	return offset & (qcow_data->subcluster_size - 1);
 }
 
-static inline s64 xloop_file_fmt_qcow_size_to_clusters(
-	struct xloop_file_fmt_qcow_data *qcow_data, u64 size)
+static inline s64 xloop_file_fmt_qcow_size_to_clusters(struct xloop_file_fmt_qcow_data *qcow_data, u64 size)
 {
-	return (size + (qcow_data->cluster_size - 1)) >>
-		qcow_data->cluster_bits;
+	return (size + (qcow_data->cluster_size - 1)) >> qcow_data->cluster_bits;
 }
 
-static inline s64 xloop_file_fmt_qcow_size_to_l1(
-	struct xloop_file_fmt_qcow_data *qcow_data, s64 size)
+static inline s64 xloop_file_fmt_qcow_size_to_l1(struct xloop_file_fmt_qcow_data *qcow_data, s64 size)
 {
 	int shift = qcow_data->cluster_bits + qcow_data->l2_bits;
+
 	return (size + (1ULL << shift) - 1) >> shift;
 }
 
-static inline int xloop_file_fmt_qcow_offset_to_l1_index(
-	struct xloop_file_fmt_qcow_data *qcow_data, u64 offset)
+static inline int xloop_file_fmt_qcow_offset_to_l1_index(struct xloop_file_fmt_qcow_data *qcow_data, u64 offset)
 {
 	return offset >> (qcow_data->l2_bits + qcow_data->cluster_bits);
 }
 
-static inline int xloop_file_fmt_qcow_offset_to_l2_index(
-	struct xloop_file_fmt_qcow_data *qcow_data, s64 offset)
+static inline int xloop_file_fmt_qcow_offset_to_l2_index(struct xloop_file_fmt_qcow_data *qcow_data, s64 offset)
 {
 	return (offset >> qcow_data->cluster_bits) & (qcow_data->l2_size - 1);
 }
 
-static inline int xloop_file_fmt_qcow_offset_to_l2_slice_index(
-	struct xloop_file_fmt_qcow_data *qcow_data, s64 offset)
+static inline int xloop_file_fmt_qcow_offset_to_l2_slice_index(struct xloop_file_fmt_qcow_data *qcow_data, s64 offset)
 {
-	return (offset >> qcow_data->cluster_bits) &
-		(qcow_data->l2_slice_size - 1);
+	return (offset >> qcow_data->cluster_bits) & (qcow_data->l2_slice_size - 1);
 }
 
-static inline int xloop_file_fmt_qcow_offset_to_sc_index(
-	struct xloop_file_fmt_qcow_data *qcow_data, s64 offset)
+static inline int xloop_file_fmt_qcow_offset_to_sc_index(struct xloop_file_fmt_qcow_data *qcow_data, s64 offset)
 {
-    return (offset >> qcow_data->subcluster_bits) & 
-		(qcow_data->subclusters_per_cluster - 1);
+	return (offset >> qcow_data->subcluster_bits) & (qcow_data->subclusters_per_cluster - 1);
 }
 
-static inline s64 xloop_file_fmt_qcow_vm_state_offset(
-	struct xloop_file_fmt_qcow_data *qcow_data)
+static inline s64 xloop_file_fmt_qcow_vm_state_offset(struct xloop_file_fmt_qcow_data *qcow_data)
 {
-	return (s64)qcow_data->l1_vm_state_index <<
-		(qcow_data->cluster_bits + qcow_data->l2_bits);
+	return (s64)qcow_data->l1_vm_state_index << (qcow_data->cluster_bits + qcow_data->l2_bits);
 }
 
-static inline enum xloop_file_fmt_qcow_cluster_type
-xloop_file_fmt_qcow_get_cluster_type(struct xloop_file_fmt *xlo_fmt,
-	u64 l2_entry)
+static inline enum xloop_file_fmt_qcow_cluster_type xloop_file_fmt_qcow_get_cluster_type(struct xloop_file_fmt *xlo_fmt,
+											 u64 l2_entry)
 {
 	struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
 
 	if (l2_entry & QCOW_OFLAG_COMPRESSED) {
 		return QCOW_CLUSTER_COMPRESSED;
 	} else if (l2_entry & QCOW_OFLAG_ZERO) {
-		if (l2_entry & QCOW_L2E_OFFSET_MASK) {
+		if (l2_entry & QCOW_L2E_OFFSET_MASK)
 			return QCOW_CLUSTER_ZERO_ALLOC;
-		}
 		return QCOW_CLUSTER_ZERO_PLAIN;
 	} else if (!(l2_entry & QCOW_L2E_OFFSET_MASK)) {
-		/* Offset 0 generally means unallocated, but it is ambiguous
+		/*
+		 * Offset 0 generally means unallocated, but it is ambiguous
 		 * with external data files because 0 is a valid offset there.
 		 * However, all clusters in external data files always have
 		 * refcount 1, so we can rely on QCOW_OFLAG_COPIED to
-		 * disambiguate. */
-		if (xloop_file_fmt_qcow_has_data_file(qcow_data) &&
-			(l2_entry & QCOW_OFLAG_COPIED)) {
+		 * disambiguate.
+		 */
+		if (xloop_file_fmt_qcow_has_data_file(qcow_data) && (l2_entry & QCOW_OFLAG_COPIED))
 			return QCOW_CLUSTER_NORMAL;
-		} else {
+		else
 			return QCOW_CLUSTER_UNALLOCATED;
-		}
 	} else {
 		return QCOW_CLUSTER_NORMAL;
 	}
@@ -570,76 +548,71 @@ xloop_file_fmt_qcow_get_cluster_type(struct xloop_file_fmt *xlo_fmt,
  * to subcluster @sc_index).
  */
 static inline enum xloop_file_fmt_qcow_subcluster_type
-xloop_file_fmt_qcow_get_subcluster_type(struct xloop_file_fmt *xlo_fmt,
-    u64 l2_entry, u64 l2_bitmap, unsigned int sc_index)
+xloop_file_fmt_qcow_get_subcluster_type(struct xloop_file_fmt *xlo_fmt, u64 l2_entry, u64 l2_bitmap,
+					unsigned int sc_index)
 {
 	struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
-    enum xloop_file_fmt_qcow_cluster_type type = 
-		xloop_file_fmt_qcow_get_cluster_type(xlo_fmt, l2_entry);
-    ASSERT(sc_index < qcow_data->subclusters_per_cluster);
-
-    if (xloop_file_fmt_qcow_has_subclusters(qcow_data)) {
-        switch (type) {
-        case QCOW_CLUSTER_COMPRESSED:
-            return QCOW_SUBCLUSTER_COMPRESSED;
-        case QCOW_CLUSTER_NORMAL:
-            if ((l2_bitmap >> 32) & l2_bitmap) {
-                return QCOW_SUBCLUSTER_INVALID;
-            } else if (l2_bitmap & QCOW_OFLAG_SUB_ZERO(sc_index)) {
-                return QCOW_SUBCLUSTER_ZERO_ALLOC;
-            } else if (l2_bitmap & QCOW_OFLAG_SUB_ALLOC(sc_index)) {
-                return QCOW_SUBCLUSTER_NORMAL;
-            } else {
-                return QCOW_SUBCLUSTER_UNALLOCATED_ALLOC;
-            }
-        case QCOW_CLUSTER_UNALLOCATED:
-            if (l2_bitmap & QCOW_L2_BITMAP_ALL_ALLOC) {
-                return QCOW_SUBCLUSTER_INVALID;
-            } else if (l2_bitmap & QCOW_OFLAG_SUB_ZERO(sc_index)) {
-                return QCOW_SUBCLUSTER_ZERO_PLAIN;
-            } else {
-                return QCOW_SUBCLUSTER_UNALLOCATED_PLAIN;
-            }
-        default:
+	enum xloop_file_fmt_qcow_cluster_type type = xloop_file_fmt_qcow_get_cluster_type(xlo_fmt, l2_entry);
+
+	ASSERT(sc_index < qcow_data->subclusters_per_cluster);
+
+	if (xloop_file_fmt_qcow_has_subclusters(qcow_data)) {
+		switch (type) {
+		case QCOW_CLUSTER_COMPRESSED:
+			return QCOW_SUBCLUSTER_COMPRESSED;
+		case QCOW_CLUSTER_NORMAL:
+			if ((l2_bitmap >> 32) & l2_bitmap)
+				return QCOW_SUBCLUSTER_INVALID;
+			else if (l2_bitmap & QCOW_OFLAG_SUB_ZERO(sc_index))
+				return QCOW_SUBCLUSTER_ZERO_ALLOC;
+			else if (l2_bitmap & QCOW_OFLAG_SUB_ALLOC(sc_index))
+				return QCOW_SUBCLUSTER_NORMAL;
+			else
+				return QCOW_SUBCLUSTER_UNALLOCATED_ALLOC;
+		case QCOW_CLUSTER_UNALLOCATED:
+			if (l2_bitmap & QCOW_L2_BITMAP_ALL_ALLOC)
+				return QCOW_SUBCLUSTER_INVALID;
+			else if (l2_bitmap & QCOW_OFLAG_SUB_ZERO(sc_index))
+				return QCOW_SUBCLUSTER_ZERO_PLAIN;
+			else
+				return QCOW_SUBCLUSTER_UNALLOCATED_PLAIN;
+		default:
 			/* not reachable */
-            ASSERT(false);
+			ASSERT(false);
 			return QCOW_SUBCLUSTER_INVALID;
-        }
-    } else {
-        switch (type) {
-        case QCOW_CLUSTER_COMPRESSED:
-            return QCOW_SUBCLUSTER_COMPRESSED;
-        case QCOW_CLUSTER_ZERO_PLAIN:
-            return QCOW_SUBCLUSTER_ZERO_PLAIN;
-        case QCOW_CLUSTER_ZERO_ALLOC:
-            return QCOW_SUBCLUSTER_ZERO_ALLOC;
-        case QCOW_CLUSTER_NORMAL:
-            return QCOW_SUBCLUSTER_NORMAL;
-        case QCOW_CLUSTER_UNALLOCATED:
-            return QCOW_SUBCLUSTER_UNALLOCATED_PLAIN;
-        default:
-            /* not reachable */
-            ASSERT(false);
+		}
+	} else {
+		switch (type) {
+		case QCOW_CLUSTER_COMPRESSED:
+			return QCOW_SUBCLUSTER_COMPRESSED;
+		case QCOW_CLUSTER_ZERO_PLAIN:
+			return QCOW_SUBCLUSTER_ZERO_PLAIN;
+		case QCOW_CLUSTER_ZERO_ALLOC:
+			return QCOW_SUBCLUSTER_ZERO_ALLOC;
+		case QCOW_CLUSTER_NORMAL:
+			return QCOW_SUBCLUSTER_NORMAL;
+		case QCOW_CLUSTER_UNALLOCATED:
+			return QCOW_SUBCLUSTER_UNALLOCATED_PLAIN;
+		default:
+			/* not reachable */
+			ASSERT(false);
 			return QCOW_SUBCLUSTER_INVALID;
-        }
-    }
+		}
+	}
 }
 
 #ifdef CONFIG_DEBUG_FS
-static inline const char *xloop_file_fmt_qcow_get_subcluster_name(
-    const enum xloop_file_fmt_qcow_subcluster_type type)
+static inline const char *xloop_file_fmt_qcow_get_subcluster_name(const enum xloop_file_fmt_qcow_subcluster_type type)
 {
-    static const char *subcluster_names[] = {
-        "QCOW2_SUBCLUSTER_UNALLOCATED_PLAIN",
-        "QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC",
-        "QCOW2_SUBCLUSTER_ZERO_PLAIN",
-        "QCOW2_SUBCLUSTER_ZERO_ALLOC",
-        "QCOW2_SUBCLUSTER_NORMAL",
-        "QCOW2_SUBCLUSTER_COMPRESSED",
-        "QCOW2_SUBCLUSTER_INVALID"
-    };
-
-    return subcluster_names[type];
+	static const char * const subcluster_names[] = { "QCOW2_SUBCLUSTER_UNALLOCATED_PLAIN",
+							 "QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC",
+							 "QCOW2_SUBCLUSTER_ZERO_PLAIN",
+							 "QCOW2_SUBCLUSTER_ZERO_ALLOC",
+							 "QCOW2_SUBCLUSTER_NORMAL",
+							 "QCOW2_SUBCLUSTER_COMPRESSED",
+							 "QCOW2_SUBCLUSTER_INVALID" };
+
+	return subcluster_names[type];
 }
 #endif
 
diff --git a/src/kernel/xloop_file_fmt_raw.c b/src/kernel/xloop_file_fmt_raw.c
index 12914e8..1c2c42b 100644
--- a/src/kernel/xloop_file_fmt_raw.c
+++ b/src/kernel/xloop_file_fmt_raw.c
@@ -1,4 +1,4 @@
-/* SPDX-License-Identifier: GPL-2.0 */
+// SPDX-License-Identifier: GPL-2.0
 /*
  * xloop_file_fmt_raw.c
  *
@@ -27,18 +27,16 @@
 
 #include "xloop_file_fmt.h"
 
-static inline loff_t __raw_file_fmt_rq_get_pos(struct xloop_file_fmt *xlo_fmt,
-					       struct request *rq)
+static inline loff_t __raw_file_fmt_rq_get_pos(struct xloop_file_fmt *xlo_fmt, struct request *rq)
 {
 	struct xloop_device *xlo = xloop_file_fmt_get_xlo(xlo_fmt);
-	return ((loff_t) blk_rq_pos(rq) << 9) + xlo->xlo_offset;
+
+	return ((loff_t)blk_rq_pos(rq) << 9) + xlo->xlo_offset;
 }
 
 /* transfer function for DEPRECATED cryptoxloop support */
-static inline int __raw_file_fmt_do_transfer(struct xloop_device *xlo, int cmd,
-					struct page *rpage, unsigned roffs,
-					struct page *lpage, unsigned loffs,
-					int size, sector_t rblock)
+static inline int __raw_file_fmt_do_transfer(struct xloop_device *xlo, int cmd, struct page *rpage, unsigned int roffs,
+					     struct page *lpage, unsigned int loffs, int size, sector_t rblock)
 {
 	int ret;
 
@@ -46,13 +44,11 @@ static inline int __raw_file_fmt_do_transfer(struct xloop_device *xlo, int cmd,
 	if (likely(!ret))
 		return 0;
 
-	pr_err_ratelimited("transfer error at byte offset %llu, length %i.\n",
-		(unsigned long long)rblock << 9, size);
+	pr_err_ratelimited("transfer error at byte offset %llu, length %i.\n", (unsigned long long)rblock << 9, size);
 	return ret;
 }
 
-static int __raw_file_fmt_read_transfer(struct xloop_device *xlo,
-		struct request *rq, loff_t pos)
+static int __raw_file_fmt_read_transfer(struct xloop_device *xlo, struct request *rq, loff_t pos)
 {
 	struct bio_vec bvec, b;
 	struct req_iterator iter;
@@ -79,8 +75,7 @@ static int __raw_file_fmt_read_transfer(struct xloop_device *xlo,
 			goto out_free_page;
 		}
 
-		ret = __raw_file_fmt_do_transfer(xlo, READ, page, 0, bvec.bv_page,
-			bvec.bv_offset, len, offset >> 9);
+		ret = __raw_file_fmt_do_transfer(xlo, READ, page, 0, bvec.bv_page, bvec.bv_offset, len, offset >> 9);
 		if (ret)
 			goto out_free_page;
 
@@ -101,8 +96,7 @@ out_free_page:
 	return ret;
 }
 
-static int raw_file_fmt_read(struct xloop_file_fmt *xlo_fmt,
-			     struct request *rq)
+static int raw_file_fmt_read(struct xloop_file_fmt *xlo_fmt, struct request *rq)
 {
 	struct bio_vec bvec;
 	struct req_iterator iter;
@@ -164,8 +158,7 @@ static void __raw_file_fmt_rw_aio_complete(struct kiocb *iocb, long ret, long re
 	__raw_file_fmt_rw_aio_do_completion(cmd);
 }
 
-static int __raw_file_fmt_rw_aio(struct xloop_device *xlo,
-			struct xloop_cmd *cmd, loff_t pos, bool rw)
+static int __raw_file_fmt_rw_aio(struct xloop_device *xlo, struct xloop_cmd *cmd, loff_t pos, bool rw)
 {
 	struct iov_iter iter;
 	struct req_iterator rq_iter;
@@ -188,8 +181,7 @@ static int __raw_file_fmt_rw_aio(struct xloop_device *xlo,
 		__rq_for_each_bio(bio, rq)
 			nr_bvec += bio_segments(bio);
 #endif
-		bvec = kmalloc_array(nr_bvec, sizeof(struct bio_vec),
-				     GFP_NOIO);
+		bvec = kmalloc_array(nr_bvec, sizeof(struct bio_vec), GFP_NOIO);
 		if (!bvec)
 			return -EIO;
 		cmd->bvec = bvec;
@@ -248,8 +240,7 @@ static int __raw_file_fmt_rw_aio(struct xloop_device *xlo,
 	return 0;
 }
 
-static int raw_file_fmt_read_aio(struct xloop_file_fmt *xlo_fmt,
-				 struct request *rq)
+static int raw_file_fmt_read_aio(struct xloop_file_fmt *xlo_fmt, struct request *rq)
 {
 	struct xloop_device *xlo = xloop_file_fmt_get_xlo(xlo_fmt);
 	struct xloop_cmd *cmd = blk_mq_rq_to_pdu(rq);
@@ -258,9 +249,7 @@ static int raw_file_fmt_read_aio(struct xloop_file_fmt *xlo_fmt,
 	return __raw_file_fmt_rw_aio(xlo, cmd, pos, READ);
 }
 
-static int __raw_file_fmt_write_bvec(struct file *file,
-				     struct bio_vec *bvec,
-				     loff_t *ppos)
+static int __raw_file_fmt_write_bvec(struct file *file, struct bio_vec *bvec, loff_t *ppos)
 {
 	struct iov_iter i;
 	ssize_t bw;
@@ -271,11 +260,10 @@ static int __raw_file_fmt_write_bvec(struct file *file,
 	bw = vfs_iter_write(file, &i, ppos, 0);
 	file_end_write(file);
 
-	if (likely(bw ==  bvec->bv_len))
+	if (likely(bw == bvec->bv_len))
 		return 0;
 
-	pr_err_ratelimited("write error at byte offset %llu, length %i.\n",
-		(unsigned long long)*ppos, bvec->bv_len);
+	pr_err_ratelimited("write error at byte offset %llu, length %i.\n", (unsigned long long)*ppos, bvec->bv_len);
 	if (bw >= 0)
 		bw = -EIO;
 	return bw;
@@ -286,10 +274,9 @@ static int __raw_file_fmt_write_bvec(struct file *file,
  * data as it cannot do the transformations in place without having direct
  * access to the destination pages of the backing file.
  */
-static int __raw_file_fmt_write_transfer(struct xloop_device *xlo,
-		struct request *rq, loff_t pos)
+static int __raw_file_fmt_write_transfer(struct xloop_device *xlo, struct request *rq, loff_t pos)
 {
-struct bio_vec bvec, b;
+	struct bio_vec bvec, b;
 	struct req_iterator iter;
 	struct page *page;
 	int ret = 0;
@@ -299,8 +286,8 @@ struct bio_vec bvec, b;
 		return -ENOMEM;
 
 	rq_for_each_segment(bvec, rq, iter) {
-		ret = __raw_file_fmt_do_transfer(xlo, WRITE, page, 0, bvec.bv_page,
-			bvec.bv_offset, bvec.bv_len, pos >> 9);
+		ret = __raw_file_fmt_do_transfer(xlo, WRITE, page, 0, bvec.bv_page, bvec.bv_offset, bvec.bv_len,
+						 pos >> 9);
 		if (unlikely(ret))
 			break;
 
@@ -316,8 +303,7 @@ struct bio_vec bvec, b;
 	return ret;
 }
 
-static int raw_file_fmt_write(struct xloop_file_fmt *xlo_fmt,
-			      struct request *rq)
+static int raw_file_fmt_write(struct xloop_file_fmt *xlo_fmt, struct request *rq)
 {
 	struct bio_vec bvec;
 	struct req_iterator iter;
@@ -341,8 +327,7 @@ static int raw_file_fmt_write(struct xloop_file_fmt *xlo_fmt,
 	return ret;
 }
 
-static int raw_file_fmt_write_aio(struct xloop_file_fmt *xlo_fmt,
-				  struct request *rq)
+static int raw_file_fmt_write_aio(struct xloop_file_fmt *xlo_fmt, struct request *rq)
 {
 	struct xloop_device *xlo = xloop_file_fmt_get_xlo(xlo_fmt);
 	struct xloop_cmd *cmd = blk_mq_rq_to_pdu(rq);
@@ -351,8 +336,7 @@ static int raw_file_fmt_write_aio(struct xloop_file_fmt *xlo_fmt,
 	return __raw_file_fmt_rw_aio(xlo, cmd, pos, WRITE);
 }
 
-static int __raw_file_fmt_fallocate(struct xloop_device *xlo,
-			struct request *rq, loff_t pos, int mode)
+static int __raw_file_fmt_fallocate(struct xloop_device *xlo, struct request *rq, loff_t pos, int mode)
 {
 	/*
 	 * We use fallocate to manipulate the space mappings used by the image
@@ -378,8 +362,7 @@ out:
 	return ret;
 }
 
-static int raw_file_fmt_write_zeros(struct xloop_file_fmt *xlo_fmt,
-				struct request *rq)
+static int raw_file_fmt_write_zeros(struct xloop_file_fmt *xlo_fmt, struct request *rq)
 {
 	loff_t pos = __raw_file_fmt_rq_get_pos(xlo_fmt, rq);
 	struct xloop_device *xlo = xloop_file_fmt_get_xlo(xlo_fmt);
@@ -389,13 +372,10 @@ static int raw_file_fmt_write_zeros(struct xloop_file_fmt *xlo_fmt,
 	 * write zeroes the range. Otherwise, punch them out.
 	 */
 	return __raw_file_fmt_fallocate(xlo, rq, pos,
-			(rq->cmd_flags & REQ_NOUNMAP) ?
-			 FALLOC_FL_ZERO_RANGE :
-			 FALLOC_FL_PUNCH_HOLE);
+					(rq->cmd_flags & REQ_NOUNMAP) ? FALLOC_FL_ZERO_RANGE : FALLOC_FL_PUNCH_HOLE);
 }
 
-static int raw_file_fmt_discard(struct xloop_file_fmt *xlo_fmt,
-				struct request *rq)
+static int raw_file_fmt_discard(struct xloop_file_fmt *xlo_fmt, struct request *rq)
 {
 	loff_t pos = __raw_file_fmt_rq_get_pos(xlo_fmt, rq);
 	struct xloop_device *xlo = xloop_file_fmt_get_xlo(xlo_fmt);
@@ -408,14 +388,15 @@ static int raw_file_fmt_flush(struct xloop_file_fmt *xlo_fmt)
 	struct xloop_device *xlo = xloop_file_fmt_get_xlo(xlo_fmt);
 	struct file *file = xlo->xlo_backing_file;
 	int ret = vfs_fsync(file, 0);
+
 	if (unlikely(ret && ret != -EINVAL))
 		ret = -EIO;
 
 	return ret;
 }
 
-static loff_t raw_file_fmt_sector_size(struct xloop_file_fmt *xlo_fmt,
-				struct file *file, loff_t offset, loff_t sizelimit)
+static loff_t raw_file_fmt_sector_size(struct xloop_file_fmt *xlo_fmt, struct file *file, loff_t offset,
+				       loff_t sizelimit)
 {
 	loff_t xloopsize;
 
@@ -437,23 +418,23 @@ static loff_t raw_file_fmt_sector_size(struct xloop_file_fmt *xlo_fmt,
 }
 
 static struct xloop_file_fmt_ops raw_file_fmt_ops = {
-	.init = NULL,
-	.exit = NULL,
-	.read = raw_file_fmt_read,
-	.write = raw_file_fmt_write,
-	.read_aio = raw_file_fmt_read_aio,
-	.write_aio = raw_file_fmt_write_aio,
+	.init        = NULL,
+	.exit        = NULL,
+	.read        = raw_file_fmt_read,
+	.write       = raw_file_fmt_write,
+	.read_aio    = raw_file_fmt_read_aio,
+	.write_aio   = raw_file_fmt_write_aio,
 	.write_zeros = raw_file_fmt_write_zeros,
-	.discard = raw_file_fmt_discard,
-	.flush = raw_file_fmt_flush,
+	.discard     = raw_file_fmt_discard,
+	.flush       = raw_file_fmt_flush,
 	.sector_size = raw_file_fmt_sector_size,
 };
 
 static struct xloop_file_fmt_driver raw_file_fmt_driver = {
-	.name = "RAW",
+	.name          = "RAW",
 	.file_fmt_type = XLO_FILE_FMT_RAW,
-	.ops = &raw_file_fmt_ops,
-	.owner = THIS_MODULE,
+	.ops           = &raw_file_fmt_ops,
+	.owner         = THIS_MODULE,
 };
 
 static int __init xloop_file_fmt_raw_init(void)
diff --git a/src/kernel/xloop_main.c b/src/kernel/xloop_main.c
index aa75c41..fb3f17b 100644
--- a/src/kernel/xloop_main.c
+++ b/src/kernel/xloop_main.c
@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: GPL-2.0
 /*
  * xloop_main.c
  *
@@ -97,9 +98,9 @@
 
 /* define RHEL_CHECK_VERSION macro to check CentOS version */
 #if defined(RHEL_RELEASE_CODE) && defined(RHEL_RELEASE_VERSION)
-	#define RHEL_CHECK_VERSION(CONDITION) (CONDITION)
+#define RHEL_CHECK_VERSION(CONDITION) (CONDITION)
 #else
-	#define RHEL_CHECK_VERSION(CONDITION) (0)
+#define RHEL_CHECK_VERSION(CONDITION) (0)
 #endif
 
 static DEFINE_IDR(xloop_index_idr);
@@ -114,10 +115,8 @@ struct device *xloop_device_to_dev(struct xloop_device *xlo)
 }
 EXPORT_SYMBOL(xloop_device_to_dev);
 
-static int transfer_xor(struct xloop_device *xlo, int cmd,
-			struct page *raw_page, unsigned raw_off,
-			struct page *xloop_page, unsigned xloop_off,
-			int size, sector_t real_block)
+static int transfer_xor(struct xloop_device *xlo, int cmd, struct page *raw_page, unsigned int raw_off,
+			struct page *xloop_page, unsigned int xloop_off, int size, sector_t real_block)
 {
 	char *raw_buf = kmap_atomic(raw_page) + raw_off;
 	char *xloop_buf = kmap_atomic(xloop_page) + xloop_off;
@@ -152,24 +151,16 @@ static int xor_init(struct xloop_device *xlo, const struct xloop_info64 *info)
 
 static struct xloop_func_table none_funcs = {
 	.number = XLO_CRYPT_NONE,
-}; 
+};
 
-static struct xloop_func_table xor_funcs = {
-	.number = XLO_CRYPT_XOR,
-	.transfer = transfer_xor,
-	.init = xor_init
-}; 
+static struct xloop_func_table xor_funcs = { .number = XLO_CRYPT_XOR, .transfer = transfer_xor, .init = xor_init };
 
 /* xfer_funcs[0] is special - its release function is never called */
-static struct xloop_func_table *xfer_funcs[MAX_XLO_CRYPT] = {
-	&none_funcs,
-	&xor_funcs
-};
+static struct xloop_func_table *xfer_funcs[MAX_XLO_CRYPT] = { &none_funcs, &xor_funcs };
 
 static loff_t get_xloop_size(struct xloop_device *xlo, struct file *file)
 {
-	return xloop_file_fmt_sector_size(xlo->xlo_fmt, file, xlo->xlo_offset,
-				xlo->xlo_sizelimit);
+	return xloop_file_fmt_sector_size(xlo->xlo_fmt, file, xlo->xlo_offset, xlo->xlo_sizelimit);
 }
 
 static void __xloop_update_dio(struct xloop_device *xlo, bool dio)
@@ -178,7 +169,7 @@ static void __xloop_update_dio(struct xloop_device *xlo, bool dio)
 	struct address_space *mapping = file->f_mapping;
 	struct inode *inode = mapping->host;
 	unsigned short sb_bsize = 0;
-	unsigned dio_align = 0;
+	unsigned int dio_align = 0;
 	bool use_dio;
 
 	if (inode->i_sb->s_bdev) {
@@ -197,10 +188,8 @@ static void __xloop_update_dio(struct xloop_device *xlo, bool dio)
 	 * of requests in sane applications should be PAGE_SIZE aligned
 	 */
 	if (dio) {
-		if (queue_logical_block_size(xlo->xlo_queue) >= sb_bsize &&
-				!(xlo->xlo_offset & dio_align) &&
-				mapping->a_ops->direct_IO &&
-				!xlo->transfer)
+		if (queue_logical_block_size(xlo->xlo_queue) >= sb_bsize && !(xlo->xlo_offset & dio_align) &&
+		    mapping->a_ops->direct_IO && !xlo->transfer)
 			use_dio = true;
 		else
 			use_dio = false;
@@ -237,8 +226,7 @@ static void __xloop_update_dio(struct xloop_device *xlo, bool dio)
  * xloop_validate_block_size() - validates the passed in block size
  * @bsize: size to validate
  */
-static int
-xloop_validate_block_size(unsigned short bsize)
+static int xloop_validate_block_size(unsigned short bsize)
 {
 	if (bsize < 512 || bsize > PAGE_SIZE || !is_power_of_2(bsize))
 		return -EINVAL;
@@ -274,12 +262,12 @@ static void xloop_set_size(struct xloop_device *xlo, loff_t size)
 	set_capacity_revalidate_and_notify(xlo->xlo_disk, size, false);
 #else
 	capacity = get_capacity(xlo->xlo_disk);
-    set_capacity(xlo->xlo_disk, size);
-    if (capacity != size && capacity != 0 && size != 0) {
-        char *envp[] = { "RESIZE=1", NULL };
-        kobject_uevent_env(&disk_to_dev(xlo->xlo_disk)->kobj, KOBJ_CHANGE, 
-			envp);
-    }
+	set_capacity(xlo->xlo_disk, size);
+	if (capacity != size && capacity != 0 && size != 0) {
+		char *envp[] = { "RESIZE=1", NULL };
+
+		kobject_uevent_env(&disk_to_dev(xlo->xlo_disk)->kobj, KOBJ_CHANGE, envp);
+	}
 #endif
 }
 
@@ -288,8 +276,7 @@ static void xlo_complete_rq(struct request *rq)
 	struct xloop_cmd *cmd = blk_mq_rq_to_pdu(rq);
 	blk_status_t ret = BLK_STS_OK;
 
-	if (!cmd->use_aio || cmd->ret < 0 || cmd->ret == blk_rq_bytes(rq) ||
-	    req_op(rq) != REQ_OP_READ) {
+	if (!cmd->use_aio || cmd->ret < 0 || cmd->ret == blk_rq_bytes(rq) || req_op(rq) != REQ_OP_READ) {
 		if (cmd->ret < 0)
 			ret = errno_to_blk_status(cmd->ret);
 		goto end_io;
@@ -356,17 +343,15 @@ static int do_req_filebacked(struct xloop_device *xlo, struct request *rq)
 
 static inline void xloop_update_dio(struct xloop_device *xlo)
 {
-	__xloop_update_dio(xlo, (xlo->xlo_backing_file->f_flags & O_DIRECT) |
-				xlo->use_dio);
+	__xloop_update_dio(xlo, (xlo->xlo_backing_file->f_flags & O_DIRECT) | xlo->use_dio);
 }
 
-static void xloop_reread_partitions(struct xloop_device *xlo,
-				   struct block_device *bdev)
+static void xloop_reread_partitions(struct xloop_device *xlo, struct block_device *bdev)
 {
 	int rc;
 
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 5, 0)) || \
-		RHEL_CHECK_VERSION(RHEL_RELEASE_CODE >= RHEL_RELEASE_VERSION(8, 3))
+#if (KERNEL_VERSION(5, 5, 0) <= LINUX_VERSION_CODE) ||                                                                 \
+	RHEL_CHECK_VERSION(RHEL_RELEASE_VERSION(8, 3) <= RHEL_RELEASE_CODE)
 	mutex_lock(&bdev->bd_mutex);
 	rc = bdev_disk_changed(bdev, false);
 	mutex_unlock(&bdev->bd_mutex);
@@ -374,8 +359,7 @@ static void xloop_reread_partitions(struct xloop_device *xlo,
 	rc = blkdev_reread_part(bdev);
 #endif
 	if (rc)
-		dev_warn(xloop_device_to_dev(xlo), "partition scan failed (rc=%d)\n",
-			rc);
+		dev_warn(xloop_device_to_dev(xlo), "partition scan failed (rc=%d)\n", rc);
 }
 
 static inline int is_xloop_device(struct file *file)
@@ -387,8 +371,8 @@ static inline int is_xloop_device(struct file *file)
 
 static int xloop_validate_file(struct file *file, struct block_device *bdev)
 {
-	struct inode	*inode = file->f_mapping->host;
-	struct file	*f = file;
+	struct inode *inode = file->f_mapping->host;
+	struct file *f = file;
 
 	/* Avoid recursion */
 	while (is_xloop_device(f)) {
@@ -398,9 +382,9 @@ static int xloop_validate_file(struct file *file, struct block_device *bdev)
 			return -EBADF;
 
 		l = f->f_mapping->host->i_bdev->bd_disk->private_data;
-		if (l->xlo_state != Xlo_bound) {
+		if (l->xlo_state != Xlo_bound)
 			return -EINVAL;
-		}
+
 		f = l->xlo_backing_file;
 	}
 	if (!S_ISREG(inode->i_mode) && !S_ISBLK(inode->i_mode))
@@ -416,12 +400,11 @@ static int xloop_validate_file(struct file *file, struct block_device *bdev)
  * This can only work if the xloop device is used read-only, and if the
  * new backing store is the same size and type as the old backing store.
  */
-static int xloop_change_fd(struct xloop_device *xlo, struct block_device *bdev,
-			  unsigned int arg)
+static int xloop_change_fd(struct xloop_device *xlo, struct block_device *bdev, unsigned int arg)
 {
-	struct file	*file = NULL, *old_file;
-	int		error;
-	bool		partscan;
+	struct file *file = NULL, *old_file;
+	int error;
+	bool partscan;
 
 	error = mutex_lock_killable(&xloop_ctl_mutex);
 	if (error)
@@ -457,8 +440,7 @@ static int xloop_change_fd(struct xloop_device *xlo, struct block_device *bdev,
 	mapping_set_gfp_mask(old_file->f_mapping, xlo->old_gfp_mask);
 	xlo->xlo_backing_file = file;
 	xlo->old_gfp_mask = mapping_gfp_mask(file->f_mapping);
-	mapping_set_gfp_mask(file->f_mapping,
-			     xlo->old_gfp_mask & ~(__GFP_IO|__GFP_FS));
+	mapping_set_gfp_mask(file->f_mapping, xlo->old_gfp_mask & ~(__GFP_IO | __GFP_FS));
 	xloop_update_dio(xlo);
 	blk_mq_unfreeze_queue(xlo->xlo_queue);
 	partscan = xlo->xlo_flags & XLO_FLAGS_PARTSCAN;
@@ -482,8 +464,7 @@ out_err:
 
 /* xloop sysfs attributes */
 
-static ssize_t xloop_attr_show(struct device *dev, char *page,
-			      ssize_t (*callback)(struct xloop_device *, char *))
+static ssize_t xloop_attr_show(struct device *dev, char *page, ssize_t (*callback)(struct xloop_device *, char *))
 {
 	struct gendisk *disk = dev_to_disk(dev);
 	struct xloop_device *xlo = disk->private_data;
@@ -491,15 +472,13 @@ static ssize_t xloop_attr_show(struct device *dev, char *page,
 	return callback(xlo, page);
 }
 
-#define XLOOP_ATTR_RO(_name)						\
-static ssize_t xloop_attr_##_name##_show(struct xloop_device *, char *);	\
-static ssize_t xloop_attr_do_show_##_name(struct device *d,		\
-				struct device_attribute *attr, char *b)	\
-{									\
-	return xloop_attr_show(d, b, xloop_attr_##_name##_show);		\
-}									\
-static struct device_attribute xloop_attr_##_name =			\
-	__ATTR(_name, 0444, xloop_attr_do_show_##_name, NULL);
+#define XLOOP_ATTR_RO(_name)                                                                                           \
+	static ssize_t xloop_attr_##_name##_show(struct xloop_device *, char *);                                       \
+	static ssize_t xloop_attr_do_show_##_name(struct device *d, struct device_attribute *attr, char *b)            \
+	{                                                                                                              \
+		return xloop_attr_show(d, b, xloop_attr_##_name##_show);                                               \
+	}                                                                                                              \
+	static struct device_attribute xloop_attr_##_name = __ATTR(_name, 0444, xloop_attr_do_show_##_name, NULL);
 
 static ssize_t xloop_attr_backing_file_show(struct xloop_device *xlo, char *buf)
 {
@@ -523,8 +502,7 @@ static ssize_t xloop_attr_backing_file_show(struct xloop_device *xlo, char *buf)
 	return ret;
 }
 
-static ssize_t xloop_attr_file_fmt_type_show(struct xloop_device *xlo,
-				char *buf)
+static ssize_t xloop_attr_file_fmt_type_show(struct xloop_device *xlo, char *buf)
 {
 	ssize_t len = 0;
 
@@ -574,32 +552,26 @@ XLOOP_ATTR_RO(partscan);
 XLOOP_ATTR_RO(dio);
 
 static struct attribute *xloop_attrs[] = {
-	&xloop_attr_backing_file.attr,
-	&xloop_attr_file_fmt_type.attr,
-	&xloop_attr_offset.attr,
-	&xloop_attr_sizelimit.attr,
-	&xloop_attr_autoclear.attr,
-	&xloop_attr_partscan.attr,
-	&xloop_attr_dio.attr,
-	NULL,
+	&xloop_attr_backing_file.attr, &xloop_attr_file_fmt_type.attr,
+	&xloop_attr_offset.attr,       &xloop_attr_sizelimit.attr,
+	&xloop_attr_autoclear.attr,    &xloop_attr_partscan.attr,
+	&xloop_attr_dio.attr,	       NULL,
 };
 
 static struct attribute_group xloop_attribute_group = {
-	.name = "xloop",
-	.attrs= xloop_attrs,
+	.name  = "xloop",
+	.attrs = xloop_attrs,
 };
 
 static void xloop_sysfs_init(struct xloop_device *xlo)
 {
-	xlo->sysfs_inited = !sysfs_create_group(&disk_to_dev(xlo->xlo_disk)->kobj,
-						&xloop_attribute_group);
+	xlo->sysfs_inited = !sysfs_create_group(&disk_to_dev(xlo->xlo_disk)->kobj, &xloop_attribute_group);
 }
 
 static void xloop_sysfs_exit(struct xloop_device *xlo)
 {
 	if (xlo->sysfs_inited)
-		sysfs_remove_group(&disk_to_dev(xlo->xlo_disk)->kobj,
-				   &xloop_attribute_group);
+		sysfs_remove_group(&disk_to_dev(xlo->xlo_disk)->kobj, &xloop_attribute_group);
 }
 
 static void xloop_config_discard(struct xloop_device *xlo)
@@ -622,8 +594,7 @@ static void xloop_config_discard(struct xloop_device *xlo)
 		backingq = bdev_get_queue(inode->i_bdev);
 
 		max_discard_sectors = backingq->limits.max_write_zeroes_sectors;
-		granularity = backingq->limits.discard_granularity ?:
-			queue_physical_block_size(backingq);
+		granularity = backingq->limits.discard_granularity ?: queue_physical_block_size(backingq);
 
 	/*
 	 * We use punch hole to reclaim the free space used by the
@@ -673,8 +644,7 @@ static int xloop_kthread_worker_fn(void *worker_ptr)
 static int xloop_prepare_queue(struct xloop_device *xlo)
 {
 	kthread_init_worker(&xlo->worker);
-	xlo->worker_task = kthread_run(xloop_kthread_worker_fn,
-			&xlo->worker, "xloop%d", xlo->xlo_number);
+	xlo->worker_task = kthread_run(xloop_kthread_worker_fn, &xlo->worker, "xloop%d", xlo->xlo_number);
 	if (IS_ERR(xlo->worker_task))
 		return -ENOMEM;
 	set_user_nice(xlo->worker_task, MIN_NICE);
@@ -699,8 +669,7 @@ static void xloop_update_rotational(struct xloop_device *xlo)
 		blk_queue_flag_clear(QUEUE_FLAG_NONROT, q);
 }
 
-static int
-xloop_release_xfer(struct xloop_device *xlo)
+static int xloop_release_xfer(struct xloop_device *xlo)
 {
 	int err = 0;
 	struct xloop_func_table *xfer = xlo->xlo_encryption;
@@ -715,9 +684,7 @@ xloop_release_xfer(struct xloop_device *xlo)
 	return err;
 }
 
-static int
-xloop_init_xfer(struct xloop_device *xlo, struct xloop_func_table *xfer,
-	       const struct xloop_info64 *i)
+static int xloop_init_xfer(struct xloop_device *xlo, struct xloop_func_table *xfer, const struct xloop_info64 *i)
 {
 	int err = 0;
 
@@ -744,15 +711,13 @@ xloop_init_xfer(struct xloop_device *xlo, struct xloop_func_table *xfer,
  * Configures the xloop device parameters according to the passed
  * in xloop_info64 configuration.
  */
-static int
-xloop_set_status_from_info(struct xloop_device *xlo,
-			  const struct xloop_info64 *info)
+static int xloop_set_status_from_info(struct xloop_device *xlo, const struct xloop_info64 *info)
 {
 	int err;
 	struct xloop_func_table *xfer;
 	kuid_t uid = current_uid();
 
-	if ((unsigned int) info->xlo_encrypt_key_size > XLO_KEY_SIZE)
+	if ((unsigned int)info->xlo_encrypt_key_size > XLO_KEY_SIZE)
 		return -EINVAL;
 
 	err = xloop_release_xfer(xlo);
@@ -778,8 +743,8 @@ xloop_set_status_from_info(struct xloop_device *xlo,
 	xlo->xlo_sizelimit = info->xlo_sizelimit;
 	memcpy(xlo->xlo_file_name, info->xlo_file_name, XLO_NAME_SIZE);
 	memcpy(xlo->xlo_crypt_name, info->xlo_crypt_name, XLO_NAME_SIZE);
-	xlo->xlo_file_name[XLO_NAME_SIZE-1] = 0;
-	xlo->xlo_crypt_name[XLO_NAME_SIZE-1] = 0;
+	xlo->xlo_file_name[XLO_NAME_SIZE - 1] = 0;
+	xlo->xlo_crypt_name[XLO_NAME_SIZE - 1] = 0;
 
 	if (!xfer)
 		xfer = &none_funcs;
@@ -792,28 +757,26 @@ xloop_set_status_from_info(struct xloop_device *xlo,
 	xlo->xlo_init[0] = info->xlo_init[0];
 	xlo->xlo_init[1] = info->xlo_init[1];
 	if (info->xlo_encrypt_key_size) {
-		memcpy(xlo->xlo_encrypt_key, info->xlo_encrypt_key,
-		       info->xlo_encrypt_key_size);
+		memcpy(xlo->xlo_encrypt_key, info->xlo_encrypt_key, info->xlo_encrypt_key_size);
 		xlo->xlo_key_owner = uid;
 	}
 
 	return 0;
 }
 
-static int xloop_configure(struct xloop_device *xlo, fmode_t mode,
-			  struct block_device *bdev,
-			  const struct xloop_config *config)
+static int xloop_configure(struct xloop_device *xlo, fmode_t mode, struct block_device *bdev,
+			   const struct xloop_config *config)
 {
-	struct file	*file;
-	struct inode	*inode;
+	struct file *file;
+	struct inode *inode;
 	struct address_space *mapping;
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 2, 0)
 	struct block_device *claimed_bdev = NULL;
 #endif
-	int		error;
-	loff_t		size;
-	bool		partscan;
-	unsigned short  bsize;
+	int error;
+	loff_t size;
+	bool partscan;
+	unsigned short bsize;
 
 	/* This is safe, since we have a reference from open(). */
 	__module_get(THIS_MODULE);
@@ -877,8 +840,7 @@ static int xloop_configure(struct xloop_device *xlo, fmode_t mode,
 	if (error)
 		goto out_unlock;
 
-	if (!(file->f_mode & FMODE_WRITE) || !(mode & FMODE_WRITE) ||
-	    !file->f_op->write_iter)
+	if (!(file->f_mode & FMODE_WRITE) || !(mode & FMODE_WRITE) || !file->f_op->write_iter)
 		xlo->xlo_flags |= XLO_FLAGS_READ_ONLY;
 
 	error = xloop_prepare_queue(xlo);
@@ -891,10 +853,9 @@ static int xloop_configure(struct xloop_device *xlo, fmode_t mode,
 	xlo->xlo_device = bdev;
 	xlo->xlo_backing_file = file;
 	xlo->old_gfp_mask = mapping_gfp_mask(mapping);
-	mapping_set_gfp_mask(mapping, xlo->old_gfp_mask & ~(__GFP_IO|__GFP_FS));
+	mapping_set_gfp_mask(mapping, xlo->old_gfp_mask & ~(__GFP_IO | __GFP_FS));
 
-	error = xloop_file_fmt_init(xlo->xlo_fmt,
-				config->info.xlo_file_fmt_type);
+	error = xloop_file_fmt_init(xlo->xlo_fmt, config->info.xlo_file_fmt_type);
 	if (error)
 		goto out_unlock;
 
@@ -920,8 +881,7 @@ static int xloop_configure(struct xloop_device *xlo, fmode_t mode,
 	size = get_xloop_size(xlo, file);
 	xloop_set_size(xlo, size);
 
-	set_blocksize(bdev, S_ISBLK(inode->i_mode) ?
-		      block_size(inode->i_bdev) : PAGE_SIZE);
+	set_blocksize(bdev, S_ISBLK(inode->i_mode) ? block_size(inode->i_bdev) : PAGE_SIZE);
 
 	xlo->xlo_state = Xlo_bound;
 	if (part_shift)
@@ -1043,8 +1003,7 @@ out_unlock:
 		 * must be at least one and it can only become zero when the
 		 * current holder is released.
 		 */
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 5, 0) || \
-		RHEL_CHECK_VERSION(RHEL_RELEASE_CODE >= RHEL_RELEASE_VERSION(8, 3))
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 5, 0) || RHEL_CHECK_VERSION(RHEL_RELEASE_VERSION(8, 3) <= RHEL_RELEASE_CODE)
 		if (!release)
 			mutex_lock(&bdev->bd_mutex);
 		err = bdev_disk_changed(bdev, false);
@@ -1056,8 +1015,8 @@ out_unlock:
 			mutex_unlock(&bdev->bd_mutex);
 #endif
 		if (err)
-			dev_warn(xloop_device_to_dev(xlo), "partition scan failed "
-				"(rc=%d)\n", err);
+			dev_warn(xloop_device_to_dev(xlo), "partition scan failed (rc=%d)\n", err);
+
 		/* Device is gone, no point in returning error */
 		err = 0;
 	}
@@ -1121,8 +1080,7 @@ static int xloop_clr_fd(struct xloop_device *xlo)
 	return __xloop_clr_fd(xlo, false);
 }
 
-static int
-xloop_set_status(struct xloop_device *xlo, const struct xloop_info64 *info)
+static int xloop_set_status(struct xloop_device *xlo, const struct xloop_info64 *info)
 {
 	int err;
 	struct block_device *bdev;
@@ -1134,9 +1092,7 @@ xloop_set_status(struct xloop_device *xlo, const struct xloop_info64 *info)
 	err = mutex_lock_killable(&xloop_ctl_mutex);
 	if (err)
 		return err;
-	if (xlo->xlo_encrypt_key_size &&
-	    !uid_eq(xlo->xlo_key_owner, uid) &&
-	    !capable(CAP_SYS_ADMIN)) {
+	if (xlo->xlo_encrypt_key_size && !uid_eq(xlo->xlo_key_owner, uid) && !capable(CAP_SYS_ADMIN)) {
 		err = -EPERM;
 		goto out_unlock;
 	}
@@ -1145,8 +1101,7 @@ xloop_set_status(struct xloop_device *xlo, const struct xloop_info64 *info)
 		goto out_unlock;
 	}
 
-	if (xlo->xlo_offset != info->xlo_offset ||
-	    xlo->xlo_sizelimit != info->xlo_sizelimit) {
+	if (xlo->xlo_offset != info->xlo_offset || xlo->xlo_sizelimit != info->xlo_sizelimit) {
 		size_changed = true;
 		sync_blockdev(xlo->xlo_device);
 		invalidate_bdev(xlo->xlo_device);
@@ -1158,9 +1113,9 @@ xloop_set_status(struct xloop_device *xlo, const struct xloop_info64 *info)
 	if (size_changed && xlo->xlo_device->bd_inode->i_mapping->nrpages) {
 		/* If any pages were dirtied after invalidate_bdev(), try again */
 		err = -EAGAIN;
-		dev_warn(xloop_device_to_dev(xlo), "xloop device has still dirty "
-			"pages (nrpages=%lu)\n",
-			xlo->xlo_device->bd_inode->i_mapping->nrpages);
+		dev_warn(xloop_device_to_dev(xlo),
+			 "xloop device has still dirty pages (nrpages=%lu)\n",
+			 xlo->xlo_device->bd_inode->i_mapping->nrpages);
 		goto out_unfreeze;
 	}
 
@@ -1183,13 +1138,13 @@ xloop_set_status(struct xloop_device *xlo, const struct xloop_info64 *info)
 		if (err)
 			goto out_unfreeze;
 
-		/* After change of the file format, recalculate the capacity of
-		 * the loop device. */
+		/* After change of the file format, recalculate the capacity of the xloop device. */
 		size_changed = true;
 	}
 
 	if (size_changed) {
 		loff_t new_size = get_xloop_size(xlo, xlo->xlo_backing_file);
+
 		xloop_set_size(xlo, new_size);
 	}
 
@@ -1201,8 +1156,7 @@ xloop_set_status(struct xloop_device *xlo, const struct xloop_info64 *info)
 out_unfreeze:
 	blk_mq_unfreeze_queue(xlo->xlo_queue);
 
-	if (!err && (xlo->xlo_flags & XLO_FLAGS_PARTSCAN) &&
-	     !(prev_xlo_flags & XLO_FLAGS_PARTSCAN)) {
+	if (!err && (xlo->xlo_flags & XLO_FLAGS_PARTSCAN) && !(prev_xlo_flags & XLO_FLAGS_PARTSCAN)) {
 		xlo->xlo_disk->flags &= ~GENHD_FL_NO_PART_SCAN;
 		bdev = xlo->xlo_device;
 		partscan = true;
@@ -1215,8 +1169,7 @@ out_unlock:
 	return err;
 }
 
-static int
-xloop_get_status(struct xloop_device *xlo, struct xloop_info64 *info)
+static int xloop_get_status(struct xloop_device *xlo, struct xloop_info64 *info)
 {
 	struct path path;
 	struct kstat stat;
@@ -1237,12 +1190,10 @@ xloop_get_status(struct xloop_device *xlo, struct xloop_info64 *info)
 	info->xlo_flags = xlo->xlo_flags;
 	memcpy(info->xlo_file_name, xlo->xlo_file_name, XLO_NAME_SIZE);
 	memcpy(info->xlo_crypt_name, xlo->xlo_crypt_name, XLO_NAME_SIZE);
-	info->xlo_encrypt_type =
-		xlo->xlo_encryption ? xlo->xlo_encryption->number : 0;
+	info->xlo_encrypt_type = xlo->xlo_encryption ? xlo->xlo_encryption->number : 0;
 	if (xlo->xlo_encrypt_key_size && capable(CAP_SYS_ADMIN)) {
 		info->xlo_encrypt_key_size = xlo->xlo_encrypt_key_size;
-		memcpy(info->xlo_encrypt_key, xlo->xlo_encrypt_key,
-		       xlo->xlo_encrypt_key_size);
+		memcpy(info->xlo_encrypt_key, xlo->xlo_encrypt_key, xlo->xlo_encrypt_key_size);
 	}
 
 	/* Drop xloop_ctl_mutex while we call into the filesystem. */
@@ -1259,8 +1210,7 @@ xloop_get_status(struct xloop_device *xlo, struct xloop_info64 *info)
 	return ret;
 }
 
-static void
-xloop_info64_from_old(const struct xloop_info *info, struct xloop_info64 *info64)
+static void xloop_info64_from_old(const struct xloop_info *info, struct xloop_info64 *info64)
 {
 	memset(info64, 0, sizeof(*info64));
 	info64->xlo_number = info->xlo_number;
@@ -1282,8 +1232,7 @@ xloop_info64_from_old(const struct xloop_info *info, struct xloop_info64 *info64
 	memcpy(info64->xlo_encrypt_key, info->xlo_encrypt_key, XLO_KEY_SIZE);
 }
 
-static int
-xloop_info64_to_old(const struct xloop_info64 *info64, struct xloop_info *info)
+static int xloop_info64_to_old(const struct xloop_info64 *info64, struct xloop_info *info)
 {
 	memset(info, 0, sizeof(*info));
 	info->xlo_number = info64->xlo_number;
@@ -1304,39 +1253,35 @@ xloop_info64_to_old(const struct xloop_info64 *info64, struct xloop_info *info)
 	memcpy(info->xlo_encrypt_key, info64->xlo_encrypt_key, XLO_KEY_SIZE);
 
 	/* error in case values were truncated */
-	if (info->xlo_device != info64->xlo_device ||
-	    info->xlo_rdevice != info64->xlo_rdevice ||
-	    info->xlo_inode != info64->xlo_inode ||
-	    info->xlo_offset != info64->xlo_offset)
+	if (info->xlo_device != info64->xlo_device || info->xlo_rdevice != info64->xlo_rdevice ||
+	    info->xlo_inode != info64->xlo_inode || info->xlo_offset != info64->xlo_offset)
 		return -EOVERFLOW;
 
 	return 0;
 }
 
-static int
-xloop_set_status_old(struct xloop_device *xlo, const struct xloop_info __user *arg)
+static int xloop_set_status_old(struct xloop_device *xlo, const struct xloop_info __user *arg)
 {
 	struct xloop_info info;
 	struct xloop_info64 info64;
 
-	if (copy_from_user(&info, arg, sizeof (struct xloop_info)))
+	if (copy_from_user(&info, arg, sizeof(struct xloop_info)))
 		return -EFAULT;
 	xloop_info64_from_old(&info, &info64);
 	return xloop_set_status(xlo, &info64);
 }
 
-static int
-xloop_set_status64(struct xloop_device *xlo, const struct xloop_info64 __user *arg)
+static int xloop_set_status64(struct xloop_device *xlo, const struct xloop_info64 __user *arg)
 {
 	struct xloop_info64 info64;
 
-	if (copy_from_user(&info64, arg, sizeof (struct xloop_info64)))
+	if (copy_from_user(&info64, arg, sizeof(struct xloop_info64)))
 		return -EFAULT;
 	return xloop_set_status(xlo, &info64);
 }
 
-static int
-xloop_get_status_old(struct xloop_device *xlo, struct xloop_info __user *arg) {
+static int xloop_get_status_old(struct xloop_device *xlo, struct xloop_info __user *arg)
+{
 	struct xloop_info info;
 	struct xloop_info64 info64;
 	int err;
@@ -1352,8 +1297,8 @@ xloop_get_status_old(struct xloop_device *xlo, struct xloop_info __user *arg) {
 	return err;
 }
 
-static int
-xloop_get_status64(struct xloop_device *xlo, struct xloop_info64 __user *arg) {
+static int xloop_get_status64(struct xloop_device *xlo, struct xloop_info64 __user *arg)
+{
 	struct xloop_info64 info64;
 	int err;
 
@@ -1382,6 +1327,7 @@ static int xloop_set_capacity(struct xloop_device *xlo)
 static int xloop_set_dio(struct xloop_device *xlo, unsigned long arg)
 {
 	int error = -ENXIO;
+
 	if (xlo->xlo_state != Xlo_bound)
 		goto out;
 
@@ -1389,7 +1335,7 @@ static int xloop_set_dio(struct xloop_device *xlo, unsigned long arg)
 	if (xlo->use_dio == !!arg)
 		return 0;
 	error = -EINVAL;
- out:
+out:
 	return error;
 }
 
@@ -1415,9 +1361,9 @@ static int xloop_set_block_size(struct xloop_device *xlo, unsigned long arg)
 	/* invalidate_bdev should have truncated all the pages */
 	if (xlo->xlo_device->bd_inode->i_mapping->nrpages) {
 		err = -EAGAIN;
-		dev_warn(xloop_device_to_dev(xlo), "xloop device has still dirty "
-			"pages (nrpages=%lu)\n",
-			xlo->xlo_device->bd_inode->i_mapping->nrpages);
+		dev_warn(xloop_device_to_dev(xlo),
+			 "xloop device has still dirty pages (nrpages=%lu)\n",
+			 xlo->xlo_device->bd_inode->i_mapping->nrpages);
 		goto out_unfreeze;
 	}
 
@@ -1431,8 +1377,7 @@ out_unfreeze:
 	return err;
 }
 
-static int xlo_simple_ioctl(struct xloop_device *xlo, unsigned int cmd,
-			   unsigned long arg)
+static int xlo_simple_ioctl(struct xloop_device *xlo, unsigned int cmd, unsigned long arg)
 {
 	int err;
 
@@ -1456,11 +1401,10 @@ static int xlo_simple_ioctl(struct xloop_device *xlo, unsigned int cmd,
 	return err;
 }
 
-static int xlo_ioctl(struct block_device *bdev, fmode_t mode,
-	unsigned int cmd, unsigned long arg)
+static int xlo_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd, unsigned long arg)
 {
 	struct xloop_device *xlo = bdev->bd_disk->private_data;
-	void __user *argp = (void __user *) arg;
+	void __user *argp = (void __user *)arg;
 	int err;
 
 	switch (cmd) {
@@ -1491,17 +1435,15 @@ static int xlo_ioctl(struct block_device *bdev, fmode_t mode,
 		return xloop_clr_fd(xlo);
 	case XLOOP_SET_STATUS:
 		err = -EPERM;
-		if ((mode & FMODE_WRITE) || capable(CAP_SYS_ADMIN)) {
+		if ((mode & FMODE_WRITE) || capable(CAP_SYS_ADMIN))
 			err = xloop_set_status_old(xlo, argp);
-		}
 		break;
 	case XLOOP_GET_STATUS:
 		return xloop_get_status_old(xlo, argp);
 	case XLOOP_SET_STATUS64:
 		err = -EPERM;
-		if ((mode & FMODE_WRITE) || capable(CAP_SYS_ADMIN)) {
+		if ((mode & FMODE_WRITE) || capable(CAP_SYS_ADMIN))
 			err = xloop_set_status64(xlo, argp);
-		}
 		break;
 	case XLOOP_GET_STATUS64:
 		return xloop_get_status64(xlo, argp);
@@ -1513,7 +1455,7 @@ static int xlo_ioctl(struct block_device *bdev, fmode_t mode,
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 4, 0)
 		fallthrough;
 #else
-		/* fall through */
+			/* fall through */
 #endif
 	default:
 		err = xlo_simple_ioctl(xlo, cmd, arg);
@@ -1525,28 +1467,26 @@ static int xlo_ioctl(struct block_device *bdev, fmode_t mode,
 
 #ifdef CONFIG_COMPAT
 struct compat_xloop_info {
-	compat_int_t	xlo_number;      /* ioctl r/o */
-	compat_dev_t	xlo_device;      /* ioctl r/o */
-	compat_ulong_t	xlo_inode;       /* ioctl r/o */
-	compat_dev_t	xlo_rdevice;     /* ioctl r/o */
-	compat_int_t	xlo_offset;
-	compat_int_t	xlo_encrypt_type;
-	compat_int_t	xlo_encrypt_key_size;    /* ioctl w/o */
-	compat_int_t	xlo_flags;       /* ioctl r/o */
-	char		xlo_name[XLO_NAME_SIZE];
-	unsigned char	xlo_encrypt_key[XLO_KEY_SIZE]; /* ioctl w/o */
-	compat_ulong_t	xlo_init[2];
-	char		reserved[4];
-	compat_int_t	xlo_file_fmt_type;
+	compat_int_t   xlo_number;                    /* ioctl r/o */
+	compat_dev_t   xlo_device;                    /* ioctl r/o */
+	compat_ulong_t xlo_inode;                     /* ioctl r/o */
+	compat_dev_t   xlo_rdevice;                   /* ioctl r/o */
+	compat_int_t   xlo_offset;
+	compat_int_t   xlo_encrypt_type;
+	compat_int_t   xlo_encrypt_key_size;          /* ioctl w/o */
+	compat_int_t   xlo_flags;                     /* ioctl r/o */
+	char           xlo_name[XLO_NAME_SIZE];
+	unsigned char  xlo_encrypt_key[XLO_KEY_SIZE]; /* ioctl w/o */
+	compat_ulong_t xlo_init[2];
+	char           reserved[4];
+	compat_int_t   xlo_file_fmt_type;
 };
 
 /*
  * Transfer 32-bit compatibility structure in userspace to 64-bit xloop info
  * - noinlined to reduce stack space usage in main part of driver
  */
-static noinline int
-xloop_info64_from_compat(const struct compat_xloop_info __user *arg,
-			struct xloop_info64 *info64)
+static noinline int xloop_info64_from_compat(const struct compat_xloop_info __user *arg, struct xloop_info64 *info64)
 {
 	struct compat_xloop_info info;
 
@@ -1578,9 +1518,7 @@ xloop_info64_from_compat(const struct compat_xloop_info __user *arg,
  * Transfer 64-bit xloop info to 32-bit compatibility structure in userspace
  * - noinlined to reduce stack space usage in main part of driver
  */
-static noinline int
-xloop_info64_to_compat(const struct xloop_info64 *info64,
-		      struct compat_xloop_info __user *arg)
+static noinline int xloop_info64_to_compat(const struct xloop_info64 *info64, struct compat_xloop_info __user *arg)
 {
 	struct compat_xloop_info info;
 
@@ -1603,13 +1541,10 @@ xloop_info64_to_compat(const struct xloop_info64 *info64,
 	memcpy(info.xlo_encrypt_key, info64->xlo_encrypt_key, XLO_KEY_SIZE);
 
 	/* error in case values were truncated */
-	if (info.xlo_device != info64->xlo_device ||
-	    info.xlo_rdevice != info64->xlo_rdevice ||
-	    info.xlo_inode != info64->xlo_inode ||
-	    info.xlo_offset != info64->xlo_offset ||
-	    info.xlo_init[0] != info64->xlo_init[0] ||
-	    info.xlo_init[1] != info64->xlo_init[1] ||
-		info.xlo_file_fmt_type != info64->xlo_file_fmt_type)
+	if (info.xlo_device != info64->xlo_device || info.xlo_rdevice != info64->xlo_rdevice ||
+	    info.xlo_inode != info64->xlo_inode || info.xlo_offset != info64->xlo_offset ||
+	    info.xlo_init[0] != info64->xlo_init[0] || info.xlo_init[1] != info64->xlo_init[1] ||
+	    info.xlo_file_fmt_type != info64->xlo_file_fmt_type)
 		return -EOVERFLOW;
 
 	if (copy_to_user(arg, &info, sizeof(info)))
@@ -1617,9 +1552,7 @@ xloop_info64_to_compat(const struct xloop_info64 *info64,
 	return 0;
 }
 
-static int
-xloop_set_status_compat(struct xloop_device *xlo,
-		       const struct compat_xloop_info __user *arg)
+static int xloop_set_status_compat(struct xloop_device *xlo, const struct compat_xloop_info __user *arg)
 {
 	struct xloop_info64 info64;
 	int ret;
@@ -1630,9 +1563,7 @@ xloop_set_status_compat(struct xloop_device *xlo,
 	return xloop_set_status(xlo, &info64);
 }
 
-static int
-xloop_get_status_compat(struct xloop_device *xlo,
-		       struct compat_xloop_info __user *arg)
+static int xloop_get_status_compat(struct xloop_device *xlo, struct compat_xloop_info __user *arg)
 {
 	struct xloop_info64 info64;
 	int err;
@@ -1645,27 +1576,24 @@ xloop_get_status_compat(struct xloop_device *xlo,
 	return err;
 }
 
-static int xlo_compat_ioctl(struct block_device *bdev, fmode_t mode,
-			   unsigned int cmd, unsigned long arg)
+static int xlo_compat_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd, unsigned long arg)
 {
 	struct xloop_device *xlo = bdev->bd_disk->private_data;
 	int err;
 
-	switch(cmd) {
+	switch (cmd) {
 	case XLOOP_SET_STATUS:
-		err = xloop_set_status_compat(xlo,
-			     (const struct compat_xloop_info __user *)arg);
+		err = xloop_set_status_compat(xlo, (const struct compat_xloop_info __user *)arg);
 		break;
 	case XLOOP_GET_STATUS:
-		err = xloop_get_status_compat(xlo,
-				     (struct compat_xloop_info __user *)arg);
+		err = xloop_get_status_compat(xlo, (struct compat_xloop_info __user *)arg);
 		break;
 	case XLOOP_SET_CAPACITY:
 	case XLOOP_CLR_FD:
 	case XLOOP_GET_STATUS64:
 	case XLOOP_SET_STATUS64:
 	case XLOOP_CONFIGURE:
-		arg = (unsigned long) compat_ptr(arg);
+		arg = (unsigned long)compat_ptr(arg);
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 4, 0)
 		fallthrough;
 #else
@@ -1739,12 +1667,12 @@ out_unlock:
 }
 
 static const struct block_device_operations xlo_fops = {
-	.owner =	THIS_MODULE,
-	.open =		xlo_open,
-	.release =	xlo_release,
-	.ioctl =	xlo_ioctl,
+	.owner        = THIS_MODULE,
+	.open         = xlo_open,
+	.release      = xlo_release,
+	.ioctl        = xlo_ioctl,
 #ifdef CONFIG_COMPAT
-	.compat_ioctl =	xlo_compat_ioctl,
+	.compat_ioctl = xlo_compat_ioctl,
 #endif
 };
 
@@ -1770,6 +1698,7 @@ int xloop_register_transfer(struct xloop_func_table *funcs)
 	xfer_funcs[n] = funcs;
 	return 0;
 }
+EXPORT_SYMBOL(xloop_register_transfer);
 
 static int unregister_transfer_cb(int id, void *ptr, void *data)
 {
@@ -1788,19 +1717,18 @@ int xloop_unregister_transfer(int number)
 	unsigned int n = number;
 	struct xloop_func_table *xfer;
 
-	if (n == 0 || n >= MAX_XLO_CRYPT || (xfer = xfer_funcs[n]) == NULL)
+	xfer = xfer_funcs[n];
+
+	if (n == 0 || n >= MAX_XLO_CRYPT || xfer == NULL)
 		return -EINVAL;
 
 	xfer_funcs[n] = NULL;
 	idr_for_each(&xloop_index_idr, &unregister_transfer_cb, xfer);
 	return 0;
 }
-
-EXPORT_SYMBOL(xloop_register_transfer);
 EXPORT_SYMBOL(xloop_unregister_transfer);
 
-static blk_status_t xloop_queue_rq(struct blk_mq_hw_ctx *hctx,
-		const struct blk_mq_queue_data *bd)
+static blk_status_t xloop_queue_rq(struct blk_mq_hw_ctx *hctx, const struct blk_mq_queue_data *bd)
 {
 	struct request *rq = bd->rq;
 	struct xloop_cmd *cmd = blk_mq_rq_to_pdu(rq);
@@ -1848,7 +1776,7 @@ static void xloop_handle_cmd(struct xloop_cmd *cmd)
 	}
 
 	ret = do_req_filebacked(xlo, rq);
- failed:
+failed:
 	/* complete non-aio request */
 	if (!cmd->use_aio || ret) {
 		if (ret == -EOPNOTSUPP)
@@ -1866,14 +1794,13 @@ static void xloop_handle_cmd(struct xloop_cmd *cmd)
 
 static void xloop_queue_work(struct kthread_work *work)
 {
-	struct xloop_cmd *cmd =
-		container_of(work, struct xloop_cmd, work);
+	struct xloop_cmd *cmd = container_of(work, struct xloop_cmd, work);
 
 	xloop_handle_cmd(cmd);
 }
 
-static int xloop_init_request(struct blk_mq_tag_set *set, struct request *rq,
-		unsigned int hctx_idx, unsigned int numa_node)
+static int xloop_init_request(struct blk_mq_tag_set *set, struct request *rq, unsigned int hctx_idx,
+			      unsigned int numa_node)
 {
 	struct xloop_cmd *cmd = blk_mq_rq_to_pdu(rq);
 
@@ -1882,9 +1809,9 @@ static int xloop_init_request(struct blk_mq_tag_set *set, struct request *rq,
 }
 
 static const struct blk_mq_ops xloop_mq_ops = {
-	.queue_rq     = xloop_queue_rq,
+	.queue_rq = xloop_queue_rq,
 	.init_request = xloop_init_request,
-	.complete     = xlo_complete_rq,
+	.complete = xlo_complete_rq,
 };
 
 static struct dentry *xloop_dbgfs_dir;
@@ -1982,21 +1909,24 @@ static int xloop_add(struct xloop_device **l, int i)
 		disk->flags |= GENHD_FL_NO_PART_SCAN;
 	disk->flags |= GENHD_FL_EXT_DEVT;
 	atomic_set(&xlo->xlo_refcnt, 0);
-	xlo->xlo_number		= i;
+	xlo->xlo_number = i;
 	spin_lock_init(&xlo->xlo_lock);
-	disk->major		= XLOOP_MAJOR;
-	disk->first_minor	= i << part_shift;
-	disk->fops		= &xlo_fops;
-	disk->private_data	= xlo;
-	disk->queue		= xlo->xlo_queue;
+	disk->major = XLOOP_MAJOR;
+	disk->first_minor = i << part_shift;
+	disk->fops = &xlo_fops;
+	disk->private_data = xlo;
+	disk->queue = xlo->xlo_queue;
 	sprintf(disk->disk_name, "xloop%d", i);
 	add_disk(disk);
 	*l = xlo;
 
-	/* initialize debugfs entries */
-	/* create for each loop device a debugfs directory under 'loop' if
+	/*
+	 * initialize debugfs entries
+	 *
+	 * create for each loop device a debugfs directory under 'loop' if
 	 * the 'block' directory exists, otherwise create the loop directory in
-	 * the root directory */
+	 * the root directory
+	 */
 #ifdef CONFIG_DEBUG_FS
 	xlo->xlo_dbgfs_dir = debugfs_create_dir(disk->disk_name, xloop_dbgfs_dir);
 
@@ -2092,8 +2022,7 @@ static struct kobject *xloop_probe(dev_t dev, int *part, void *data)
 	return kobj;
 }
 
-static long xloop_control_ioctl(struct file *file, unsigned int cmd,
-			       unsigned long parm)
+static long xloop_control_ioctl(struct file *file, unsigned int cmd, unsigned long parm)
 {
 	struct xloop_device *xlo;
 	int ret;
@@ -2102,7 +2031,7 @@ static long xloop_control_ioctl(struct file *file, unsigned int cmd,
 	if (ret)
 		return ret;
 
-	ret = -ENOSYS;
+	ret = -EINVAL;
 	switch (cmd) {
 	case XLOOP_CTL_ADD:
 		ret = xloop_lookup(&xlo, parm);
@@ -2140,17 +2069,17 @@ static long xloop_control_ioctl(struct file *file, unsigned int cmd,
 }
 
 static const struct file_operations xloop_ctl_fops = {
-	.open		= nonseekable_open,
-	.unlocked_ioctl	= xloop_control_ioctl,
-	.compat_ioctl	= xloop_control_ioctl,
-	.owner		= THIS_MODULE,
-	.llseek		= noop_llseek,
+	.open           = nonseekable_open,
+	.unlocked_ioctl = xloop_control_ioctl,
+	.compat_ioctl   = xloop_control_ioctl,
+	.owner          = THIS_MODULE,
+	.llseek         = noop_llseek,
 };
 
 static struct miscdevice xloop_misc = {
-	.minor		= XLOOP_CTRL_MINOR,
-	.name		= "xloop-control",
-	.fops		= &xloop_ctl_fops,
+	.minor = XLOOP_CTRL_MINOR,
+	.name  = "xloop-control",
+	.fops  = &xloop_ctl_fops,
 };
 
 MODULE_ALIAS_MISCDEV(XLOOP_CTRL_MINOR);
@@ -2205,7 +2134,6 @@ static int __init xloop_init(void)
 	if (err < 0)
 		goto err_out;
 
-
 	if (register_blkdev(XLOOP_MAJOR, "xloop")) {
 		err = -EIO;
 		goto misc_out;
@@ -2219,8 +2147,7 @@ static int __init xloop_init(void)
 	}
 #endif
 
-	blk_register_region(MKDEV(XLOOP_MAJOR, 0), range,
-				  THIS_MODULE, xloop_probe, NULL, NULL);
+	blk_register_region(MKDEV(XLOOP_MAJOR, 0), range, THIS_MODULE, xloop_probe, NULL, NULL);
 
 	/* pre-create number of devices given by config or max_xloop */
 	mutex_lock(&xloop_ctl_mutex);
diff --git a/src/kernel/xloop_main.h b/src/kernel/xloop_main.h
index e1b4cb6..97c2654 100644
--- a/src/kernel/xloop_main.h
+++ b/src/kernel/xloop_main.h
@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: GPL-2.0 */
 /*
  * loop_main.h
  *
@@ -32,76 +33,72 @@ enum {
 struct xloop_func_table;
 
 struct xloop_device {
-	int		xlo_number;
-	atomic_t	xlo_refcnt;
-	loff_t		xlo_offset;
-	loff_t		xlo_sizelimit;
-	int		xlo_flags;
-	int		(*transfer)(struct xloop_device *, int cmd,
-				    struct page *raw_page, unsigned raw_off,
-				    struct page *xloop_page, unsigned xloop_off,
-				    int size, sector_t real_block);
-	char		xlo_file_name[XLO_NAME_SIZE];
-	char		xlo_crypt_name[XLO_NAME_SIZE];
-	char		xlo_encrypt_key[XLO_KEY_SIZE];
-	int		xlo_encrypt_key_size;
+	int                     xlo_number;
+	atomic_t                xlo_refcnt;
+	loff_t                  xlo_offset;
+	loff_t                  xlo_sizelimit;
+	int                     xlo_flags;
+	int                    (*transfer)(struct xloop_device *xlo, int cmd, struct page *raw_page,
+					unsigned int raw_off, struct page *xloop_page, unsigned int xloop_off,
+					int size, sector_t real_block);
+	char                    xlo_file_name[XLO_NAME_SIZE];
+	char                    xlo_crypt_name[XLO_NAME_SIZE];
+	char                    xlo_encrypt_key[XLO_KEY_SIZE];
+	int                     xlo_encrypt_key_size;
 	struct xloop_func_table *xlo_encryption;
-	__u32           xlo_init[2];
-	kuid_t		xlo_key_owner;	/* Who set the key */
-	int		(*ioctl)(struct xloop_device *, int cmd, 
-				 unsigned long arg); 
+	__u32                   xlo_init[2];
+	kuid_t                  xlo_key_owner; /* Who set the key */
+	int                     (*ioctl)(struct xloop_device *xlo, int cmd, unsigned long arg);
 
-	struct xloop_file_fmt *xlo_fmt;
+	struct xloop_file_fmt   *xlo_fmt;
 
-	struct file *	xlo_backing_file;
-	struct block_device *xlo_device;
-	void		*key_data; 
+	struct file             *xlo_backing_file;
+	struct block_device     *xlo_device;
+	void                    *key_data;
 
-	gfp_t		old_gfp_mask;
+	gfp_t                   old_gfp_mask;
 
-	spinlock_t		xlo_lock;
-	int			xlo_state;
-	struct kthread_worker	worker;
-	struct task_struct	*worker_task;
-	bool			use_dio;
-	bool			sysfs_inited;
+	spinlock_t              xlo_lock;
+	int                     xlo_state;
+	struct kthread_worker   worker;
+	struct task_struct      *worker_task;
+	bool                    use_dio;
+	bool                    sysfs_inited;
 
-	struct request_queue	*xlo_queue;
-	struct blk_mq_tag_set	tag_set;
-	struct gendisk		*xlo_disk;
+	struct request_queue    *xlo_queue;
+	struct blk_mq_tag_set   tag_set;
+	struct gendisk          *xlo_disk;
 
 #ifdef CONFIG_DEBUG_FS
-	struct dentry *xlo_dbgfs_dir;
+	struct dentry           *xlo_dbgfs_dir;
 #endif
 };
 
 struct xloop_cmd {
-	struct kthread_work work;
-	bool use_aio; /* use AIO interface to handle I/O */
-	atomic_t ref; /* only for aio */
-	long ret;
-	struct kiocb iocb;
-	struct bio_vec *bvec;
+	struct kthread_work        work;
+	bool                       use_aio; /* use AIO interface to handle I/O */
+	atomic_t                   ref;     /* only for aio */
+	long                       ret;
+	struct kiocb               iocb;
+	struct bio_vec             *bvec;
 	struct cgroup_subsys_state *css;
 };
 
 /* Support for loadable transfer modules */
 struct xloop_func_table {
-	int number;	/* filter type */ 
-	int (*transfer)(struct xloop_device *xlo, int cmd,
-			struct page *raw_page, unsigned raw_off,
-			struct page *xloop_page, unsigned xloop_off,
-			int size, sector_t real_block);
-	int (*init)(struct xloop_device *, const struct xloop_info64 *); 
+	int           number; /* filter type */
+	int           (*transfer)(struct xloop_device *xlo, int cmd, struct page *raw_page, unsigned int raw_off,
+				struct page *xloop_page, unsigned int xloop_off, int size, sector_t real_block);
+	int           (*init)(struct xloop_device *xlo, const struct xloop_info64 *info);
 	/* release is called from xloop_unregister_transfer or clr_fd */
-	int (*release)(struct xloop_device *); 
-	int (*ioctl)(struct xloop_device *, int cmd, unsigned long arg);
+	int           (*release)(struct xloop_device *xlo);
+	int           (*ioctl)(struct xloop_device *xlo, int cmd, unsigned long arg);
 	struct module *owner;
-}; 
+};
 
 extern inline struct device *xloop_device_to_dev(struct xloop_device *xlo);
 
 int xloop_register_transfer(struct xloop_func_table *funcs);
-int xloop_unregister_transfer(int number); 
+int xloop_unregister_transfer(int number);
 
 #endif