From efc492d327ea6a9658674eb9e971aff3742818cd Mon Sep 17 00:00:00 2001
From: Manuel Bentele
Date: Tue, 8 Sep 2020 15:07:31 +0200
Subject: Added patched losetup utility to configure xloop devices
---
.gitignore | 1 +
CMakeLists.txt | 8 +
Kbuild.in | 9 -
Kconfig | 93 --
Makefile | 12 -
kernel/CMakeLists.txt | 4 +
kernel/Kbuild.in | 9 +
kernel/Kconfig | 93 ++
kernel/Makefile | 12 +
kernel/loop_file_fmt.c | 347 +++++
kernel/loop_file_fmt.h | 380 ++++++
kernel/loop_file_fmt_qcow_cache.c | 218 ++++
kernel/loop_file_fmt_qcow_cache.h | 51 +
kernel/loop_file_fmt_qcow_cluster.c | 270 ++++
kernel/loop_file_fmt_qcow_cluster.h | 23 +
kernel/loop_file_fmt_qcow_main.c | 953 ++++++++++++++
kernel/loop_file_fmt_qcow_main.h | 419 +++++++
kernel/loop_file_fmt_raw.c | 465 +++++++
kernel/loop_main.c | 2221 +++++++++++++++++++++++++++++++++
kernel/loop_main.h | 105 ++
kernel/uapi/linux/loop.h | 125 ++
loop_file_fmt.c | 347 -----
loop_file_fmt.h | 380 ------
loop_file_fmt_qcow_cache.c | 218 ----
loop_file_fmt_qcow_cache.h | 51 -
loop_file_fmt_qcow_cluster.c | 270 ----
loop_file_fmt_qcow_cluster.h | 23 -
loop_file_fmt_qcow_main.c | 953 --------------
loop_file_fmt_qcow_main.h | 419 -------
loop_file_fmt_raw.c | 465 -------
loop_main.c | 2221 ---------------------------------
loop_main.h | 105 --
uapi/linux/loop.h | 125 --
utils/CMakeLists.txt | 15 +
utils/bash-completion/losetup | 85 ++
utils/config.h | 897 +++++++++++++
utils/include/all-io.h | 81 ++
utils/include/bitops.h | 150 +++
utils/include/blkdev.h | 151 +++
utils/include/c.h | 427 +++++++
utils/include/canonicalize.h | 32 +
utils/include/caputils.h | 34 +
utils/include/carefulputc.h | 155 +++
utils/include/cctype.h | 325 +++++
utils/include/closestream.h | 110 ++
utils/include/color-names.h | 44 +
utils/include/colors.h | 73 ++
utils/include/cpuset.h | 99 ++
utils/include/crc32.h | 12 +
utils/include/crc32c.h | 9 +
utils/include/debug.h | 181 +++
utils/include/debugobj.h | 22 +
utils/include/encode.h | 14 +
utils/include/env.h | 35 +
utils/include/exec_shell.h | 6 +
utils/include/exitcodes.h | 25 +
utils/include/fileutils.h | 77 ++
utils/include/fuzz.h | 9 +
utils/include/idcache.h | 28 +
utils/include/ismounted.h | 14 +
utils/include/iso9660.h | 58 +
utils/include/linux_version.h | 14 +
utils/include/list.h | 361 ++++++
utils/include/loopdev.h | 222 ++++
utils/include/mangle.h | 28 +
utils/include/match.h | 12 +
utils/include/mbsalign.h | 66 +
utils/include/mbsedit.h | 32 +
utils/include/md5.h | 24 +
utils/include/minix.h | 85 ++
utils/include/monotonic.h | 22 +
utils/include/namespace.h | 56 +
utils/include/nls.h | 153 +++
utils/include/optutils.h | 107 ++
utils/include/pager.h | 9 +
utils/include/partx.h | 63 +
utils/include/path.h | 135 ++
utils/include/pathnames.h | 210 ++++
utils/include/pidfd-utils.h | 28 +
utils/include/plymouth-ctrl.h | 65 +
utils/include/procutils.h | 34 +
utils/include/pt-bsd.h | 156 +++
utils/include/pt-gpt-partnames.h | 160 +++
utils/include/pt-mbr-partnames.h | 112 ++
utils/include/pt-mbr.h | 187 +++
utils/include/pt-sgi.h | 115 ++
utils/include/pt-sun.h | 90 ++
utils/include/pty-session.h | 110 ++
utils/include/pwdutils.h | 14 +
utils/include/randutils.h | 17 +
utils/include/rpmatch.h | 13 +
utils/include/setproctitle.h | 7 +
utils/include/sha1.h | 27 +
utils/include/signames.h | 8 +
utils/include/statfs_magic.h | 100 ++
utils/include/strutils.h | 333 +++++
utils/include/strv.h | 55 +
utils/include/swapheader.h | 23 +
utils/include/swapprober.h | 9 +
utils/include/sysfs.h | 113 ++
utils/include/timer.h | 22 +
utils/include/timeutils.h | 92 ++
utils/include/ttyutils.h | 205 +++
utils/include/widechar.h | 47 +
utils/include/xalloc.h | 139 +++
utils/lib/CMakeLists.txt | 45 +
utils/lib/blkdev.c | 452 +++++++
utils/lib/canonicalize.c | 250 ++++
utils/lib/caputils.c | 45 +
utils/lib/color-names.c | 64 +
utils/lib/colors.c | 907 ++++++++++++++
utils/lib/cpuset.c | 413 ++++++
utils/lib/crc32.c | 142 +++
utils/lib/crc32c.c | 102 ++
utils/lib/encode.c | 79 ++
utils/lib/env.c | 238 ++++
utils/lib/exec_shell.c | 51 +
utils/lib/fileutils.c | 246 ++++
utils/lib/idcache.c | 117 ++
utils/lib/ismounted.c | 396 ++++++
utils/lib/langinfo.c | 124 ++
utils/lib/linux_version.c | 71 ++
utils/lib/loopdev.c | 1914 ++++++++++++++++++++++++++++
utils/lib/mangle.c | 169 +++
utils/lib/match.c | 53 +
utils/lib/mbsalign.c | 627 ++++++++++
utils/lib/mbsedit.c | 225 ++++
utils/lib/md5.c | 257 ++++
utils/lib/monotonic.c | 81 ++
utils/lib/pager.c | 317 +++++
utils/lib/path.c | 1248 ++++++++++++++++++
utils/lib/plymouth-ctrl.c | 144 +++
utils/lib/procutils.c | 308 +++++
utils/lib/pty-session.c | 725 +++++++++++
utils/lib/pwdutils.c | 156 +++
utils/lib/randutils.c | 238 ++++
utils/lib/setproctitle.c | 75 ++
utils/lib/sha1.c | 256 ++++
utils/lib/signames.c | 204 +++
utils/lib/strutils.c | 1135 +++++++++++++++++
utils/lib/strv.c | 403 ++++++
utils/lib/sysfs.c | 1127 +++++++++++++++++
utils/lib/timer.c | 95 ++
utils/lib/timeutils.c | 611 +++++++++
utils/lib/ttyutils.c | 152 +++
utils/libsmartcols/CMakeLists.txt | 22 +
utils/libsmartcols/src/buffer.c | 152 +++
utils/libsmartcols/src/calculate.c | 454 +++++++
utils/libsmartcols/src/cell.c | 257 ++++
utils/libsmartcols/src/column.c | 564 +++++++++
utils/libsmartcols/src/fput.c | 97 ++
utils/libsmartcols/src/grouping.c | 575 +++++++++
utils/libsmartcols/src/init.c | 62 +
utils/libsmartcols/src/iter.c | 74 ++
utils/libsmartcols/src/libsmartcols.h | 336 +++++
utils/libsmartcols/src/line.c | 540 ++++++++
utils/libsmartcols/src/print-api.c | 211 ++++
utils/libsmartcols/src/print.c | 1089 ++++++++++++++++
utils/libsmartcols/src/smartcolsP.h | 468 +++++++
utils/libsmartcols/src/symbols.c | 293 +++++
utils/libsmartcols/src/table.c | 1691 +++++++++++++++++++++++++
utils/libsmartcols/src/version.c | 62 +
utils/libsmartcols/src/walk.c | 152 +++
utils/sys-utils/CMakeLists.txt | 9 +
utils/sys-utils/losetup.8 | 215 ++++
utils/sys-utils/losetup.c | 955 ++++++++++++++
166 files changed, 35292 insertions(+), 5691 deletions(-)
create mode 100644 CMakeLists.txt
delete mode 100644 Kbuild.in
delete mode 100644 Kconfig
delete mode 100644 Makefile
create mode 100644 kernel/CMakeLists.txt
create mode 100644 kernel/Kbuild.in
create mode 100644 kernel/Kconfig
create mode 100644 kernel/Makefile
create mode 100644 kernel/loop_file_fmt.c
create mode 100644 kernel/loop_file_fmt.h
create mode 100644 kernel/loop_file_fmt_qcow_cache.c
create mode 100644 kernel/loop_file_fmt_qcow_cache.h
create mode 100644 kernel/loop_file_fmt_qcow_cluster.c
create mode 100644 kernel/loop_file_fmt_qcow_cluster.h
create mode 100644 kernel/loop_file_fmt_qcow_main.c
create mode 100644 kernel/loop_file_fmt_qcow_main.h
create mode 100644 kernel/loop_file_fmt_raw.c
create mode 100644 kernel/loop_main.c
create mode 100644 kernel/loop_main.h
create mode 100644 kernel/uapi/linux/loop.h
delete mode 100644 loop_file_fmt.c
delete mode 100644 loop_file_fmt.h
delete mode 100644 loop_file_fmt_qcow_cache.c
delete mode 100644 loop_file_fmt_qcow_cache.h
delete mode 100644 loop_file_fmt_qcow_cluster.c
delete mode 100644 loop_file_fmt_qcow_cluster.h
delete mode 100644 loop_file_fmt_qcow_main.c
delete mode 100644 loop_file_fmt_qcow_main.h
delete mode 100644 loop_file_fmt_raw.c
delete mode 100644 loop_main.c
delete mode 100644 loop_main.h
delete mode 100644 uapi/linux/loop.h
create mode 100644 utils/CMakeLists.txt
create mode 100644 utils/bash-completion/losetup
create mode 100644 utils/config.h
create mode 100644 utils/include/all-io.h
create mode 100644 utils/include/bitops.h
create mode 100644 utils/include/blkdev.h
create mode 100644 utils/include/c.h
create mode 100644 utils/include/canonicalize.h
create mode 100644 utils/include/caputils.h
create mode 100644 utils/include/carefulputc.h
create mode 100644 utils/include/cctype.h
create mode 100644 utils/include/closestream.h
create mode 100644 utils/include/color-names.h
create mode 100644 utils/include/colors.h
create mode 100644 utils/include/cpuset.h
create mode 100644 utils/include/crc32.h
create mode 100644 utils/include/crc32c.h
create mode 100644 utils/include/debug.h
create mode 100644 utils/include/debugobj.h
create mode 100644 utils/include/encode.h
create mode 100644 utils/include/env.h
create mode 100644 utils/include/exec_shell.h
create mode 100644 utils/include/exitcodes.h
create mode 100644 utils/include/fileutils.h
create mode 100644 utils/include/fuzz.h
create mode 100644 utils/include/idcache.h
create mode 100644 utils/include/ismounted.h
create mode 100644 utils/include/iso9660.h
create mode 100644 utils/include/linux_version.h
create mode 100644 utils/include/list.h
create mode 100644 utils/include/loopdev.h
create mode 100644 utils/include/mangle.h
create mode 100644 utils/include/match.h
create mode 100644 utils/include/mbsalign.h
create mode 100644 utils/include/mbsedit.h
create mode 100644 utils/include/md5.h
create mode 100644 utils/include/minix.h
create mode 100644 utils/include/monotonic.h
create mode 100644 utils/include/namespace.h
create mode 100644 utils/include/nls.h
create mode 100644 utils/include/optutils.h
create mode 100644 utils/include/pager.h
create mode 100644 utils/include/partx.h
create mode 100644 utils/include/path.h
create mode 100644 utils/include/pathnames.h
create mode 100644 utils/include/pidfd-utils.h
create mode 100644 utils/include/plymouth-ctrl.h
create mode 100644 utils/include/procutils.h
create mode 100644 utils/include/pt-bsd.h
create mode 100644 utils/include/pt-gpt-partnames.h
create mode 100644 utils/include/pt-mbr-partnames.h
create mode 100644 utils/include/pt-mbr.h
create mode 100644 utils/include/pt-sgi.h
create mode 100644 utils/include/pt-sun.h
create mode 100644 utils/include/pty-session.h
create mode 100644 utils/include/pwdutils.h
create mode 100644 utils/include/randutils.h
create mode 100644 utils/include/rpmatch.h
create mode 100644 utils/include/setproctitle.h
create mode 100644 utils/include/sha1.h
create mode 100644 utils/include/signames.h
create mode 100644 utils/include/statfs_magic.h
create mode 100644 utils/include/strutils.h
create mode 100644 utils/include/strv.h
create mode 100644 utils/include/swapheader.h
create mode 100644 utils/include/swapprober.h
create mode 100644 utils/include/sysfs.h
create mode 100644 utils/include/timer.h
create mode 100644 utils/include/timeutils.h
create mode 100644 utils/include/ttyutils.h
create mode 100644 utils/include/widechar.h
create mode 100644 utils/include/xalloc.h
create mode 100644 utils/lib/CMakeLists.txt
create mode 100644 utils/lib/blkdev.c
create mode 100644 utils/lib/canonicalize.c
create mode 100644 utils/lib/caputils.c
create mode 100644 utils/lib/color-names.c
create mode 100644 utils/lib/colors.c
create mode 100644 utils/lib/cpuset.c
create mode 100644 utils/lib/crc32.c
create mode 100644 utils/lib/crc32c.c
create mode 100644 utils/lib/encode.c
create mode 100644 utils/lib/env.c
create mode 100644 utils/lib/exec_shell.c
create mode 100644 utils/lib/fileutils.c
create mode 100644 utils/lib/idcache.c
create mode 100644 utils/lib/ismounted.c
create mode 100644 utils/lib/langinfo.c
create mode 100644 utils/lib/linux_version.c
create mode 100644 utils/lib/loopdev.c
create mode 100644 utils/lib/mangle.c
create mode 100644 utils/lib/match.c
create mode 100644 utils/lib/mbsalign.c
create mode 100644 utils/lib/mbsedit.c
create mode 100644 utils/lib/md5.c
create mode 100644 utils/lib/monotonic.c
create mode 100644 utils/lib/pager.c
create mode 100644 utils/lib/path.c
create mode 100644 utils/lib/plymouth-ctrl.c
create mode 100644 utils/lib/procutils.c
create mode 100644 utils/lib/pty-session.c
create mode 100644 utils/lib/pwdutils.c
create mode 100644 utils/lib/randutils.c
create mode 100644 utils/lib/setproctitle.c
create mode 100644 utils/lib/sha1.c
create mode 100644 utils/lib/signames.c
create mode 100644 utils/lib/strutils.c
create mode 100644 utils/lib/strv.c
create mode 100644 utils/lib/sysfs.c
create mode 100644 utils/lib/timer.c
create mode 100644 utils/lib/timeutils.c
create mode 100644 utils/lib/ttyutils.c
create mode 100644 utils/libsmartcols/CMakeLists.txt
create mode 100644 utils/libsmartcols/src/buffer.c
create mode 100644 utils/libsmartcols/src/calculate.c
create mode 100644 utils/libsmartcols/src/cell.c
create mode 100644 utils/libsmartcols/src/column.c
create mode 100644 utils/libsmartcols/src/fput.c
create mode 100644 utils/libsmartcols/src/grouping.c
create mode 100644 utils/libsmartcols/src/init.c
create mode 100644 utils/libsmartcols/src/iter.c
create mode 100644 utils/libsmartcols/src/libsmartcols.h
create mode 100644 utils/libsmartcols/src/line.c
create mode 100644 utils/libsmartcols/src/print-api.c
create mode 100644 utils/libsmartcols/src/print.c
create mode 100644 utils/libsmartcols/src/smartcolsP.h
create mode 100644 utils/libsmartcols/src/symbols.c
create mode 100644 utils/libsmartcols/src/table.c
create mode 100644 utils/libsmartcols/src/version.c
create mode 100644 utils/libsmartcols/src/walk.c
create mode 100644 utils/sys-utils/CMakeLists.txt
create mode 100644 utils/sys-utils/losetup.8
create mode 100644 utils/sys-utils/losetup.c
diff --git a/.gitignore b/.gitignore
index b2d1740..4dafafe 100644
--- a/.gitignore
+++ b/.gitignore
@@ -6,3 +6,4 @@ modules.order
*.o.cmd
*.mod*
*.ko.cmd
+build
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 0000000..b136eca
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,8 @@
+cmake_minimum_required(VERSION 3.10)
+
+# set the project name
+project(xloop)
+
+# add subprojects
+add_subdirectory(kernel)
+add_subdirectory(utils)
diff --git a/Kbuild.in b/Kbuild.in
deleted file mode 100644
index b61f7a0..0000000
--- a/Kbuild.in
+++ /dev/null
@@ -1,9 +0,0 @@
-# SPDX-License-Identifier: GPL-2.0
-
-obj-$(CONFIG_BLK_DEV_XLOOP) += xloop.o
-xloop-objs += loop_main.o loop_file_fmt.o
-
-obj-$(CONFIG_BLK_DEV_XLOOP_FILE_FMT_RAW) += loop_file_fmt_raw.o
-
-loop_file_fmt_qcow-y += loop_file_fmt_qcow_main.o loop_file_fmt_qcow_cluster.o loop_file_fmt_qcow_cache.o
-obj-$(CONFIG_BLK_DEV_XLOOP_FILE_FMT_QCOW) += loop_file_fmt_qcow.o
diff --git a/Kconfig b/Kconfig
deleted file mode 100644
index 2fe8cb5..0000000
--- a/Kconfig
+++ /dev/null
@@ -1,93 +0,0 @@
-# SPDX-License-Identifier: GPL-2.0
-#
-# Loop device driver configuration
-#
-
-config BLK_DEV_XLOOP
- tristate "Loopback device support"
- ---help---
- Saying Y here will allow you to use a regular file as a block
- device; you can then create a file system on that block device and
- mount it just as you would mount other block devices such as hard
- drive partitions, CD-ROM drives or floppy drives. The loop devices
- are block special device files with major number 7 and typically
- called /dev/loop0, /dev/loop1 etc.
-
- This is useful if you want to check an ISO 9660 file system before
- burning the CD, or if you want to use floppy images without first
- writing them to floppy. Furthermore, some Linux distributions avoid
- the need for a dedicated Linux partition by keeping their complete
- root file system inside a DOS FAT file using this loop device
- driver.
-
- To use the loop device, you need the losetup utility, found in the
- util-linux package, see
- .
-
- The loop device driver can also be used to "hide" a file system in
- a disk partition, floppy, or regular file, either using encryption
- (scrambling the data) or steganography (hiding the data in the low
- bits of, say, a sound file). This is also safe if the file resides
- on a remote file server.
-
- There are several ways of encrypting disks. Some of these require
- kernel patches. The vanilla kernel offers the cryptoloop option
- and a Device Mapper target (which is superior, as it supports all
- file systems). If you want to use the cryptoloop, say Y to both
- LOOP and CRYPTOLOOP, and make sure you have a recent (version 2.12
- or later) version of util-linux. Additionally, be aware that
- the cryptoloop is not safe for storing journaled filesystems.
-
- Note that this loop device has nothing to do with the loopback
- device used for network connections from the machine to itself.
-
- To compile this driver as a module, choose M here: the
- module will be called loop.
-
- Most users will answer N here.
-
-config BLK_DEV_XLOOP_MIN_COUNT
- int "Number of loop devices to pre-create at init time"
- depends on BLK_DEV_XLOOP
- default 8
- help
- Static number of loop devices to be unconditionally pre-created
- at init time.
-
- This default value can be overwritten on the kernel command
- line or with module-parameter loop.max_loop.
-
- The historic default is 8. If a late 2011 version of losetup(8)
- is used, it can be set to 0, since needed loop devices can be
- dynamically allocated with the /dev/loop-control interface.
-
-config BLK_DEV_CRYPTOLOOP
- tristate "Cryptoloop Support"
- select CRYPTO
- select CRYPTO_CBC
- depends on BLK_DEV_XLOOP
- ---help---
- Say Y here if you want to be able to use the ciphers that are
- provided by the CryptoAPI as loop transformation. This might be
- used as hard disk encryption.
-
- WARNING: This device is not safe for journaled file systems like
- ext3 or Reiserfs. Please use the Device Mapper crypto module
- instead, which can be configured to be on-disk compatible with the
- cryptoloop device.
-
-config BLK_DEV_XLOOP_FILE_FMT_RAW
- tristate "Loop device binary file format support"
- depends on BLK_DEV_XLOOP
- ---help---
- Say Y or M here if you want to enable the binary (RAW) file format
- support of the loop device module.
-
-config BLK_DEV_XLOOP_FILE_FMT_QCOW
- tristate "Loop device QCOW file format support"
- depends on BLK_DEV_XLOOP
- select ZLIB_INFLATE
- select ZLIB_DEFLATE
- ---help---
- Say Y or M here if you want to enable the QEMU's copy on write (QCOW)
- file format support of the loop device module.
diff --git a/Makefile b/Makefile
deleted file mode 100644
index b7f2191..0000000
--- a/Makefile
+++ /dev/null
@@ -1,12 +0,0 @@
-# SPDX-License-Identifier: GPL-2.0
-include $(PWD)/Kbuild.in
-
-ifndef KDIR
- KDIR = /lib/modules/$(shell uname -r)/build
-endif
-
-all:
- make -C "$(KDIR)" "M=$(PWD)" modules
-
-clean:
- make -C "$(KDIR)" "M=$(PWD)" clean
diff --git a/kernel/CMakeLists.txt b/kernel/CMakeLists.txt
new file mode 100644
index 0000000..3c91af4
--- /dev/null
+++ b/kernel/CMakeLists.txt
@@ -0,0 +1,4 @@
+cmake_minimum_required(VERSION 3.10)
+
+# set the project name
+project(xloop-kernel)
diff --git a/kernel/Kbuild.in b/kernel/Kbuild.in
new file mode 100644
index 0000000..b61f7a0
--- /dev/null
+++ b/kernel/Kbuild.in
@@ -0,0 +1,9 @@
+# SPDX-License-Identifier: GPL-2.0
+
+obj-$(CONFIG_BLK_DEV_XLOOP) += xloop.o
+xloop-objs += loop_main.o loop_file_fmt.o
+
+obj-$(CONFIG_BLK_DEV_XLOOP_FILE_FMT_RAW) += loop_file_fmt_raw.o
+
+loop_file_fmt_qcow-y += loop_file_fmt_qcow_main.o loop_file_fmt_qcow_cluster.o loop_file_fmt_qcow_cache.o
+obj-$(CONFIG_BLK_DEV_XLOOP_FILE_FMT_QCOW) += loop_file_fmt_qcow.o
diff --git a/kernel/Kconfig b/kernel/Kconfig
new file mode 100644
index 0000000..2fe8cb5
--- /dev/null
+++ b/kernel/Kconfig
@@ -0,0 +1,93 @@
+# SPDX-License-Identifier: GPL-2.0
+#
+# Loop device driver configuration
+#
+
+config BLK_DEV_XLOOP
+ tristate "Loopback device support"
+ ---help---
+ Saying Y here will allow you to use a regular file as a block
+ device; you can then create a file system on that block device and
+ mount it just as you would mount other block devices such as hard
+ drive partitions, CD-ROM drives or floppy drives. The loop devices
+ are block special device files with major number 7 and typically
+ called /dev/loop0, /dev/loop1 etc.
+
+ This is useful if you want to check an ISO 9660 file system before
+ burning the CD, or if you want to use floppy images without first
+ writing them to floppy. Furthermore, some Linux distributions avoid
+ the need for a dedicated Linux partition by keeping their complete
+ root file system inside a DOS FAT file using this loop device
+ driver.
+
+ To use the loop device, you need the losetup utility, found in the
+ util-linux package, see
+ .
+
+ The loop device driver can also be used to "hide" a file system in
+ a disk partition, floppy, or regular file, either using encryption
+ (scrambling the data) or steganography (hiding the data in the low
+ bits of, say, a sound file). This is also safe if the file resides
+ on a remote file server.
+
+ There are several ways of encrypting disks. Some of these require
+ kernel patches. The vanilla kernel offers the cryptoloop option
+ and a Device Mapper target (which is superior, as it supports all
+ file systems). If you want to use the cryptoloop, say Y to both
+ LOOP and CRYPTOLOOP, and make sure you have a recent (version 2.12
+ or later) version of util-linux. Additionally, be aware that
+ the cryptoloop is not safe for storing journaled filesystems.
+
+ Note that this loop device has nothing to do with the loopback
+ device used for network connections from the machine to itself.
+
+ To compile this driver as a module, choose M here: the
+ module will be called loop.
+
+ Most users will answer N here.
+
+config BLK_DEV_XLOOP_MIN_COUNT
+ int "Number of loop devices to pre-create at init time"
+ depends on BLK_DEV_XLOOP
+ default 8
+ help
+ Static number of loop devices to be unconditionally pre-created
+ at init time.
+
+ This default value can be overwritten on the kernel command
+ line or with module-parameter loop.max_loop.
+
+ The historic default is 8. If a late 2011 version of losetup(8)
+ is used, it can be set to 0, since needed loop devices can be
+ dynamically allocated with the /dev/loop-control interface.
+
+config BLK_DEV_CRYPTOLOOP
+ tristate "Cryptoloop Support"
+ select CRYPTO
+ select CRYPTO_CBC
+ depends on BLK_DEV_XLOOP
+ ---help---
+ Say Y here if you want to be able to use the ciphers that are
+ provided by the CryptoAPI as loop transformation. This might be
+ used as hard disk encryption.
+
+ WARNING: This device is not safe for journaled file systems like
+ ext3 or Reiserfs. Please use the Device Mapper crypto module
+ instead, which can be configured to be on-disk compatible with the
+ cryptoloop device.
+
+config BLK_DEV_XLOOP_FILE_FMT_RAW
+ tristate "Loop device binary file format support"
+ depends on BLK_DEV_XLOOP
+ ---help---
+ Say Y or M here if you want to enable the binary (RAW) file format
+ support of the loop device module.
+
+config BLK_DEV_XLOOP_FILE_FMT_QCOW
+ tristate "Loop device QCOW file format support"
+ depends on BLK_DEV_XLOOP
+ select ZLIB_INFLATE
+ select ZLIB_DEFLATE
+ ---help---
+ Say Y or M here if you want to enable the QEMU's copy on write (QCOW)
+ file format support of the loop device module.
diff --git a/kernel/Makefile b/kernel/Makefile
new file mode 100644
index 0000000..b7f2191
--- /dev/null
+++ b/kernel/Makefile
@@ -0,0 +1,12 @@
+# SPDX-License-Identifier: GPL-2.0
+include $(PWD)/Kbuild.in
+
+ifndef KDIR
+ KDIR = /lib/modules/$(shell uname -r)/build
+endif
+
+all:
+ make -C "$(KDIR)" "M=$(PWD)" modules
+
+clean:
+ make -C "$(KDIR)" "M=$(PWD)" clean
diff --git a/kernel/loop_file_fmt.c b/kernel/loop_file_fmt.c
new file mode 100644
index 0000000..062ea0d
--- /dev/null
+++ b/kernel/loop_file_fmt.c
@@ -0,0 +1,347 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * loop_file_fmt.c
+ *
+ * File format subsystem for the xloop device module.
+ *
+ * Copyright (C) 2019 Manuel Bentele
+ */
+
+#include
+#include
+
+#include "loop_file_fmt.h"
+
+/* storage for all registered file format drivers */
+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)
+{
+ int ret = 0;
+
+ if (drv == NULL)
+ return -EFAULT;
+
+ if (drv->file_fmt_type > MAX_XLO_FILE_FMT)
+ return -EINVAL;
+
+ if (xloop_file_fmt_drivers[drv->file_fmt_type] == NULL) {
+ xloop_file_fmt_drivers[drv->file_fmt_type] = drv;
+ printk(KERN_INFO "xloop_file_fmt: successfully registered file "
+ "format driver %s", drv->name);
+ } else {
+ printk(KERN_WARNING "xloop_file_fmt: driver for file format "
+ "already registered");
+ ret = -EBUSY;
+ }
+
+ return ret;
+}
+EXPORT_SYMBOL(xloop_file_fmt_register_driver);
+
+void xloop_file_fmt_unregister_driver(struct xloop_file_fmt_driver *drv)
+{
+ if (drv == NULL)
+ return;
+
+ if (drv->file_fmt_type > MAX_XLO_FILE_FMT)
+ return;
+
+ xloop_file_fmt_drivers[drv->file_fmt_type] = NULL;
+ printk(KERN_INFO "xloop_file_fmt: successfully unregistered file "
+ "format driver %s", drv->name);
+}
+EXPORT_SYMBOL(xloop_file_fmt_unregister_driver);
+
+struct xloop_file_fmt *xloop_file_fmt_alloc(void)
+{
+ return kzalloc(sizeof(struct xloop_file_fmt), GFP_KERNEL);
+}
+
+void xloop_file_fmt_free(struct xloop_file_fmt *xlo_fmt)
+{
+ kfree(xlo_fmt);
+}
+
+int xloop_file_fmt_set_xlo(struct xloop_file_fmt *xlo_fmt, struct xloop_device *xlo)
+{
+ if (xlo_fmt == NULL)
+ return -EINVAL;
+
+ xlo_fmt->xlo = xlo;
+
+ return 0;
+}
+EXPORT_SYMBOL(xloop_file_fmt_set_xlo);
+
+struct xloop_device *xloop_file_fmt_get_xlo(struct xloop_file_fmt *xlo_fmt)
+{
+ return xlo_fmt->xlo;
+}
+EXPORT_SYMBOL(xloop_file_fmt_get_xlo);
+
+int xloop_file_fmt_init(struct xloop_file_fmt *xlo_fmt,
+ u32 file_fmt_type)
+{
+ struct xloop_file_fmt_ops *ops;
+ struct module *drv;
+ int ret = 0;
+
+ if (file_fmt_type > MAX_XLO_FILE_FMT)
+ return -EINVAL;
+
+ xlo_fmt->file_fmt_type = file_fmt_type;
+
+ if (xlo_fmt->file_fmt_state != file_fmt_uninitialized) {
+ printk(KERN_WARNING "xloop_file_fmt: file format is "
+ "initialized already");
+ return -EINVAL;
+ }
+
+ /* check if new file format driver is registered */
+ if (xloop_file_fmt_drivers[xlo_fmt->file_fmt_type] == NULL) {
+ printk(KERN_ERR "xloop_file_fmt: file format driver is not "
+ "available");
+ return -ENODEV;
+ }
+
+ printk(KERN_INFO "xloop_file_fmt: use file format driver %s",
+ 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)) {
+ printk(KERN_ERR "xloop_file_fmt: file format driver %s can not "
+ "be accessed",
+ xloop_file_fmt_drivers[xlo_fmt->file_fmt_type]->name);
+ return -ENODEV;
+ }
+
+ ops = xloop_file_fmt_drivers[xlo_fmt->file_fmt_type]->ops;
+ if (likely(ops->init)) {
+ ret = ops->init(xlo_fmt);
+ if (ret < 0)
+ goto free_drv;
+ }
+
+ /* 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;
+
+free_drv:
+ module_put(drv);
+ xlo_fmt->file_fmt_state = file_fmt_uninitialized;
+ return ret;
+}
+
+void xloop_file_fmt_exit(struct xloop_file_fmt *xlo_fmt)
+{
+ struct xloop_file_fmt_ops *ops;
+ struct module *drv;
+
+ if (xlo_fmt->file_fmt_state != file_fmt_initialized) {
+ printk(KERN_WARNING "xloop_file_fmt: file format is "
+ "uninitialized already");
+ return;
+ }
+
+ ops = xloop_file_fmt_drivers[xlo_fmt->file_fmt_type]->ops;
+ if (likely(ops->exit))
+ ops->exit(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 */
+ xlo_fmt->file_fmt_state = file_fmt_uninitialized;
+}
+
+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)) {
+ printk(KERN_ERR "xloop_file_fmt: file format is "
+ "not initialized, can not read");
+ return -EINVAL;
+ }
+
+ ops = xloop_file_fmt_drivers[xlo_fmt->file_fmt_type]->ops;
+ if (likely(ops->read))
+ return ops->read(xlo_fmt, rq);
+ else
+ return -EIO;
+}
+
+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)) {
+ printk(KERN_ERR "xloop_file_fmt: file format is "
+ "not initialized, can not read aio");
+ return -EINVAL;
+ }
+
+ ops = xloop_file_fmt_drivers[xlo_fmt->file_fmt_type]->ops;
+ if (likely(ops->read_aio))
+ return ops->read_aio(xlo_fmt, rq);
+ else
+ return -EIO;
+}
+
+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)) {
+ printk(KERN_ERR "xloop_file_fmt: file format is "
+ "not initialized, can not write");
+ return -EINVAL;
+ }
+
+ ops = xloop_file_fmt_drivers[xlo_fmt->file_fmt_type]->ops;
+ if (likely(ops->write))
+ return ops->write(xlo_fmt, rq);
+ else
+ return -EIO;
+}
+
+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)) {
+ printk(KERN_ERR "xloop_file_fmt: file format is "
+ "not initialized, can not write aio");
+ return -EINVAL;
+ }
+
+ ops = xloop_file_fmt_drivers[xlo_fmt->file_fmt_type]->ops;
+ if (likely(ops->write_aio))
+ return ops->write_aio(xlo_fmt, rq);
+ else
+ return -EIO;
+}
+
+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)) {
+ printk(KERN_ERR "xloop_file_fmt: file format is "
+ "not initialized, can not write zeros");
+ return -EINVAL;
+ }
+
+ ops = xloop_file_fmt_drivers[xlo_fmt->file_fmt_type]->ops;
+ if (likely(ops->write_zeros))
+ return ops->write_zeros(xlo_fmt, rq);
+ else
+ return -EIO;
+}
+
+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)) {
+ printk(KERN_ERR "xloop_file_fmt: file format is "
+ "not initialized, can not discard");
+ return -EINVAL;
+ }
+
+ ops = xloop_file_fmt_drivers[xlo_fmt->file_fmt_type]->ops;
+ if (likely(ops->discard))
+ return ops->discard(xlo_fmt, rq);
+ else
+ return -EIO;
+}
+
+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)) {
+ printk(KERN_ERR "xloop_file_fmt: file format is "
+ "not initialized, can not flush");
+ return -EINVAL;
+ }
+
+ ops = xloop_file_fmt_drivers[xlo_fmt->file_fmt_type]->ops;
+ if (likely(ops->flush))
+ return ops->flush(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)
+{
+ struct xloop_file_fmt_ops *ops;
+
+ if (unlikely(xlo_fmt->file_fmt_state != file_fmt_initialized)) {
+ printk(KERN_ERR "xloop_file_fmt: file format is "
+ "not initialized, can not read sector size");
+ return 0;
+ }
+
+ ops = xloop_file_fmt_drivers[xlo_fmt->file_fmt_type]->ops;
+ if (likely(ops->sector_size))
+ return ops->sector_size(xlo_fmt, file, offset, sizelimit);
+ else
+ return 0;
+}
+
+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;
+
+ /* 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 */
+ return xloop_file_fmt_init(xlo_fmt, file_fmt_type_new);
+}
+
+ssize_t xloop_file_fmt_print_type(u32 file_fmt_type, char *file_fmt_name)
+{
+ ssize_t len = 0;
+
+ switch (file_fmt_type) {
+ case XLO_FILE_FMT_RAW:
+ len = sprintf(file_fmt_name, "%s", "RAW");
+ break;
+ case XLO_FILE_FMT_QCOW:
+ len = sprintf(file_fmt_name, "%s", "QCOW");
+ break;
+ case XLO_FILE_FMT_VDI:
+ len = sprintf(file_fmt_name, "%s", "VDI");
+ break;
+ case XLO_FILE_FMT_VMDK:
+ len = sprintf(file_fmt_name, "%s", "VMDK");
+ break;
+ default:
+ len = sprintf(file_fmt_name, "%s", "ERROR: Unsupported xloop "
+ "file format!");
+ break;
+ }
+
+ return len;
+}
+EXPORT_SYMBOL(xloop_file_fmt_print_type);
diff --git a/kernel/loop_file_fmt.h b/kernel/loop_file_fmt.h
new file mode 100644
index 0000000..38d6a3b
--- /dev/null
+++ b/kernel/loop_file_fmt.h
@@ -0,0 +1,380 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * loop_file_fmt.h
+ *
+ * File format subsystem for the xloop device module.
+ *
+ * Copyright (C) 2019 Manuel Bentele
+ */
+
+#ifndef _LINUX_XLOOP_FILE_FMT_H
+#define _LINUX_XLOOP_FILE_FMT_H
+
+#include "loop_main.h"
+
+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)
+
+/**
+ * struct xloop_file_fmt_ops - File format subsystem operations
+ *
+ * Data structure representing the file format subsystem interface.
+ */
+struct xloop_file_fmt_ops {
+ /**
+ * @init: Initialization callback function
+ */
+ int (*init) (struct xloop_file_fmt *xlo_fmt);
+
+ /**
+ * @exit: Release callback function
+ */
+ void (*exit) (struct xloop_file_fmt *xlo_fmt);
+
+ /**
+ * @read: Read IO callback function
+ */
+ 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);
+
+ /**
+ * @read_aio: Asynchronous read IO callback function
+ */
+ 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);
+
+ /**
+ * @zero: Zero (discard) IO callback function
+ */
+ 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);
+
+ /**
+ * @flush: Flush callback function
+ */
+ 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);
+};
+
+/**
+ * struct xloop_file_fmt_driver - File format subsystem driver
+ *
+ * Data structure to implement file format drivers for the file format
+ * subsystem.
+ */
+struct xloop_file_fmt_driver {
+ /**
+ * @name: Name of the file format driver
+ */
+ const char *name;
+
+ /**
+ * @file_fmt_type: xloop file format type of the file format driver
+ */
+ const u32 file_fmt_type;
+
+ /**
+ * @ops: Driver's implemented file format operations
+ */
+ struct xloop_file_fmt_ops *ops;
+
+ /**
+ * @ops: Owner of the file format driver
+ */
+ struct module *owner;
+};
+
+/*
+ * states of the file format
+ *
+ * transitions:
+ * xloop_file_fmt_init(...)
+ * ---> uninitialized ------------------------------> initialized
+ * xloop_file_fmt_exit(...)
+ * initialized ------------------------------> uninitialized
+ * xloop_file_fmt_read(...)
+ * initialized ------------------------------> initialized
+ * xloop_file_fmt_read_aio(...)
+ * initialized ------------------------------> initialized
+ * xloop_file_fmt_write(...)
+ * initialized ------------------------------> initialized
+ * xloop_file_fmt_write_aio(...)
+ * initialized ------------------------------> initialized
+ * xloop_file_fmt_discard(...)
+ * initialized ------------------------------> initialized
+ * xloop_file_fmt_flush(...)
+ * initialized ------------------------------> initialized
+ * xloop_file_fmt_sector_size(...)
+ * initialized ------------------------------> initialized
+ *
+ * xloop_file_fmt_change(...)
+ * +-----------------------------------------------------------+
+ * | exit(...) init(...) |
+ * | initialized -------> uninitialized -------> initialized |
+ * +-----------------------------------------------------------+
+ */
+enum {
+ file_fmt_uninitialized = 0,
+ file_fmt_initialized
+};
+
+/**
+ * struct xloop_file_fmt - xloop file format
+ *
+ * Data structure to use with the file format the xloop file format subsystem.
+ */
+struct xloop_file_fmt {
+ /**
+ * @file_fmt_type: Current type of the xloop file format
+ */
+ u32 file_fmt_type;
+
+ /**
+ * @file_fmt_state: Current state of the xloop file format
+ */
+ int file_fmt_state;
+
+ /**
+ * @xlo: Link to a file format's xloop device
+ */
+ struct xloop_device *xlo;
+
+ /**
+ * @private_data: Optional link to a file format's driver specific data
+ */
+ void *private_data;
+};
+
+
+/* subsystem functions for the driver implementation */
+
+/**
+ * xloop_file_fmt_register_driver - Register a xloop file format driver
+ * @drv: File format driver
+ *
+ * Registers the specified xloop file format driver @drv by the xloop file format
+ * subsystem.
+ */
+extern int xloop_file_fmt_register_driver(struct xloop_file_fmt_driver *drv);
+
+/**
+ * xloop_file_fmt_unregister_driver - Unregister a xloop file format driver
+ * @drv: File format driver
+ *
+ * Unregisters the specified xloop file format driver @drv from the xloop file
+ * format subsystem.
+ */
+extern void xloop_file_fmt_unregister_driver(struct xloop_file_fmt_driver *drv);
+
+
+/* subsystem functions for subsystem usage */
+
+/**
+ * xloop_file_fmt_alloc - Allocate a xloop file format
+ *
+ * Dynamically allocates a xloop file format and returns a pointer to the
+ * created xloop file format.
+ */
+extern struct xloop_file_fmt *xloop_file_fmt_alloc(void);
+
+/**
+ * xloop_file_fmt_free - Free an allocated xloop file format
+ * @xlo_fmt: xloop file format
+ *
+ * Frees the already allocated xloop file format @xlo_fmt.
+ */
+extern void xloop_file_fmt_free(struct xloop_file_fmt *xlo_fmt);
+
+/**
+ * xloop_file_fmt_set_xlo - Set the xloop file format's xloop device
+ * @xlo_fmt: xloop file format
+ * @xlo: xloop device
+ *
+ * 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);
+
+/**
+ * xloop_file_fmt_get_xlo - Get the xloop file format's xloop device
+ * @xlo_fmt: xloop file format
+ *
+ * Returns a pointer to the xloop device of the xloop file format @xlo_fmt.
+ */
+extern struct xloop_device *xloop_file_fmt_get_xlo(struct xloop_file_fmt *xlo_fmt);
+
+/**
+ * xloop_file_fmt_init - Initialize a xloop file format
+ * @xlo_fmt: xloop file format
+ * @file_fmt_type: Type of the file format
+ *
+ * Initializes the specified xloop file format @xlo_fmt and sets up the correct
+ * file format type @file_fmt_type. Depending on @file_fmt_type, the correct
+ * xloop file format driver is loaded in the subsystems backend. If no xloop file
+ * 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);
+
+/**
+ * xloop_file_fmt_exit - Release a xloop file format
+ * @xlo_fmt: xloop file format
+ *
+ * Releases the specified xloop file format @xlo_fmt and all its resources.
+ */
+extern void xloop_file_fmt_exit(struct xloop_file_fmt *xlo_fmt);
+
+/**
+ * xloop_file_fmt_read - Read IO from a xloop file format
+ * @xlo_fmt: xloop file format
+ * @rq: IO Request
+ *
+ * Reads IO from the file format's xloop device by sending the IO read 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_read(struct xloop_file_fmt *xlo_fmt,
+ struct request *rq);
+
+/**
+ * xloop_file_fmt_read_aio - Read IO from a xloop file format asynchronously
+ * @xlo_fmt: xloop file format
+ * @rq: IO Request
+ *
+ * Reads IO from the file format's xloop device asynchronously by sending the
+ * IO read aio 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_read_aio(struct xloop_file_fmt *xlo_fmt,
+ struct request *rq);
+
+/**
+ * xloop_file_fmt_write - Write IO to a xloop file format
+ * @xlo_fmt: xloop file format
+ * @rq: IO Request
+ *
+ * Write IO to the file format's xloop device by sending the IO write 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(struct xloop_file_fmt *xlo_fmt,
+ struct request *rq);
+
+/**
+ * xloop_file_fmt_write_aio - Write IO to a xloop file format asynchronously
+ * @xlo_fmt: xloop file format
+ * @rq: IO Request
+ *
+ * Write IO to the file format's xloop device asynchronously by sending the
+ * IO write aio 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_aio(struct xloop_file_fmt *xlo_fmt,
+ struct request *rq);
+
+/**
+ * xloop_file_fmt_write_zeros - Zero (discard) IO on a xloop file format
+ * @xlo_fmt: xloop file format
+ * @rq: IO Request
+ *
+ * Zero (discard) IO on the file format's xloop device by sending the IO write
+ * 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);
+
+/**
+ * xloop_file_fmt_discard - Discard IO on a xloop file format
+ * @xlo_fmt: xloop file format
+ * @rq: IO Request
+ *
+ * Discard IO on the file format's xloop device by sending the IO discard
+ * 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);
+
+/**
+ * xloop_file_fmt_flush - Flush a xloop file format
+ * @xlo_fmt: xloop file format
+ *
+ * Flush the file format's xloop device by calling the registered callback
+ * function of the suitable xloop file format driver.
+ */
+extern int xloop_file_fmt_flush(struct xloop_file_fmt *xlo_fmt);
+
+/**
+ * xloop_file_fmt_sector_size - Get sector size of a xloop file format
+ * @xlo_fmt: xloop file format
+ * @file: xloop file formats file for sector size calculation
+ * @offset: Offset within the file for sector size calculation
+ * @sizelimit: Sizelimit of the file for sector size calculation
+ *
+ * Returns the physical sector size of the given xloop file format's file.
+ * 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);
+
+/**
+ * xloop_file_fmt_change - Change the xloop file format's type
+ * @xlo_fmt: xloop file format
+ * @file_fmt_type_new: xloop file format type
+ *
+ * Changes the file format type of the already initialized xloop file format
+ * @xlo_fmt. Therefore, the function releases the old file format and frees all
+ * 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);
+
+
+/* helper functions of the subsystem */
+
+/**
+ * xloop_file_fmt_print_type - Convert file format type to string
+ * @file_fmt_type: xloop file format type
+ * @file_fmt_name: xloop file format type string
+ *
+ * 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);
+
+#endif
diff --git a/kernel/loop_file_fmt_qcow_cache.c b/kernel/loop_file_fmt_qcow_cache.c
new file mode 100644
index 0000000..4ef772a
--- /dev/null
+++ b/kernel/loop_file_fmt_qcow_cache.c
@@ -0,0 +1,218 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * loop_file_fmt_qcow_cache.c
+ *
+ * QCOW file format driver for the xloop device module.
+ *
+ * Ported QCOW2 implementation of the QEMU project (GPL-2.0):
+ * L2/refcount table cache for the QCOW2 format.
+ *
+ * The copyright (C) 2010 of the original code is owned by
+ * Kevin Wolf
+ *
+ * Copyright (C) 2019 Manuel Bentele
+ */
+
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include "loop_file_fmt_qcow_main.h"
+#include "loop_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)
+{
+ 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)
+{
+ ptrdiff_t table_offset = (u8 *) table - (u8 *) c->table_array;
+ int idx = table_offset / c->table_size;
+ ASSERT(idx >= 0 && idx < c->size && table_offset % c->table_size == 0);
+ 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)
+{
+ struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
+
+ if (c == qcow_data->refcount_block_cache) {
+ return "refcount block";
+ } else if (c == qcow_data->l2_table_cache) {
+ return "L2 table";
+ } else {
+ /* do not abort, because this is not critical */
+ return "unknown";
+ }
+}
+
+struct xloop_file_fmt_qcow_cache *xloop_file_fmt_qcow_cache_create(
+ struct xloop_file_fmt *xlo_fmt, int num_tables, unsigned table_size)
+{
+#ifdef CONFIG_DEBUG_DRIVER
+ struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
+#endif
+ struct xloop_file_fmt_qcow_cache *c;
+
+ ASSERT(num_tables > 0);
+ ASSERT(is_power_of_2(table_size));
+ ASSERT(table_size >= (1 << QCOW_MIN_CLUSTER_BITS));
+ ASSERT(table_size <= qcow_data->cluster_size);
+
+ c = kzalloc(sizeof(*c), GFP_KERNEL);
+ 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->table_array = vzalloc(num_tables * c->table_size);
+
+ if (!c->entries || !c->table_array) {
+ vfree(c->table_array);
+ vfree(c->entries);
+ kfree(c);
+ c = NULL;
+ }
+
+ return c;
+}
+
+void xloop_file_fmt_qcow_cache_destroy(struct xloop_file_fmt *xlo_fmt)
+{
+ struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
+ struct xloop_file_fmt_qcow_cache *c = qcow_data->l2_table_cache;
+ int 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_qcow_cache *c, int i)
+{
+ if (!c->entries[i].dirty || !c->entries[i].offset) {
+ return 0;
+ } else {
+ printk(KERN_ERR "xloop_file_fmt_qcow: Flush dirty cache tables "
+ "is not supported yet\n");
+ return -ENOSYS;
+ }
+}
+
+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;
+ int ret;
+ int lookup_index;
+ u64 min_lru_counter = U64_MAX;
+ int min_lru_index = -1;
+ u64 read_offset;
+ size_t len;
+
+ ASSERT(offset != 0);
+
+ if (!IS_ALIGNED(offset, c->table_size)) {
+ printk_ratelimited(KERN_ERR "xloop_file_fmt_qcow: Cannot get "
+ "entry from %s cache: offset %llx is unaligned\n",
+ __xloop_file_fmt_qcow_cache_get_name(xlo_fmt, c),
+ offset);
+ return -EIO;
+ }
+
+ /* Check if the table is already cached */
+ i = lookup_index = (offset / c->table_size * 4) % c->size;
+ do {
+ 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) {
+ 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");
+ }
+
+ /* Cache miss: write a table back and replace it */
+ i = min_lru_index;
+
+ ret = __xloop_file_fmt_qcow_cache_entry_flush(c, i);
+ 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);
+ if (len < 0) {
+ len = ret;
+ return ret;
+ }
+ }
+
+ c->entries[i].offset = offset;
+
+ /* And return the right table */
+found:
+ c->entries[i].ref++;
+ *table = __xloop_file_fmt_qcow_cache_get_table_addr(c, i);
+
+ return 0;
+}
+
+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);
+}
+
+void xloop_file_fmt_qcow_cache_put(struct xloop_file_fmt *xlo_fmt, 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;
+ int i = __xloop_file_fmt_qcow_cache_get_table_idx(c, *table);
+
+ c->entries[i].ref--;
+ *table = NULL;
+
+ if (c->entries[i].ref == 0) {
+ c->entries[i].lru_counter = ++c->lru_counter;
+ }
+
+ ASSERT(c->entries[i].ref >= 0);
+}
diff --git a/kernel/loop_file_fmt_qcow_cache.h b/kernel/loop_file_fmt_qcow_cache.h
new file mode 100644
index 0000000..d2f1010
--- /dev/null
+++ b/kernel/loop_file_fmt_qcow_cache.h
@@ -0,0 +1,51 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * xloop_file_fmt_qcow_cache.h
+ *
+ * Ported QCOW2 implementation of the QEMU project (GPL-2.0):
+ * L2/refcount table cache for the QCOW2 format.
+ *
+ * The copyright (C) 2010 of the original code is owned by
+ * Kevin Wolf
+ *
+ * Copyright (C) 2019 Manuel Bentele
+ */
+
+#ifndef _LINUX_XLOOP_FILE_FMT_QCOW_CACHE_H
+#define _LINUX_XLOOP_FILE_FMT_QCOW_CACHE_H
+
+#include "loop_file_fmt.h"
+
+struct xloop_file_fmt_qcow_cache_table {
+ s64 offset;
+ u64 lru_counter;
+ int ref;
+ bool dirty;
+};
+
+struct xloop_file_fmt_qcow_cache {
+ struct xloop_file_fmt_qcow_cache_table *entries;
+ struct xloop_file_fmt_qcow_cache *depends;
+ int size;
+ int table_size;
+ bool depends_on_flush;
+ void *table_array;
+ u64 lru_counter;
+ 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 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 void xloop_file_fmt_qcow_cache_put(struct xloop_file_fmt *xlo_fmt,
+ void **table);
+
+#endif
diff --git a/kernel/loop_file_fmt_qcow_cluster.c b/kernel/loop_file_fmt_qcow_cluster.c
new file mode 100644
index 0000000..593a173
--- /dev/null
+++ b/kernel/loop_file_fmt_qcow_cluster.c
@@ -0,0 +1,270 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * xloop_file_fmt_qcow_cluster.c
+ *
+ * Ported QCOW2 implementation of the QEMU project (GPL-2.0):
+ * Cluster calculation and lookup for the QCOW2 format.
+ *
+ * The copyright (C) 2004-2006 of the original code is owned by Fabrice Bellard.
+ *
+ * Copyright (C) 2019 Manuel Bentele
+ */
+
+#include
+#include
+
+#include "loop_file_fmt.h"
+#include "loop_file_fmt_qcow_main.h"
+#include "loop_file_fmt_qcow_cache.h"
+#include "loop_file_fmt_qcow_cluster.h"
+
+/*
+ * Loads a L2 slice into memory (L2 slices are the parts of L2 tables
+ * that are loaded by the qcow2 cache). If the slice is in the cache,
+ * 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)
+{
+ struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
+
+ int start_of_slice = sizeof(u64) * (
+ 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);
+}
+
+/*
+ * Checks how many clusters in a given L2 slice are contiguous in the image
+ * file. As soon as one of the flags in the bitmask stop_flags changes compared
+ * to the first cluster, the search is stopped and the cluster is not counted
+ * as contiguous. (This allows it, for example, to stop at the first compressed
+ * cluster which may require a different handling)
+ */
+static int __xloop_file_fmt_qcow_cluster_count_contiguous(
+ struct xloop_file_fmt *xlo_fmt, int nb_clusters, int cluster_size,
+ u64 *l2_slice, u64 stop_flags)
+{
+ int i;
+ enum xloop_file_fmt_qcow_cluster_type first_cluster_type;
+ u64 mask = stop_flags | L2E_OFFSET_MASK | QCOW_OFLAG_COMPRESSED;
+ u64 first_entry = be64_to_cpu(l2_slice[0]);
+ u64 offset = first_entry & mask;
+
+ first_cluster_type = xloop_file_fmt_qcow_get_cluster_type(xlo_fmt,
+ first_entry);
+ if (first_cluster_type == QCOW_CLUSTER_UNALLOCATED) {
+ return 0;
+ }
+
+ /* must be allocated */
+ ASSERT(first_cluster_type == QCOW_CLUSTER_NORMAL ||
+ first_cluster_type == QCOW_CLUSTER_ZERO_ALLOC);
+
+ for (i = 0; i < nb_clusters; i++) {
+ u64 l2_entry = be64_to_cpu(l2_slice[i]) & mask;
+ if (offset + (u64) i * cluster_size != l2_entry) {
+ break;
+ }
+ }
+
+ return i;
+}
+
+/*
+ * Checks how many consecutive unallocated clusters in a given L2
+ * slice have the same cluster type.
+ */
+static int __xloop_file_fmt_qcow_cluster_count_contiguous_unallocated(
+ struct xloop_file_fmt *xlo_fmt, int nb_clusters, u64 *l2_slice,
+ enum xloop_file_fmt_qcow_cluster_type wanted_type)
+{
+ int i;
+
+ ASSERT(wanted_type == QCOW_CLUSTER_ZERO_PLAIN ||
+ wanted_type == QCOW_CLUSTER_UNALLOCATED);
+
+ for (i = 0; i < nb_clusters; i++) {
+ u64 entry = be64_to_cpu(l2_slice[i]);
+ enum xloop_file_fmt_qcow_cluster_type type =
+ xloop_file_fmt_qcow_get_cluster_type(xlo_fmt, entry);
+
+ if (type != wanted_type) {
+ break;
+ }
+ }
+
+ return i;
+}
+
+/*
+ * For a given offset of the virtual disk, find the cluster type and offset in
+ * the qcow2 file. The offset is stored in *cluster_offset.
+ *
+ * On entry, *bytes is the maximum number of contiguous bytes starting at
+ * offset that we are interested in.
+ *
+ * On exit, *bytes is the number of bytes starting at offset that have the same
+ * cluster type and (if applicable) are stored contiguously in the image file.
+ * Compressed clusters are always returned one by one.
+ *
+ * Returns the cluster type (QCOW2_CLUSTER_*) on success, -errno in error
+ * cases.
+ */
+int xloop_file_fmt_qcow_cluster_get_offset(struct xloop_file_fmt *xlo_fmt,
+ u64 offset, unsigned int *bytes, u64 *cluster_offset)
+{
+ struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
+ unsigned int l2_index;
+ u64 l1_index, l2_offset, *l2_slice;
+ int c;
+ unsigned int offset_in_cluster;
+ u64 bytes_available, bytes_needed, nb_clusters;
+ enum xloop_file_fmt_qcow_cluster_type type;
+ int ret;
+
+ 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
+ * 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;
+
+ if (bytes_needed > bytes_available) {
+ bytes_needed = bytes_available;
+ }
+
+ *cluster_offset = 0;
+
+ /* seek to the l2 offset in the l1 table */
+ l1_index = xloop_file_fmt_qcow_offset_to_l1_index(qcow_data, offset);
+ if (l1_index >= qcow_data->l1_size) {
+ type = QCOW_CLUSTER_UNALLOCATED;
+ goto out;
+ }
+
+ l2_offset = qcow_data->l1_table[l1_index] & L1E_OFFSET_MASK;
+ if (!l2_offset) {
+ type = QCOW_CLUSTER_UNALLOCATED;
+ goto out;
+ }
+
+ if (xloop_file_fmt_qcow_offset_into_cluster(qcow_data, l2_offset)) {
+ printk_ratelimited(KERN_ERR "xloop_file_fmt_qcow: 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) {
+ 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);
+ *cluster_offset = be64_to_cpu(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 */
+ ASSERT(nb_clusters <= INT_MAX);
+
+ type = xloop_file_fmt_qcow_get_cluster_type(xlo_fmt, *cluster_offset);
+ if (qcow_data->qcow_version < 3 && (
+ type == QCOW_CLUSTER_ZERO_PLAIN ||
+ type == QCOW_CLUSTER_ZERO_ALLOC)) {
+ printk_ratelimited(KERN_ERR "xloop_file_fmt_qcow: 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_CLUSTER_COMPRESSED:
+ if (xloop_file_fmt_qcow_has_data_file(xlo_fmt)) {
+ printk_ratelimited(KERN_ERR "xloop_file_fmt_qcow: "
+ "compressed cluster entry found in image with "
+ "external data file (L2 offset: %llx, "
+ "L2 index: %x)", l2_offset, l2_index);
+ ret = -EIO;
+ goto fail;
+ }
+ /* Compressed clusters can only be processed one by one */
+ c = 1;
+ *cluster_offset &= L2E_COMPRESSED_OFFSET_SIZE_MASK;
+ break;
+ case QCOW_CLUSTER_ZERO_PLAIN:
+ case QCOW_CLUSTER_UNALLOCATED:
+ /* how many empty clusters ? */
+ c = __xloop_file_fmt_qcow_cluster_count_contiguous_unallocated(
+ xlo_fmt, nb_clusters, &l2_slice[l2_index], type);
+ *cluster_offset = 0;
+ break;
+ case QCOW_CLUSTER_ZERO_ALLOC:
+ case QCOW_CLUSTER_NORMAL:
+ /* how many allocated clusters ? */
+ c = __xloop_file_fmt_qcow_cluster_count_contiguous(xlo_fmt,
+ nb_clusters, qcow_data->cluster_size,
+ &l2_slice[l2_index], QCOW_OFLAG_ZERO);
+ *cluster_offset &= L2E_OFFSET_MASK;
+ if (xloop_file_fmt_qcow_offset_into_cluster(qcow_data,
+ *cluster_offset)) {
+ printk_ratelimited(KERN_ERR "xloop_file_fmt_qcow: "
+ "cluster allocation offset %llx unaligned "
+ "(L2 offset: %llx, L2 index: %x)\n",
+ *cluster_offset, l2_offset, l2_index);
+ ret = -EIO;
+ goto fail;
+ }
+ if (xloop_file_fmt_qcow_has_data_file(xlo_fmt) &&
+ *cluster_offset != offset - offset_in_cluster) {
+ printk_ratelimited(KERN_ERR "xloop_file_fmt_qcow: "
+ "external data file host cluster offset %llx "
+ "does not match guest cluster offset: %llx, "
+ "L2 index: %x)", *cluster_offset,
+ offset - offset_in_cluster, l2_index);
+ ret = -EIO;
+ goto fail;
+ }
+ break;
+ default:
+ BUG();
+ }
+
+ xloop_file_fmt_qcow_cache_put(xlo_fmt, (void **) &l2_slice);
+
+ bytes_available = (s64) c * qcow_data->cluster_size;
+
+out:
+ if (bytes_available > bytes_needed) {
+ bytes_available = bytes_needed;
+ }
+
+ /* bytes_available <= bytes_needed <= *bytes + offset_in_cluster;
+ * subtracting offset_in_cluster will therefore definitely yield
+ * something not exceeding UINT_MAX */
+ ASSERT(bytes_available - offset_in_cluster <= UINT_MAX);
+ *bytes = bytes_available - offset_in_cluster;
+
+ return type;
+
+fail:
+ xloop_file_fmt_qcow_cache_put(xlo_fmt, (void **) &l2_slice);
+ return ret;
+}
diff --git a/kernel/loop_file_fmt_qcow_cluster.h b/kernel/loop_file_fmt_qcow_cluster.h
new file mode 100644
index 0000000..5078f29
--- /dev/null
+++ b/kernel/loop_file_fmt_qcow_cluster.h
@@ -0,0 +1,23 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * xloop_file_fmt_qcow_cluster.h
+ *
+ * Ported QCOW2 implementation of the QEMU project (GPL-2.0):
+ * Cluster calculation and lookup for the QCOW2 format.
+ *
+ * The copyright (C) 2004-2006 of the original code is owned by Fabrice Bellard.
+ *
+ * Copyright (C) 2019 Manuel Bentele
+ */
+
+#ifndef _LINUX_XLOOP_FILE_FMT_QCOW_CLUSTER_H
+#define _LINUX_XLOOP_FILE_FMT_QCOW_CLUSTER_H
+
+#include "loop_file_fmt.h"
+
+extern int xloop_file_fmt_qcow_cluster_get_offset(struct xloop_file_fmt *xlo_fmt,
+ u64 offset,
+ unsigned int *bytes,
+ u64 *cluster_offset);
+
+#endif
diff --git a/kernel/loop_file_fmt_qcow_main.c b/kernel/loop_file_fmt_qcow_main.c
new file mode 100644
index 0000000..7c3e360
--- /dev/null
+++ b/kernel/loop_file_fmt_qcow_main.c
@@ -0,0 +1,953 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * xloop_file_fmt_qcow.c
+ *
+ * QCOW file format driver for the xloop device module.
+ *
+ * Copyright (C) 2019 Manuel Bentele
+ */
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include "loop_file_fmt.h"
+#include "loop_file_fmt_qcow_main.h"
+#include "loop_file_fmt_qcow_cache.h"
+#include "loop_file_fmt_qcow_cluster.h"
+
+static int __qcow_file_fmt_header_read(struct file *file,
+ struct xloop_file_fmt_qcow_header *header)
+{
+ ssize_t len;
+ loff_t offset;
+ int ret = 0;
+
+ /* read QCOW header */
+ offset = 0;
+ len = kernel_read(file, header, sizeof(*header), &offset);
+ if (len < 0) {
+ printk(KERN_ERR "xloop_file_fmt_qcow: could not read QCOW "
+ "header");
+ return len;
+ }
+
+ header->magic = be32_to_cpu(header->magic);
+ header->version = be32_to_cpu(header->version);
+ header->backing_file_offset = be64_to_cpu(header->backing_file_offset);
+ header->backing_file_size = be32_to_cpu(header->backing_file_size);
+ header->cluster_bits = be32_to_cpu(header->cluster_bits);
+ header->size = be64_to_cpu(header->size);
+ 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->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) {
+ printk(KERN_ERR "xloop_file_fmt_qcow: image is not in QCOW "
+ "format");
+ return -EINVAL;
+ }
+
+ if (header->version < 2 || header->version > 3) {
+ printk(KERN_ERR "xloop_file_fmt_qcow: unsupported QCOW version "
+ "%d", 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;
+ } 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->refcount_order = be32_to_cpu(header->refcount_order);
+ header->header_length = be32_to_cpu(header->header_length);
+
+ if (header->header_length < 104) {
+ printk(KERN_ERR "xloop_file_fmt_qcow: QCOW header too "
+ "short");
+ return -EINVAL;
+ }
+ }
+
+ 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)
+{
+ struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
+
+ if (entries > max_size_bytes / entry_len) {
+ printk(KERN_INFO "xloop_file_fmt_qcow: %s too large",
+ table_name);
+ 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)
+ ) {
+ printk(KERN_INFO "xloop_file_fmt_qcow: %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)
+{
+ struct xloop_device *xlo = xloop_file_fmt_get_xlo(xlo_fmt);
+ return ((loff_t) blk_rq_pos(rq) << 9) + xlo->xlo_offset;
+}
+
+static int __qcow_file_fmt_compression_init(struct xloop_file_fmt *xlo_fmt)
+{
+ struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
+ int ret = 0;
+
+ qcow_data->strm = kzalloc(sizeof(*qcow_data->strm), GFP_KERNEL);
+ if (!qcow_data->strm) {
+ ret = -ENOMEM;
+ goto out;
+ }
+
+ qcow_data->strm->workspace = vzalloc(zlib_inflate_workspacesize());
+ if (!qcow_data->strm->workspace) {
+ ret = -ENOMEM;
+ goto out_free_strm;
+ }
+
+ qcow_data->cmp_last_coffset = ULLONG_MAX;
+ qcow_data->cmp_out_buf = vmalloc(qcow_data->cluster_size);
+ if (!qcow_data->cmp_out_buf) {
+ ret = -ENOMEM;
+ goto out_free_workspace;
+ }
+
+ return ret;
+
+out_free_workspace:
+ vfree(qcow_data->strm->workspace);
+out_free_strm:
+ kfree(qcow_data->strm);
+out:
+ return ret;
+}
+
+static void __qcow_file_fmt_compression_exit(struct xloop_file_fmt *xlo_fmt)
+{
+ struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
+
+ vfree(qcow_data->strm->workspace);
+ kfree(qcow_data->strm);
+ vfree(qcow_data->cmp_out_buf);
+}
+
+#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)
+{
+ 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);
+
+ 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);
+ }
+
+ 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)
+{
+ 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));
+}
+
+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)
+{
+ struct xloop_file_fmt *xlo_fmt = file->private_data;
+ struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
+ unsigned int cur_bytes = 1;
+ u64 offset = 0;
+ u64 cluster_offset = 0;
+ s64 offset_in_cluster = 0;
+ ssize_t len = 0;
+ int ret = 0;
+
+ /* read the share debugfs offset */
+ ret = mutex_lock_interruptible(&qcow_data->dbgfs_qcow_offset_mutex);
+ if (ret)
+ return ret;
+
+ offset = qcow_data->dbgfs_qcow_offset;
+ mutex_unlock(&qcow_data->dbgfs_qcow_offset_mutex);
+
+ /* calculate and print the cluster offset */
+ ret = xloop_file_fmt_qcow_cluster_get_offset(xlo_fmt,
+ offset, &cur_bytes, &cluster_offset);
+ if (ret < 0)
+ return -EINVAL;
+
+ offset_in_cluster = xloop_file_fmt_qcow_offset_into_cluster(qcow_data,
+ offset);
+
+ len = sprintf(qcow_data->dbgfs_file_qcow_cluster_buf,
+ "offset: %lld\ncluster_offset: %lld\noffset_in_cluster: %lld\n",
+ offset, cluster_offset, offset_in_cluster);
+
+ ASSERT(len < 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)
+{
+ struct xloop_file_fmt *xlo_fmt = file->private_data;
+ struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
+ ssize_t len = 0;
+ int ret = 0;
+
+ 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);
+ if (len < 0)
+ return len;
+
+ qcow_data->dbgfs_file_qcow_offset_buf[len] = '\0';
+
+ ret = mutex_lock_interruptible(&qcow_data->dbgfs_qcow_offset_mutex);
+ if (ret)
+ return ret;
+
+ ret = kstrtou64(qcow_data->dbgfs_file_qcow_offset_buf, 10,
+ &qcow_data->dbgfs_qcow_offset);
+ if (ret < 0)
+ goto out;
+
+ ret = len;
+out:
+ mutex_unlock(&qcow_data->dbgfs_qcow_offset_mutex);
+ 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 int __qcow_file_fmt_dbgfs_init(struct xloop_file_fmt *xlo_fmt)
+{
+ struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
+ struct xloop_device *xlo = xloop_file_fmt_get_xlo(xlo_fmt);
+ int ret = 0;
+
+ qcow_data->dbgfs_dir = debugfs_create_dir("QCOW", xlo->xlo_dbgfs_dir);
+ if (IS_ERR_OR_NULL(qcow_data->dbgfs_dir)) {
+ ret = -ENODEV;
+ 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);
+ 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);
+ if (IS_ERR_OR_NULL(qcow_data->dbgfs_file_qcow_offset)) {
+ qcow_data->dbgfs_file_qcow_offset = NULL;
+ ret = -ENODEV;
+ goto out_free_dbgfs_hdr;
+ }
+
+ qcow_data->dbgfs_qcow_offset = 0;
+ mutex_init(&qcow_data->dbgfs_qcow_offset_mutex);
+
+ return ret;
+
+out_free_dbgfs_hdr:
+ debugfs_remove(qcow_data->dbgfs_file_qcow_header);
+ qcow_data->dbgfs_file_qcow_header = NULL;
+out_free_dbgfs_dir:
+ debugfs_remove(qcow_data->dbgfs_dir);
+ qcow_data->dbgfs_dir = NULL;
+out:
+ return ret;
+}
+
+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);
+
+ mutex_destroy(&qcow_data->dbgfs_qcow_offset_mutex);
+
+ if (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);
+}
+#endif
+
+static int qcow_file_fmt_init(struct xloop_file_fmt *xlo_fmt)
+{
+ struct xloop_file_fmt_qcow_data *qcow_data;
+ struct xloop_device *xlo = xloop_file_fmt_get_xlo(xlo_fmt);
+ struct xloop_file_fmt_qcow_header header;
+ u64 l1_vm_state_index;
+ u64 l2_cache_size;
+ u64 l2_cache_entry_size;
+ ssize_t len;
+ unsigned int i;
+ int ret = 0;
+
+ /* allocate memory for saving QCOW file format data */
+ qcow_data = kzalloc(sizeof(*qcow_data), GFP_KERNEL);
+ if (!qcow_data)
+ return -ENOMEM;
+
+ xlo_fmt->private_data = qcow_data;
+
+ /* read the QCOW file header */
+ ret = __qcow_file_fmt_header_read(xlo->xlo_backing_file, &header);
+ 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 */
+#ifdef CONFIG_DEBUG_FS
+ __qcow_file_fmt_header_to_buf(xlo_fmt, &header);
+#endif
+
+ qcow_data->qcow_version = header.version;
+
+ /* Initialise cluster size */
+ if (header.cluster_bits < QCOW_MIN_CLUSTER_BITS
+ || header.cluster_bits > QCOW_MAX_CLUSTER_BITS) {
+ printk(KERN_ERR "xloop_file_fmt_qcow: unsupported cluster "
+ "size: 2^%d", header.cluster_bits);
+ ret = -EINVAL;
+ goto free_qcow_data;
+ }
+
+ qcow_data->cluster_bits = header.cluster_bits;
+ qcow_data->cluster_size = 1 << qcow_data->cluster_bits;
+ qcow_data->cluster_sectors = 1 <<
+ (qcow_data->cluster_bits - SECTOR_SHIFT);
+
+ if (header.header_length > qcow_data->cluster_size) {
+ printk(KERN_ERR "xloop_file_fmt_qcow: QCOW header exceeds "
+ "cluster size");
+ ret = -EINVAL;
+ goto free_qcow_data;
+ }
+
+ if (header.backing_file_offset > qcow_data->cluster_size) {
+ printk(KERN_ERR "xloop_file_fmt_qcow: invalid backing file "
+ "offset");
+ ret = -EINVAL;
+ goto free_qcow_data;
+ }
+
+ if (header.backing_file_offset) {
+ printk(KERN_ERR "xloop_file_fmt_qcow: backing file support not "
+ "available");
+ ret = -ENOTSUPP;
+ goto free_qcow_data;
+ }
+
+ /* handle feature bits */
+ qcow_data->incompatible_features = header.incompatible_features;
+ qcow_data->compatible_features = header.compatible_features;
+ qcow_data->autoclear_features = header.autoclear_features;
+
+ if (qcow_data->incompatible_features & QCOW_INCOMPAT_DIRTY) {
+ printk(KERN_ERR "xloop_file_fmt_qcow: image contains "
+ "inconsistent refcounts");
+ ret = -EACCES;
+ goto free_qcow_data;
+ }
+
+ if (qcow_data->incompatible_features & QCOW_INCOMPAT_CORRUPT) {
+ printk(KERN_ERR "xloop_file_fmt_qcow: image is corrupt; cannot "
+ "be opened read/write");
+ ret = -EACCES;
+ goto free_qcow_data;
+ }
+
+ if (qcow_data->incompatible_features & QCOW_INCOMPAT_DATA_FILE) {
+ printk(KERN_ERR "xloop_file_fmt_qcow: clusters in the external "
+ "data file are not refcounted");
+ ret = -EACCES;
+ goto free_qcow_data;
+ }
+
+ /* Check support for various header values */
+ if (header.refcount_order > 6) {
+ printk(KERN_ERR "xloop_file_fmt_qcow: reference count entry "
+ "width too large; may not exceed 64 bits");
+ ret = -EINVAL;
+ goto free_qcow_data;
+ }
+ qcow_data->refcount_order = header.refcount_order;
+ qcow_data->refcount_bits = 1 << qcow_data->refcount_order;
+ qcow_data->refcount_max = U64_C(1) << (qcow_data->refcount_bits - 1);
+ qcow_data->refcount_max += qcow_data->refcount_max - 1;
+
+ qcow_data->crypt_method_header = header.crypt_method;
+ if (qcow_data->crypt_method_header) {
+ printk(KERN_ERR "xloop_file_fmt_qcow: encryption support not "
+ "available");
+ ret = -ENOTSUPP;
+ goto free_qcow_data;
+ }
+
+ /* L2 is always one cluster */
+ qcow_data->l2_bits = qcow_data->cluster_bits - 3;
+ 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_size = 1 << qcow_data->refcount_block_bits;
+ qcow_data->size = header.size;
+ qcow_data->csize_shift = (62 - (qcow_data->cluster_bits - 8));
+ qcow_data->csize_mask = (1 << (qcow_data->cluster_bits - 8)) - 1;
+ 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);
+
+ if (header.refcount_table_clusters == 0) {
+ printk(KERN_ERR "xloop_file_fmt_qcow: image does not contain a "
+ "reference count table");
+ 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) {
+ goto free_qcow_data;
+ }
+
+ /* 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) {
+ goto free_qcow_data;
+ }
+
+ /* read the level 1 table */
+ ret = __qcow_file_fmt_validate_table(xlo_fmt, header.l1_table_offset,
+ header.l1_size, sizeof(u64), 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);
+ if (l1_vm_state_index > INT_MAX) {
+ printk(KERN_ERR "xloop_file_fmt_qcow: image is too big");
+ ret = -EFBIG;
+ goto free_qcow_data;
+ }
+ qcow_data->l1_vm_state_index = l1_vm_state_index;
+
+ /* 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) {
+ printk(KERN_ERR "xloop_file_fmt_qcow: L1 table is too small");
+ ret = -EINVAL;
+ goto free_qcow_data;
+ }
+
+ if (qcow_data->l1_size > 0) {
+ qcow_data->l1_table = vzalloc(round_up(qcow_data->l1_size *
+ sizeof(u64), 512));
+ if (qcow_data->l1_table == NULL) {
+ printk(KERN_ERR "xloop_file_fmt_qcow: could not "
+ "allocate L1 table");
+ ret = -ENOMEM;
+ goto free_qcow_data;
+ }
+ len = kernel_read(xlo->xlo_backing_file, qcow_data->l1_table,
+ qcow_data->l1_size * sizeof(u64),
+ &qcow_data->l1_table_offset);
+ if (len < 0) {
+ printk(KERN_ERR "xloop_file_fmt_qcow: could not read L1 "
+ "table");
+ 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]);
+ }
+ }
+
+ /* Internal snapshots */
+ qcow_data->snapshots_offset = header.snapshots_offset;
+ qcow_data->nb_snapshots = header.nb_snapshots;
+
+ if (qcow_data->nb_snapshots > 0) {
+ printk(KERN_ERR "xloop_file_fmt_qcow: snapshots support not "
+ "available");
+ ret = -ENOTSUPP;
+ goto free_l1_table;
+ }
+
+
+ /* create cache for L2 */
+ l2_cache_size = qcow_data->size / (qcow_data->cluster_size / 8);
+ l2_cache_entry_size = min(qcow_data->cluster_size, (int)4096);
+
+ /* limit the L2 size to maximum QCOW_DEFAULT_L2_CACHE_MAX_SIZE */
+ l2_cache_size = min(l2_cache_size, (u64)QCOW_DEFAULT_L2_CACHE_MAX_SIZE);
+
+ /* calculate the number of cache tables */
+ l2_cache_size /= l2_cache_entry_size;
+ if (l2_cache_size < QCOW_MIN_L2_CACHE_SIZE) {
+ l2_cache_size = QCOW_MIN_L2_CACHE_SIZE;
+ }
+
+ if (l2_cache_size > INT_MAX) {
+ printk(KERN_ERR "xloop_file_fmt_qcow: L2 cache size too big");
+ ret = -EINVAL;
+ goto free_l1_table;
+ }
+
+ qcow_data->l2_slice_size = l2_cache_entry_size / sizeof(u64);
+
+ 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;
+ }
+
+ /* initialize compression support */
+ ret = __qcow_file_fmt_compression_init(xlo_fmt);
+ if (ret < 0)
+ goto free_l2_cache;
+
+ /* initialize debugfs entries */
+#ifdef CONFIG_DEBUG_FS
+ ret = __qcow_file_fmt_dbgfs_init(xlo_fmt);
+ if (ret < 0)
+ goto free_l2_cache;
+#endif
+
+ return ret;
+
+free_l2_cache:
+ xloop_file_fmt_qcow_cache_destroy(xlo_fmt);
+free_l1_table:
+ vfree(qcow_data->l1_table);
+free_qcow_data:
+ kfree(qcow_data);
+ xlo_fmt->private_data = NULL;
+ return ret;
+}
+
+static void qcow_file_fmt_exit(struct xloop_file_fmt *xlo_fmt)
+{
+ struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
+
+#ifdef CONFIG_DEBUG_FS
+ __qcow_file_fmt_dbgfs_exit(xlo_fmt);
+#endif
+
+ __qcow_file_fmt_compression_exit(xlo_fmt);
+
+ if (qcow_data->l1_table) {
+ vfree(qcow_data->l1_table);
+ }
+
+ 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;
+ }
+}
+
+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;
+ int ret = 0;
+
+ qcow_data->strm->avail_in = src_size;
+ qcow_data->strm->next_in = (void *) src;
+ qcow_data->strm->avail_out = dest_size;
+ qcow_data->strm->next_out = dest;
+
+ ret = zlib_inflateInit2(qcow_data->strm, -12);
+ if (ret != Z_OK) {
+ return -1;
+ }
+
+ ret = zlib_inflate(qcow_data->strm, Z_FINISH);
+ if ((ret != Z_STREAM_END && ret != Z_BUF_ERROR)
+ || qcow_data->strm->avail_out != 0) {
+ /* We approve Z_BUF_ERROR because we need @dest buffer to be
+ * filled, but @src buffer may be processed partly (because in
+ * qcow2 we know size of compressed data with precision of one
+ * sector) */
+ ret = -1;
+ } else {
+ ret = 0;
+ }
+ return ret;
+}
+
+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);
+ int ret = 0, csize, nb_csectors;
+ u64 coffset;
+ u8 *in_buf = NULL;
+ ssize_t len;
+ void *data;
+ unsigned long irq_flags;
+ 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);
+
+
+ if (qcow_data->cmp_last_coffset != coffset) {
+ in_buf = vmalloc(csize);
+ if (!in_buf) {
+ qcow_data->cmp_last_coffset = ULLONG_MAX;
+ return -ENOMEM;
+ }
+ qcow_data->cmp_last_coffset = coffset;
+ len = kernel_read(xlo->xlo_backing_file, in_buf, csize, &coffset);
+ if (len < 0) {
+ qcow_data->cmp_last_coffset = ULLONG_MAX;
+ ret = len;
+ 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) {
+ qcow_data->cmp_last_coffset = ULLONG_MAX;
+ ret = -EIO;
+ goto out_free_in_buf;
+ }
+ }
+
+ ASSERT(bytes <= bvec->bv_len);
+ data = bvec_kmap_irq(bvec, &irq_flags) + bytes_done;
+ memcpy(data, qcow_data->cmp_out_buf + offset_in_cluster, bytes);
+ flush_dcache_page(bvec->bv_page);
+ bvec_kunmap_irq(data, &irq_flags);
+
+out_free_in_buf:
+ vfree(in_buf);
+
+ return ret;
+}
+
+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);
+ int offset_in_cluster;
+ int ret;
+ unsigned int cur_bytes; /* number of bytes in current iteration */
+ u64 bytes;
+ u64 cluster_offset = 0;
+ u64 bytes_done = 0;
+ void *data;
+ unsigned long irq_flags;
+ ssize_t len;
+ loff_t pos_read;
+
+ bytes = bvec->bv_len;
+
+ while (bytes != 0) {
+
+ /* prepare next request */
+ cur_bytes = bytes;
+
+ ret = xloop_file_fmt_qcow_cluster_get_offset(xlo_fmt, *ppos,
+ &cur_bytes, &cluster_offset);
+ if (ret < 0) {
+ goto fail;
+ }
+
+ offset_in_cluster = xloop_file_fmt_qcow_offset_into_cluster(
+ qcow_data, *ppos);
+
+ switch (ret) {
+ case QCOW_CLUSTER_UNALLOCATED:
+ case QCOW_CLUSTER_ZERO_PLAIN:
+ case QCOW_CLUSTER_ZERO_ALLOC:
+ data = bvec_kmap_irq(bvec, &irq_flags) + bytes_done;
+ memset(data, 0, cur_bytes);
+ flush_dcache_page(bvec->bv_page);
+ bvec_kunmap_irq(data, &irq_flags);
+ break;
+
+ case QCOW_CLUSTER_COMPRESSED:
+ ret = __qcow_file_fmt_read_compressed(xlo_fmt, bvec,
+ cluster_offset, *ppos, cur_bytes, bytes_done);
+ if (ret < 0) {
+ goto fail;
+ }
+
+ break;
+
+ case QCOW_CLUSTER_NORMAL:
+ if ((cluster_offset & 511) != 0) {
+ ret = -EIO;
+ goto fail;
+ }
+
+ pos_read = cluster_offset + offset_in_cluster;
+
+ data = bvec_kmap_irq(bvec, &irq_flags) + bytes_done;
+ len = kernel_read(xlo->xlo_backing_file, data, cur_bytes,
+ &pos_read);
+ flush_dcache_page(bvec->bv_page);
+ bvec_kunmap_irq(data, &irq_flags);
+
+ if (len < 0)
+ return len;
+
+ break;
+
+ default:
+ ret = -EIO;
+ goto fail;
+ }
+
+ bytes -= cur_bytes;
+ *ppos += cur_bytes;
+ bytes_done += cur_bytes;
+ }
+
+ ret = 0;
+
+fail:
+ return ret;
+}
+
+static int qcow_file_fmt_read(struct xloop_file_fmt *xlo_fmt,
+ struct request *rq)
+{
+ struct bio_vec bvec;
+ struct req_iterator iter;
+ loff_t pos;
+ int ret = 0;
+
+ pos = __qcow_file_fmt_rq_get_pos(xlo_fmt, rq);
+
+ rq_for_each_segment(bvec, rq, iter) {
+ ret = __qcow_file_fmt_read_bvec(xlo_fmt, &bvec, &pos);
+ if (ret)
+ return ret;
+
+ cond_resched();
+ }
+
+ 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)
+{
+ struct xloop_file_fmt_qcow_header header;
+ loff_t xloopsize;
+ int ret;
+
+ /* temporary read the QCOW file header of other QCOW image file */
+ ret = __qcow_file_fmt_header_read(file, &header);
+ if (ret)
+ return 0;
+
+ /* compute xloopsize in bytes */
+ xloopsize = header.size;
+ if (offset > 0)
+ xloopsize -= offset;
+ /* offset is beyond i_size, weird but possible */
+ if (xloopsize < 0)
+ return 0;
+
+ if (sizelimit > 0 && sizelimit < xloopsize)
+ xloopsize = sizelimit;
+ /*
+ * Unfortunately, if we want to do I/O on the device,
+ * the number of 512-byte sectors has to fit into a sector_t.
+ */
+ return xloopsize >> 9;
+}
+
+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,
+ .write_zeros = NULL,
+ .discard = NULL,
+ .flush = NULL,
+ .sector_size = qcow_file_fmt_sector_size,
+};
+
+static struct xloop_file_fmt_driver qcow_file_fmt_driver = {
+ .name = "QCOW",
+ .file_fmt_type = XLO_FILE_FMT_QCOW,
+ .ops = &qcow_file_fmt_ops,
+ .owner = THIS_MODULE,
+};
+
+static int __init xloop_file_fmt_qcow_init(void)
+{
+ printk(KERN_INFO "xloop_file_fmt_qcow: init xloop device QCOW file "
+ "format driver");
+ return xloop_file_fmt_register_driver(&qcow_file_fmt_driver);
+}
+
+static void __exit xloop_file_fmt_qcow_exit(void)
+{
+ printk(KERN_INFO "xloop_file_fmt_qcow: exit xloop device QCOW file "
+ "format driver");
+ xloop_file_fmt_unregister_driver(&qcow_file_fmt_driver);
+}
+
+module_init(xloop_file_fmt_qcow_init);
+module_exit(xloop_file_fmt_qcow_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Manuel Bentele ");
+MODULE_DESCRIPTION("xloop device QCOW file format driver");
+MODULE_SOFTDEP("pre: xloop");
diff --git a/kernel/loop_file_fmt_qcow_main.h b/kernel/loop_file_fmt_qcow_main.h
new file mode 100644
index 0000000..54b94c3
--- /dev/null
+++ b/kernel/loop_file_fmt_qcow_main.h
@@ -0,0 +1,419 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * xloop_file_fmt_qcow.h
+ *
+ * QCOW file format driver for the xloop device module.
+ *
+ * Ported QCOW2 implementation of the QEMU project (GPL-2.0):
+ * Declarations for the QCOW2 file format.
+ *
+ * The copyright (C) 2004-2006 of the original code is owned by Fabrice Bellard.
+ *
+ * Copyright (C) 2019 Manuel Bentele
+ */
+
+#ifndef _LINUX_XLOOP_FILE_FMT_QCOW_H
+#define _LINUX_XLOOP_FILE_FMT_QCOW_H
+
+#include
+#include
+#include
+#include
+
+#ifdef CONFIG_DEBUG_FS
+#include
+#endif
+
+#include "loop_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)
+#else
+#define ASSERT(x) do { } while (0)
+#endif
+
+#define KiB (1024)
+#define MiB (1024 * 1024)
+
+#define QCOW_MAGIC (('Q' << 24) | ('F' << 16) | ('I' << 8) | 0xfb)
+
+#define QCOW_CRYPT_NONE 0
+#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
+ * 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). */
+#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) */
+#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) */
+#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 */
+#define QCOW_MAX_SNAPSHOTS_SIZE (1024 * QCOW_MAX_SNAPSHOTS)
+
+/* Bitmap header extension constraints */
+#define QCOW_MAX_BITMAPS 65535
+#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)
+/* indicate that the cluster is compressed (they never have the copied flag) */
+#define QCOW_OFLAG_COMPRESSED (1ULL << 62)
+/* The cluster reads as all zeros */
+#define QCOW_OFLAG_ZERO (1ULL << 0)
+
+#define QCOW_MIN_CLUSTER_BITS 9
+#define QCOW_MAX_CLUSTER_BITS 21
+
+/* Defined in the qcow2 spec (compressed cluster descriptor) */
+#define QCOW_COMPRESSED_SECTOR_SIZE 512U
+#define QCOW_COMPRESSED_SECTOR_MASK (~(QCOW_COMPRESSED_SECTOR_SIZE - 1))
+
+/* Must be at least 2 to cover COW */
+#define QCOW_MIN_L2_CACHE_SIZE 2 /* cache entries */
+
+/* Must be at least 4 to cover all cases of refcount table growth */
+#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_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 */
+#define QCOW_OFFSET_BUF_LEN 32
+#define QCOW_CLUSTER_BUF_LEN 128
+
+struct xloop_file_fmt_qcow_header {
+ u32 magic;
+ u32 version;
+ u64 backing_file_offset;
+ u32 backing_file_size;
+ u32 cluster_bits;
+ u64 size; /* in bytes */
+ u32 crypt_method;
+ u32 l1_size;
+ u64 l1_table_offset;
+ u64 refcount_table_offset;
+ u32 refcount_table_clusters;
+ u32 nb_snapshots;
+ u64 snapshots_offset;
+
+ /* The following fields are only valid for version >= 3 */
+ u64 incompatible_features;
+ u64 compatible_features;
+ u64 autoclear_features;
+
+ u32 refcount_order;
+ u32 header_length;
+} __attribute__((packed));
+
+struct xloop_file_fmt_qcow_snapshot_header {
+ /* header is 8 byte aligned */
+ u64 l1_table_offset;
+
+ u32 l1_size;
+ u16 id_str_size;
+ u16 name_size;
+
+ u32 date_sec;
+ u32 date_nsec;
+
+ u64 vm_clock_nsec;
+
+ u32 vm_state_size;
+ /* for extension */
+ u32 extra_data_size;
+ /* extra data follows */
+ /* id_str follows */
+ /* name follows */
+} __attribute__((packed));
+
+enum {
+ 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 = 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_MASK = QCOW_INCOMPAT_DIRTY
+ | QCOW_INCOMPAT_CORRUPT
+ | QCOW_INCOMPAT_DATA_FILE,
+};
+
+/* compatible feature bits */
+enum {
+ QCOW_COMPAT_LAZY_REFCOUNTS_BITNR = 0,
+ QCOW_COMPAT_LAZY_REFCOUNTS = 1 << QCOW_COMPAT_LAZY_REFCOUNTS_BITNR,
+
+ QCOW_COMPAT_FEAT_MASK = QCOW_COMPAT_LAZY_REFCOUNTS,
+};
+
+/* autoclear feature bits */
+enum {
+ QCOW_AUTOCLEAR_BITMAPS_BITNR = 0,
+ QCOW_AUTOCLEAR_DATA_FILE_RAW_BITNR = 1,
+ 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,
+};
+
+struct xloop_file_fmt_qcow_data {
+ u64 size;
+ int cluster_bits;
+ int cluster_size;
+ int cluster_sectors;
+ int l2_slice_size;
+ 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;
+
+ 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;
+
+ 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;
+
+ struct z_stream_s *strm;
+ u8 *cmp_out_buf;
+ u64 cmp_last_coffset;
+
+ /* 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];
+ 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;
+#endif
+};
+
+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;
+
+ /** Number of bytes to copy */
+ unsigned nb_bytes;
+};
+
+enum xloop_file_fmt_qcow_cluster_type {
+ QCOW_CLUSTER_UNALLOCATED,
+ QCOW_CLUSTER_ZERO_PLAIN,
+ QCOW_CLUSTER_ZERO_ALLOC,
+ QCOW_CLUSTER_NORMAL,
+ QCOW_CLUSTER_COMPRESSED,
+};
+
+enum xloop_file_fmt_qcow_metadata_overlap {
+ QCOW_OL_MAIN_HEADER_BITNR = 0,
+ QCOW_OL_ACTIVE_L1_BITNR = 1,
+ QCOW_OL_ACTIVE_L2_BITNR = 2,
+ QCOW_OL_REFCOUNT_TABLE_BITNR = 3,
+ QCOW_OL_REFCOUNT_BLOCK_BITNR = 4,
+ QCOW_OL_SNAPSHOT_TABLE_BITNR = 5,
+ QCOW_OL_INACTIVE_L1_BITNR = 6,
+ QCOW_OL_INACTIVE_L2_BITNR = 7,
+ QCOW_OL_BITMAP_DIRECTORY_BITNR = 8,
+
+ 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),
+};
+
+/* 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)
+
+/* 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)
+
+/* Perform all overlap checks */
+#define QCOW_OL_ALL \
+ (QCOW_OL_CACHED | QCOW_OL_INACTIVE_L2)
+
+#define L1E_OFFSET_MASK 0x00fffffffffffe00ULL
+#define L2E_OFFSET_MASK 0x00fffffffffffe00ULL
+#define L2E_COMPRESSED_OFFSET_SIZE_MASK 0x3fffffffffffffffULL
+
+#define REFT_OFFSET_MASK 0xfffffffffffffe00ULL
+
+#define INV_OFFSET (-1ULL)
+
+static inline bool xloop_file_fmt_qcow_has_data_file(
+ struct xloop_file_fmt *xlo_fmt)
+{
+ /* 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 *xlo_fmt)
+{
+ struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
+ 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)
+{
+ 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)
+{
+ return offset & (qcow_data->cluster_size - 1);
+}
+
+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;
+}
+
+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)
+{
+ 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)
+{
+ 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)
+{
+ return (offset >> qcow_data->cluster_bits) &
+ (qcow_data->l2_slice_size - 1);
+}
+
+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);
+}
+
+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)
+{
+ if (l2_entry & QCOW_OFLAG_COMPRESSED) {
+ return QCOW_CLUSTER_COMPRESSED;
+ } else if (l2_entry & QCOW_OFLAG_ZERO) {
+ if (l2_entry & L2E_OFFSET_MASK) {
+ return QCOW_CLUSTER_ZERO_ALLOC;
+ }
+ return QCOW_CLUSTER_ZERO_PLAIN;
+ } else if (!(l2_entry & L2E_OFFSET_MASK)) {
+ /* 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(xlo_fmt) &&
+ (l2_entry & QCOW_OFLAG_COPIED)) {
+ return QCOW_CLUSTER_NORMAL;
+ } else {
+ return QCOW_CLUSTER_UNALLOCATED;
+ }
+ } else {
+ return QCOW_CLUSTER_NORMAL;
+ }
+}
+
+#endif
diff --git a/kernel/loop_file_fmt_raw.c b/kernel/loop_file_fmt_raw.c
new file mode 100644
index 0000000..11cc8cd
--- /dev/null
+++ b/kernel/loop_file_fmt_raw.c
@@ -0,0 +1,465 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * xloop_file_fmt_raw.c
+ *
+ * RAW file format driver for the xloop device module.
+ *
+ * Copyright (C) 2019 Manuel Bentele
+ */
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include "loop_file_fmt.h"
+
+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;
+}
+
+/* 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)
+{
+ int ret;
+
+ ret = xlo->transfer(xlo, cmd, rpage, roffs, lpage, loffs, size, rblock);
+ if (likely(!ret))
+ return 0;
+
+ printk_ratelimited(KERN_ERR
+ "xloop_file_fmt_raw: 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)
+{
+ struct bio_vec bvec, b;
+ struct req_iterator iter;
+ struct iov_iter i;
+ struct page *page;
+ ssize_t len;
+ int ret = 0;
+
+ page = alloc_page(GFP_NOIO);
+ if (unlikely(!page))
+ return -ENOMEM;
+
+ rq_for_each_segment(bvec, rq, iter) {
+ loff_t offset = pos;
+
+ b.bv_page = page;
+ b.bv_offset = 0;
+ b.bv_len = bvec.bv_len;
+
+ iov_iter_bvec(&i, READ, &b, 1, b.bv_len);
+ len = vfs_iter_read(xlo->xlo_backing_file, &i, &pos, 0);
+ if (len < 0) {
+ ret = len;
+ goto out_free_page;
+ }
+
+ 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;
+
+ flush_dcache_page(bvec.bv_page);
+
+ if (len != bvec.bv_len) {
+ struct bio *bio;
+
+ __rq_for_each_bio(bio, rq)
+ zero_fill_bio(bio);
+ break;
+ }
+ }
+
+ ret = 0;
+out_free_page:
+ __free_page(page);
+ return ret;
+}
+
+static int raw_file_fmt_read(struct xloop_file_fmt *xlo_fmt,
+ struct request *rq)
+{
+ struct bio_vec bvec;
+ struct req_iterator iter;
+ struct iov_iter i;
+ ssize_t len;
+ struct xloop_device *xlo;
+ loff_t pos;
+
+ xlo = xloop_file_fmt_get_xlo(xlo_fmt);
+ pos = __raw_file_fmt_rq_get_pos(xlo_fmt, rq);
+
+ if (xlo->transfer)
+ return __raw_file_fmt_read_transfer(xlo, rq, pos);
+
+ rq_for_each_segment(bvec, rq, iter) {
+ iov_iter_bvec(&i, READ, &bvec, 1, bvec.bv_len);
+ len = vfs_iter_read(xlo->xlo_backing_file, &i, &pos, 0);
+ if (len < 0)
+ return len;
+
+ flush_dcache_page(bvec.bv_page);
+
+ if (len != bvec.bv_len) {
+ struct bio *bio;
+
+ __rq_for_each_bio(bio, rq)
+ zero_fill_bio(bio);
+ break;
+ }
+ cond_resched();
+ }
+
+ return 0;
+}
+
+static void __raw_file_fmt_rw_aio_do_completion(struct xloop_cmd *cmd)
+{
+ struct request *rq = blk_mq_rq_from_pdu(cmd);
+
+ if (!atomic_dec_and_test(&cmd->ref))
+ return;
+ kfree(cmd->bvec);
+ cmd->bvec = NULL;
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 9, 0)
+ if (likely(!blk_should_fake_timeout(rq->q)))
+ blk_mq_complete_request(rq);
+#else
+ blk_mq_complete_request(rq);
+#endif
+}
+
+static void __raw_file_fmt_rw_aio_complete(struct kiocb *iocb, long ret, long ret2)
+{
+ struct xloop_cmd *cmd = container_of(iocb, struct xloop_cmd, iocb);
+
+ if (cmd->css)
+ css_put(cmd->css);
+ cmd->ret = ret;
+ __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)
+{
+ struct iov_iter iter;
+ struct req_iterator rq_iter;
+ struct bio_vec *bvec;
+ struct request *rq = blk_mq_rq_from_pdu(cmd);
+ struct bio *bio = rq->bio;
+ struct file *file = xlo->xlo_backing_file;
+ struct bio_vec tmp;
+ unsigned int offset;
+ int nr_bvec = 0;
+ int ret;
+
+ rq_for_each_bvec(tmp, rq, rq_iter)
+ nr_bvec++;
+
+ if (rq->bio != rq->biotail) {
+
+ bvec = kmalloc_array(nr_bvec, sizeof(struct bio_vec),
+ GFP_NOIO);
+ if (!bvec)
+ return -EIO;
+ cmd->bvec = bvec;
+
+ /*
+ * The bios of the request may be started from the middle of
+ * the 'bvec' because of bio splitting, so we can't directly
+ * copy bio->bi_iov_vec to new bvec. The rq_for_each_bvec
+ * API will take care of all details for us.
+ */
+ rq_for_each_bvec(tmp, rq, rq_iter) {
+ *bvec = tmp;
+ bvec++;
+ }
+ bvec = cmd->bvec;
+ offset = 0;
+ } else {
+ /*
+ * Same here, this bio may be started from the middle of the
+ * 'bvec' because of bio splitting, so offset from the bvec
+ * must be passed to iov iterator
+ */
+ offset = bio->bi_iter.bi_bvec_done;
+ bvec = __bvec_iter_bvec(bio->bi_io_vec, bio->bi_iter);
+ }
+ atomic_set(&cmd->ref, 2);
+
+ iov_iter_bvec(&iter, rw, bvec, nr_bvec, blk_rq_bytes(rq));
+ iter.iov_offset = offset;
+
+ cmd->iocb.ki_pos = pos;
+ cmd->iocb.ki_filp = file;
+ cmd->iocb.ki_complete = __raw_file_fmt_rw_aio_complete;
+ cmd->iocb.ki_flags = IOCB_DIRECT;
+ cmd->iocb.ki_ioprio = IOPRIO_PRIO_VALUE(IOPRIO_CLASS_NONE, 0);
+ if (cmd->css)
+ kthread_associate_blkcg(cmd->css);
+
+ if (rw == WRITE)
+ ret = call_write_iter(file, &cmd->iocb, &iter);
+ else
+ ret = call_read_iter(file, &cmd->iocb, &iter);
+
+ __raw_file_fmt_rw_aio_do_completion(cmd);
+ kthread_associate_blkcg(NULL);
+
+ if (ret != -EIOCBQUEUED)
+ cmd->iocb.ki_complete(&cmd->iocb, ret, 0);
+ return 0;
+}
+
+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);
+ loff_t pos = __raw_file_fmt_rq_get_pos(xlo_fmt, rq);
+
+ 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)
+{
+ struct iov_iter i;
+ ssize_t bw;
+
+ iov_iter_bvec(&i, WRITE, bvec, 1, bvec->bv_len);
+
+ file_start_write(file);
+ bw = vfs_iter_write(file, &i, ppos, 0);
+ file_end_write(file);
+
+ if (likely(bw == bvec->bv_len))
+ return 0;
+
+ printk_ratelimited(KERN_ERR
+ "xloop_file_fmt_raw: Write error at byte offset %llu, length "
+ "%i.\n", (unsigned long long)*ppos, bvec->bv_len);
+ if (bw >= 0)
+ bw = -EIO;
+ return bw;
+}
+
+/*
+ * This is the slow, transforming version that needs to double buffer the
+ * 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)
+{
+struct bio_vec bvec, b;
+ struct req_iterator iter;
+ struct page *page;
+ int ret = 0;
+
+ page = alloc_page(GFP_NOIO);
+ if (unlikely(!page))
+ 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);
+ if (unlikely(ret))
+ break;
+
+ b.bv_page = page;
+ b.bv_offset = 0;
+ b.bv_len = bvec.bv_len;
+ ret = __raw_file_fmt_write_bvec(xlo->xlo_backing_file, &b, &pos);
+ if (ret < 0)
+ break;
+ }
+
+ __free_page(page);
+ return ret;
+}
+
+static int raw_file_fmt_write(struct xloop_file_fmt *xlo_fmt,
+ struct request *rq)
+{
+ struct bio_vec bvec;
+ struct req_iterator iter;
+ int ret = 0;
+ struct xloop_device *xlo;
+ loff_t pos;
+
+ xlo = xloop_file_fmt_get_xlo(xlo_fmt);
+ pos = __raw_file_fmt_rq_get_pos(xlo_fmt, rq);
+
+ if (xlo->transfer)
+ return __raw_file_fmt_write_transfer(xlo, rq, pos);
+
+ rq_for_each_segment(bvec, rq, iter) {
+ ret = __raw_file_fmt_write_bvec(xlo->xlo_backing_file, &bvec, &pos);
+ if (ret < 0)
+ break;
+ cond_resched();
+ }
+
+ return ret;
+}
+
+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);
+ loff_t pos = __raw_file_fmt_rq_get_pos(xlo_fmt, rq);
+
+ 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)
+{
+ /*
+ * We use fallocate to manipulate the space mappings used by the image
+ * a.k.a. discard/zerorange. However we do not support this if
+ * encryption is enabled, because it may give an attacker useful
+ * information.
+ */
+ struct file *file = xlo->xlo_backing_file;
+ struct request_queue *q = xlo->xlo_queue;
+ int ret;
+
+ mode |= FALLOC_FL_KEEP_SIZE;
+
+ if (!blk_queue_discard(q)) {
+ ret = -EOPNOTSUPP;
+ goto out;
+ }
+
+ ret = file->f_op->fallocate(file, mode, pos, blk_rq_bytes(rq));
+ if (unlikely(ret && ret != -EINVAL && ret != -EOPNOTSUPP))
+ ret = -EIO;
+out:
+ return ret;
+}
+
+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);
+
+ /*
+ * If the caller doesn't want deallocation, call zeroout to
+ * 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);
+}
+
+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);
+
+ return __raw_file_fmt_fallocate(xlo, rq, pos, FALLOC_FL_PUNCH_HOLE);
+}
+
+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)
+{
+ loff_t xloopsize;
+
+ /* Compute xloopsize in bytes */
+ xloopsize = i_size_read(file->f_mapping->host);
+ if (offset > 0)
+ xloopsize -= offset;
+ /* offset is beyond i_size, weird but possible */
+ if (xloopsize < 0)
+ return 0;
+
+ if (sizelimit > 0 && sizelimit < xloopsize)
+ xloopsize = sizelimit;
+ /*
+ * Unfortunately, if we want to do I/O on the device,
+ * the number of 512-byte sectors has to fit into a sector_t.
+ */
+ return xloopsize >> 9;
+}
+
+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,
+ .write_zeros = raw_file_fmt_write_zeros,
+ .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",
+ .file_fmt_type = XLO_FILE_FMT_RAW,
+ .ops = &raw_file_fmt_ops,
+ .owner = THIS_MODULE,
+};
+
+static int __init xloop_file_fmt_raw_init(void)
+{
+ printk(KERN_INFO "xloop_file_fmt_raw: init xloop device RAW file format "
+ "driver");
+ return xloop_file_fmt_register_driver(&raw_file_fmt_driver);
+}
+
+static void __exit xloop_file_fmt_raw_exit(void)
+{
+ printk(KERN_INFO "xloop_file_fmt_raw: exit xloop device RAW file format "
+ "driver");
+ xloop_file_fmt_unregister_driver(&raw_file_fmt_driver);
+}
+
+module_init(xloop_file_fmt_raw_init);
+module_exit(xloop_file_fmt_raw_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Manuel Bentele ");
+MODULE_DESCRIPTION("xloop device RAW file format driver");
+MODULE_SOFTDEP("pre: xloop");
diff --git a/kernel/loop_main.c b/kernel/loop_main.c
new file mode 100644
index 0000000..9cd9c99
--- /dev/null
+++ b/kernel/loop_main.c
@@ -0,0 +1,2221 @@
+/*
+ * loop_main.c
+ *
+ * Written by Theodore Ts'o, 3/29/93
+ *
+ * Copyright 1993 by Theodore Ts'o. Redistribution of this file is
+ * permitted under the GNU General Public License.
+ *
+ * DES encryption plus some minor changes by Werner Almesberger, 30-MAY-1993
+ * more DES encryption plus IDEA encryption by Nicholas J. Leon, June 20, 1996
+ *
+ * Modularized and updated for 1.1.16 kernel - Mitch Dsouza 28th May 1994
+ * Adapted for 1.3.59 kernel - Andries Brouwer, 1 Feb 1996
+ *
+ * Fixed do_xloop_request() re-entrancy - Vincent.Renardias@waw.com Mar 20, 1997
+ *
+ * Added devfs support - Richard Gooch 16-Jan-1998
+ *
+ * Handle sparse backing files correctly - Kenn Humborg, Jun 28, 1998
+ *
+ * Loadable modules and other fixes by AK, 1998
+ *
+ * Make real block number available to downstream transfer functions, enables
+ * CBC (and relatives) mode encryption requiring unique IVs per data block.
+ * Reed H. Petty, rhp@draper.net
+ *
+ * Maximum number of xloop devices now dynamic via max_xloop module parameter.
+ * Russell Kroll 19990701
+ *
+ * Maximum number of xloop devices when compiled-in now selectable by passing
+ * max_xloop=<1-255> to the kernel on boot.
+ * Erik I. Bolsø, , Oct 31, 1999
+ *
+ * Completely rewrite request handling to be make_request_fn style and
+ * non blocking, pushing work to a helper thread. Lots of fixes from
+ * Al Viro too.
+ * Jens Axboe , Nov 2000
+ *
+ * Support up to 256 xloop devices
+ * Heinz Mauelshagen , Feb 2002
+ *
+ * Support for falling back on the write file operation when the address space
+ * operations write_begin is not available on the backing filesystem.
+ * Anton Altaparmakov, 16 Feb 2005
+ *
+ * Support for using file formats.
+ * Manuel Bentele , 2019
+ *
+ * Still To Fix:
+ * - Advisory locking is ignored here.
+ * - Should use an own CAP_* category instead of CAP_SYS_ADMIN
+ *
+ */
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#ifdef CONFIG_DEBUG_FS
+#include
+#endif
+
+#include "loop_file_fmt.h"
+#include "loop_main.h"
+
+#include
+
+static DEFINE_IDR(xloop_index_idr);
+static DEFINE_MUTEX(xloop_ctl_mutex);
+
+static int max_part;
+static int part_shift;
+
+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)
+{
+ char *raw_buf = kmap_atomic(raw_page) + raw_off;
+ char *xloop_buf = kmap_atomic(xloop_page) + xloop_off;
+ char *in, *out, *key;
+ int i, keysize;
+
+ if (cmd == READ) {
+ in = raw_buf;
+ out = xloop_buf;
+ } else {
+ in = xloop_buf;
+ out = raw_buf;
+ }
+
+ key = xlo->xlo_encrypt_key;
+ keysize = xlo->xlo_encrypt_key_size;
+ for (i = 0; i < size; i++)
+ *out++ = *in++ ^ key[(i & 511) % keysize];
+
+ kunmap_atomic(xloop_buf);
+ kunmap_atomic(raw_buf);
+ cond_resched();
+ return 0;
+}
+
+static int xor_init(struct xloop_device *xlo, const struct xloop_info64 *info)
+{
+ if (unlikely(info->xlo_encrypt_key_size <= 0))
+ return -EINVAL;
+ return 0;
+}
+
+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
+};
+
+/* 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 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);
+}
+
+static void __xloop_update_dio(struct xloop_device *xlo, bool dio)
+{
+ struct file *file = xlo->xlo_backing_file;
+ struct address_space *mapping = file->f_mapping;
+ struct inode *inode = mapping->host;
+ unsigned short sb_bsize = 0;
+ unsigned dio_align = 0;
+ bool use_dio;
+
+ if (inode->i_sb->s_bdev) {
+ sb_bsize = bdev_logical_block_size(inode->i_sb->s_bdev);
+ dio_align = sb_bsize - 1;
+ }
+
+ /*
+ * We support direct I/O only if xlo_offset is aligned with the
+ * logical I/O size of backing device, and the logical block
+ * size of xloop is bigger than the backing device's and the xloop
+ * needn't transform transfer.
+ *
+ * TODO: the above condition may be loosed in the future, and
+ * direct I/O may be switched runtime at that time because most
+ * 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)
+ use_dio = true;
+ else
+ use_dio = false;
+ } else {
+ use_dio = false;
+ }
+
+ if (xlo->use_dio == use_dio)
+ return;
+
+ /* flush dirty pages before changing direct IO */
+ xloop_file_fmt_flush(xlo->xlo_fmt);
+
+ /*
+ * The flag of XLO_FLAGS_DIRECT_IO is handled similarly with
+ * XLO_FLAGS_READ_ONLY, both are set from kernel, and losetup
+ * will get updated by ioctl(XLOOP_GET_STATUS)
+ */
+ if (xlo->xlo_state == Xlo_bound)
+ blk_mq_freeze_queue(xlo->xlo_queue);
+ xlo->use_dio = use_dio;
+ if (use_dio) {
+ blk_queue_flag_clear(QUEUE_FLAG_NOMERGES, xlo->xlo_queue);
+ xlo->xlo_flags |= XLO_FLAGS_DIRECT_IO;
+ } else {
+ blk_queue_flag_set(QUEUE_FLAG_NOMERGES, xlo->xlo_queue);
+ xlo->xlo_flags &= ~XLO_FLAGS_DIRECT_IO;
+ }
+ if (xlo->xlo_state == Xlo_bound)
+ blk_mq_unfreeze_queue(xlo->xlo_queue);
+}
+
+/**
+ * xloop_validate_block_size() - validates the passed in block size
+ * @bsize: size to validate
+ */
+static int
+xloop_validate_block_size(unsigned short bsize)
+{
+ if (bsize < 512 || bsize > PAGE_SIZE || !is_power_of_2(bsize))
+ return -EINVAL;
+
+ return 0;
+}
+
+/**
+ * xloop_set_size() - sets device size and notifies userspace
+ * @xlo: struct xloop_device to set the size for
+ * @size: new size of the xloop device
+ *
+ * Callers must validate that the size passed into this function fits into
+ * a sector_t, eg using xloop_validate_size()
+ */
+static void xloop_set_size(struct xloop_device *xlo, loff_t size)
+{
+ struct block_device *bdev = xlo->xlo_device;
+#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 7, 0)
+ sector_t capacity;
+#endif
+
+ bd_set_size(bdev, size << SECTOR_SHIFT);
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 7, 0)
+ 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);
+ }
+#endif
+}
+
+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->ret < 0)
+ ret = errno_to_blk_status(cmd->ret);
+ goto end_io;
+ }
+
+ /*
+ * Short READ - if we got some data, advance our request and
+ * retry it. If we got no data, end the rest with EIO.
+ */
+ if (cmd->ret) {
+ blk_update_request(rq, BLK_STS_OK, cmd->ret);
+ cmd->ret = 0;
+ blk_mq_requeue_request(rq, true);
+ } else {
+ if (cmd->use_aio) {
+ struct bio *bio = rq->bio;
+
+ while (bio) {
+ zero_fill_bio(bio);
+ bio = bio->bi_next;
+ }
+ }
+ ret = BLK_STS_IOERR;
+end_io:
+ blk_mq_end_request(rq, ret);
+ }
+}
+
+static int do_req_filebacked(struct xloop_device *xlo, struct request *rq)
+{
+ struct xloop_cmd *cmd = blk_mq_rq_to_pdu(rq);
+
+ /*
+ * xlo_write_simple and xlo_read_simple should have been covered
+ * by io submit style function like xlo_rw_aio(), one blocker
+ * is that xlo_read_simple() need to call flush_dcache_page after
+ * the page is written from kernel, and it isn't easy to handle
+ * this in io submit style function which submits all segments
+ * of the req at one time. And direct read IO doesn't need to
+ * run flush_dcache_page().
+ */
+ switch (req_op(rq)) {
+ case REQ_OP_FLUSH:
+ return xloop_file_fmt_flush(xlo->xlo_fmt);
+ case REQ_OP_WRITE_ZEROES:
+ return xloop_file_fmt_write_zeros(xlo->xlo_fmt, rq);
+ case REQ_OP_DISCARD:
+ return xloop_file_fmt_discard(xlo->xlo_fmt, rq);
+ case REQ_OP_WRITE:
+ if (cmd->use_aio)
+ return xloop_file_fmt_write_aio(xlo->xlo_fmt, rq);
+ else
+ return xloop_file_fmt_write(xlo->xlo_fmt, rq);
+ case REQ_OP_READ:
+ if (cmd->use_aio)
+ return xloop_file_fmt_read_aio(xlo->xlo_fmt, rq);
+ else
+ return xloop_file_fmt_read(xlo->xlo_fmt, rq);
+ default:
+ WARN_ON_ONCE(1);
+ return -EIO;
+ }
+}
+
+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);
+}
+
+static void xloop_reread_partitions(struct xloop_device *xlo,
+ struct block_device *bdev)
+{
+ int rc;
+
+ mutex_lock(&bdev->bd_mutex);
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 5, 0)
+ rc = bdev_disk_changed(bdev, false);
+#else
+ rc = blkdev_reread_part(bdev);
+#endif
+ mutex_unlock(&bdev->bd_mutex);
+ if (rc)
+ pr_warn("%s: partition scan of xloop%d (%s) failed (rc=%d)\n",
+ __func__, xlo->xlo_number, xlo->xlo_file_name, rc);
+}
+
+static inline int is_xloop_device(struct file *file)
+{
+ struct inode *i = file->f_mapping->host;
+
+ return i && S_ISBLK(i->i_mode) && MAJOR(i->i_rdev) == LOOP_MAJOR;
+}
+
+static int xloop_validate_file(struct file *file, struct block_device *bdev)
+{
+ struct inode *inode = file->f_mapping->host;
+ struct file *f = file;
+
+ /* Avoid recursion */
+ while (is_xloop_device(f)) {
+ struct xloop_device *l;
+
+ if (f->f_mapping->host->i_bdev == bdev)
+ return -EBADF;
+
+ l = f->f_mapping->host->i_bdev->bd_disk->private_data;
+ if (l->xlo_state != Xlo_bound) {
+ return -EINVAL;
+ }
+ f = l->xlo_backing_file;
+ }
+ if (!S_ISREG(inode->i_mode) && !S_ISBLK(inode->i_mode))
+ return -EINVAL;
+ return 0;
+}
+
+/*
+ * xloop_change_fd switched the backing store of a xloopback device to
+ * a new file. This is useful for operating system installers to free up
+ * the original file and in High Availability environments to switch to
+ * an alternative location for the content in case of server meltdown.
+ * 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)
+{
+ struct file *file = NULL, *old_file;
+ int error;
+ bool partscan;
+
+ error = mutex_lock_killable(&xloop_ctl_mutex);
+ if (error)
+ return error;
+ error = -ENXIO;
+ if (xlo->xlo_state != Xlo_bound)
+ goto out_err;
+
+ /* the xloop device has to be read-only */
+ error = -EINVAL;
+ if (!(xlo->xlo_flags & XLO_FLAGS_READ_ONLY))
+ goto out_err;
+
+ error = -EBADF;
+ file = fget(arg);
+ if (!file)
+ goto out_err;
+
+ error = xloop_validate_file(file, bdev);
+ if (error)
+ goto out_err;
+
+ old_file = xlo->xlo_backing_file;
+
+ error = -EINVAL;
+
+ /* size of the new backing store needs to be the same */
+ if (get_xloop_size(xlo, file) != get_xloop_size(xlo, old_file))
+ goto out_err;
+
+ /* and ... switch */
+ blk_mq_freeze_queue(xlo->xlo_queue);
+ 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));
+ xloop_update_dio(xlo);
+ blk_mq_unfreeze_queue(xlo->xlo_queue);
+ partscan = xlo->xlo_flags & XLO_FLAGS_PARTSCAN;
+ mutex_unlock(&xloop_ctl_mutex);
+ /*
+ * We must drop file reference outside of xloop_ctl_mutex as dropping
+ * the file ref can take bd_mutex which creates circular locking
+ * dependency.
+ */
+ fput(old_file);
+ if (partscan)
+ xloop_reread_partitions(xlo, bdev);
+ return 0;
+
+out_err:
+ mutex_unlock(&xloop_ctl_mutex);
+ if (file)
+ fput(file);
+ return error;
+}
+
+/* xloop sysfs attributes */
+
+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;
+
+ 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);
+
+static ssize_t xloop_attr_backing_file_show(struct xloop_device *xlo, char *buf)
+{
+ ssize_t ret;
+ char *p = NULL;
+
+ spin_lock_irq(&xlo->xlo_lock);
+ if (xlo->xlo_backing_file)
+ p = file_path(xlo->xlo_backing_file, buf, PAGE_SIZE - 1);
+ spin_unlock_irq(&xlo->xlo_lock);
+
+ if (IS_ERR_OR_NULL(p))
+ ret = PTR_ERR(p);
+ else {
+ ret = strlen(p);
+ memmove(buf, p, ret);
+ buf[ret++] = '\n';
+ buf[ret] = 0;
+ }
+
+ return ret;
+}
+
+static ssize_t xloop_attr_file_fmt_type_show(struct xloop_device *xlo,
+ char *buf)
+{
+ ssize_t len = 0;
+
+ len = xloop_file_fmt_print_type(xlo->xlo_fmt->file_fmt_type, buf);
+ len += sprintf(buf + len, "\n");
+
+ return len;
+}
+
+static ssize_t xloop_attr_offset_show(struct xloop_device *xlo, char *buf)
+{
+ return sprintf(buf, "%llu\n", (unsigned long long)xlo->xlo_offset);
+}
+
+static ssize_t xloop_attr_sizelimit_show(struct xloop_device *xlo, char *buf)
+{
+ return sprintf(buf, "%llu\n", (unsigned long long)xlo->xlo_sizelimit);
+}
+
+static ssize_t xloop_attr_autoclear_show(struct xloop_device *xlo, char *buf)
+{
+ int autoclear = (xlo->xlo_flags & XLO_FLAGS_AUTOCLEAR);
+
+ return sprintf(buf, "%s\n", autoclear ? "1" : "0");
+}
+
+static ssize_t xloop_attr_partscan_show(struct xloop_device *xlo, char *buf)
+{
+ int partscan = (xlo->xlo_flags & XLO_FLAGS_PARTSCAN);
+
+ return sprintf(buf, "%s\n", partscan ? "1" : "0");
+}
+
+static ssize_t xloop_attr_dio_show(struct xloop_device *xlo, char *buf)
+{
+ int dio = (xlo->xlo_flags & XLO_FLAGS_DIRECT_IO);
+
+ return sprintf(buf, "%s\n", dio ? "1" : "0");
+}
+
+XLOOP_ATTR_RO(backing_file);
+XLOOP_ATTR_RO(file_fmt_type);
+XLOOP_ATTR_RO(offset);
+XLOOP_ATTR_RO(sizelimit);
+XLOOP_ATTR_RO(autoclear);
+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,
+};
+
+static struct attribute_group xloop_attribute_group = {
+ .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);
+}
+
+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);
+}
+
+static void xloop_config_discard(struct xloop_device *xlo)
+{
+ struct file *file = xlo->xlo_backing_file;
+ struct inode *inode = file->f_mapping->host;
+ struct request_queue *q = xlo->xlo_queue;
+ u32 granularity, max_discard_sectors;
+
+ /*
+ * If the backing device is a block device, mirror its zeroing
+ * capability. Set the discard sectors to the block device's zeroing
+ * capabilities because xloop discards result in blkdev_issue_zeroout(),
+ * not blkdev_issue_discard(). This maintains consistent behavior with
+ * file-backed xloop devices: discarded regions read back as zero.
+ */
+ if (S_ISBLK(inode->i_mode) && !xlo->xlo_encrypt_key_size) {
+ struct request_queue *backingq;
+
+ 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);
+
+ /*
+ * We use punch hole to reclaim the free space used by the
+ * image a.k.a. discard. However we do not support discard if
+ * encryption is enabled, because it may give an attacker
+ * useful information.
+ */
+ } else if (!file->f_op->fallocate || xlo->xlo_encrypt_key_size) {
+ max_discard_sectors = 0;
+ granularity = 0;
+
+ } else {
+ max_discard_sectors = UINT_MAX >> 9;
+ granularity = inode->i_sb->s_blocksize;
+ }
+
+ if (max_discard_sectors) {
+ q->limits.discard_granularity = granularity;
+ blk_queue_max_discard_sectors(q, max_discard_sectors);
+ blk_queue_max_write_zeroes_sectors(q, max_discard_sectors);
+ blk_queue_flag_set(QUEUE_FLAG_DISCARD, q);
+ } else {
+ q->limits.discard_granularity = 0;
+ blk_queue_max_discard_sectors(q, 0);
+ blk_queue_max_write_zeroes_sectors(q, 0);
+ blk_queue_flag_clear(QUEUE_FLAG_DISCARD, q);
+ }
+ q->limits.discard_alignment = 0;
+}
+
+static void xloop_unprepare_queue(struct xloop_device *xlo)
+{
+ kthread_flush_worker(&xlo->worker);
+ kthread_stop(xlo->worker_task);
+}
+
+static int xloop_kthread_worker_fn(void *worker_ptr)
+{
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 8, 0)
+ current->flags |= PF_LOCAL_THROTTLE | PF_MEMALLOC_NOIO;
+#else
+ current->flags |= PF_LESS_THROTTLE | PF_MEMALLOC_NOIO;
+#endif
+ return kthread_worker_fn(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);
+ if (IS_ERR(xlo->worker_task))
+ return -ENOMEM;
+ set_user_nice(xlo->worker_task, MIN_NICE);
+ return 0;
+}
+
+static void xloop_update_rotational(struct xloop_device *xlo)
+{
+ struct file *file = xlo->xlo_backing_file;
+ struct inode *file_inode = file->f_mapping->host;
+ struct block_device *file_bdev = file_inode->i_sb->s_bdev;
+ struct request_queue *q = xlo->xlo_queue;
+ bool nonrot = true;
+
+ /* not all filesystems (e.g. tmpfs) have a sb->s_bdev */
+ if (file_bdev)
+ nonrot = blk_queue_nonrot(bdev_get_queue(file_bdev));
+
+ if (nonrot)
+ blk_queue_flag_set(QUEUE_FLAG_NONROT, q);
+ else
+ blk_queue_flag_clear(QUEUE_FLAG_NONROT, q);
+}
+
+static int
+xloop_release_xfer(struct xloop_device *xlo)
+{
+ int err = 0;
+ struct xloop_func_table *xfer = xlo->xlo_encryption;
+
+ if (xfer) {
+ if (xfer->release)
+ err = xfer->release(xlo);
+ xlo->transfer = NULL;
+ xlo->xlo_encryption = NULL;
+ module_put(xfer->owner);
+ }
+ return err;
+}
+
+static int
+xloop_init_xfer(struct xloop_device *xlo, struct xloop_func_table *xfer,
+ const struct xloop_info64 *i)
+{
+ int err = 0;
+
+ if (xfer) {
+ struct module *owner = xfer->owner;
+
+ if (!try_module_get(owner))
+ return -EINVAL;
+ if (xfer->init)
+ err = xfer->init(xlo, i);
+ if (err)
+ module_put(owner);
+ else
+ xlo->xlo_encryption = xfer;
+ }
+ return err;
+}
+
+/**
+ * xloop_set_status_from_info - configure device from xloop_info
+ * @xlo: struct xloop_device to configure
+ * @info: struct xloop_info64 to configure the device with
+ *
+ * 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)
+{
+ int err;
+ struct xloop_func_table *xfer;
+ kuid_t uid = current_uid();
+
+ if ((unsigned int) info->xlo_encrypt_key_size > XLO_KEY_SIZE)
+ return -EINVAL;
+
+ err = xloop_release_xfer(xlo);
+ if (err)
+ return err;
+
+ if (info->xlo_encrypt_type) {
+ unsigned int type = info->xlo_encrypt_type;
+
+ if (type >= MAX_XLO_CRYPT)
+ return -EINVAL;
+ xfer = xfer_funcs[type];
+ if (xfer == NULL)
+ return -EINVAL;
+ } else
+ xfer = NULL;
+
+ err = xloop_init_xfer(xlo, xfer, info);
+ if (err)
+ return err;
+
+ xlo->xlo_offset = info->xlo_offset;
+ 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;
+
+ if (!xfer)
+ xfer = &none_funcs;
+ xlo->transfer = xfer->transfer;
+ xlo->ioctl = xfer->ioctl;
+
+ xlo->xlo_flags = info->xlo_flags;
+
+ xlo->xlo_encrypt_key_size = info->xlo_encrypt_key_size;
+ 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);
+ 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)
+{
+ struct file *file;
+ struct inode *inode;
+ struct address_space *mapping;
+ struct block_device *claimed_bdev = NULL;
+ int error;
+ loff_t size;
+ bool partscan;
+ unsigned short bsize;
+
+ /* This is safe, since we have a reference from open(). */
+ __module_get(THIS_MODULE);
+
+ error = -EBADF;
+ file = fget(config->fd);
+ if (!file)
+ goto out;
+
+ /*
+ * If we don't hold exclusive handle for the device, upgrade to it
+ * here to avoid changing device under exclusive owner.
+ */
+ if (!(mode & FMODE_EXCL)) {
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 9, 0)
+ claimed_bdev = bdev->bd_contains;
+ error = bd_prepare_to_claim(bdev, claimed_bdev, xloop_configure);
+ if (error)
+ goto out_putf;
+#else
+ claimed_bdev = bd_start_claiming(bdev, xloop_configure);
+ if (IS_ERR(claimed_bdev)) {
+ error = PTR_ERR(claimed_bdev);
+ goto out_putf;
+ }
+#endif
+ }
+
+ error = mutex_lock_killable(&xloop_ctl_mutex);
+ if (error)
+ goto out_bdev;
+
+ error = -EBUSY;
+ if (xlo->xlo_state != Xlo_unbound)
+ goto out_unlock;
+
+ error = xloop_validate_file(file, bdev);
+ if (error)
+ goto out_unlock;
+
+ mapping = file->f_mapping;
+ inode = mapping->host;
+
+ if ((config->info.xlo_flags & ~XLOOP_CONFIGURE_SETTABLE_FLAGS) != 0) {
+ error = -EINVAL;
+ goto out_unlock;
+ }
+
+ if (config->block_size) {
+ error = xloop_validate_block_size(config->block_size);
+ if (error)
+ goto out_unlock;
+ }
+
+ error = xloop_set_status_from_info(xlo, &config->info);
+ if (error)
+ goto out_unlock;
+
+ 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);
+ if (error)
+ goto out_unlock;
+
+ error = xloop_file_fmt_init(xlo->xlo_fmt,
+ config->info.xlo_file_fmt_type);
+ if (error)
+ goto out_unlock;
+
+ set_device_ro(bdev, (xlo->xlo_flags & XLO_FLAGS_READ_ONLY) != 0);
+
+ xlo->use_dio = xlo->xlo_flags & XLO_FLAGS_DIRECT_IO;
+ 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));
+
+ if (!(xlo->xlo_flags & XLO_FLAGS_READ_ONLY) && file->f_op->fsync)
+ blk_queue_write_cache(xlo->xlo_queue, true, false);
+
+ if (config->block_size)
+ bsize = config->block_size;
+ else if ((xlo->xlo_backing_file->f_flags & O_DIRECT) && inode->i_sb->s_bdev)
+ /* In case of direct I/O, match underlying block size */
+ bsize = bdev_logical_block_size(inode->i_sb->s_bdev);
+ else
+ bsize = 512;
+
+ blk_queue_logical_block_size(xlo->xlo_queue, bsize);
+ blk_queue_physical_block_size(xlo->xlo_queue, bsize);
+ blk_queue_io_min(xlo->xlo_queue, bsize);
+
+ xloop_update_rotational(xlo);
+ xloop_update_dio(xlo);
+ xloop_sysfs_init(xlo);
+
+ 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);
+
+ xlo->xlo_state = Xlo_bound;
+ if (part_shift)
+ xlo->xlo_flags |= XLO_FLAGS_PARTSCAN;
+ partscan = xlo->xlo_flags & XLO_FLAGS_PARTSCAN;
+ if (partscan)
+ xlo->xlo_disk->flags &= ~GENHD_FL_NO_PART_SCAN;
+
+ /* Grab the block_device to prevent its destruction after we
+ * put /dev/xloopXX inode. Later in __xloop_clr_fd() we bdput(bdev).
+ */
+ bdgrab(bdev);
+ mutex_unlock(&xloop_ctl_mutex);
+ if (partscan)
+ xloop_reread_partitions(xlo, bdev);
+ if (claimed_bdev)
+ bd_abort_claiming(bdev, claimed_bdev, xloop_configure);
+ return 0;
+
+out_unlock:
+ mutex_unlock(&xloop_ctl_mutex);
+out_bdev:
+ if (claimed_bdev)
+ bd_abort_claiming(bdev, claimed_bdev, xloop_configure);
+out_putf:
+ fput(file);
+out:
+ /* This is safe: open() is still holding a reference. */
+ module_put(THIS_MODULE);
+ return error;
+}
+
+static int __xloop_clr_fd(struct xloop_device *xlo, bool release)
+{
+ struct file *filp = NULL;
+ gfp_t gfp = xlo->old_gfp_mask;
+ struct block_device *bdev = xlo->xlo_device;
+ int err = 0;
+ bool partscan = false;
+ int xlo_number;
+
+ mutex_lock(&xloop_ctl_mutex);
+ if (WARN_ON_ONCE(xlo->xlo_state != Xlo_rundown)) {
+ err = -ENXIO;
+ goto out_unlock;
+ }
+
+ filp = xlo->xlo_backing_file;
+ if (filp == NULL) {
+ err = -EINVAL;
+ goto out_unlock;
+ }
+
+ /* freeze request queue during the transition */
+ blk_mq_freeze_queue(xlo->xlo_queue);
+
+ xloop_file_fmt_exit(xlo->xlo_fmt);
+
+ spin_lock_irq(&xlo->xlo_lock);
+ xlo->xlo_backing_file = NULL;
+ spin_unlock_irq(&xlo->xlo_lock);
+
+ xloop_release_xfer(xlo);
+ xlo->transfer = NULL;
+ xlo->ioctl = NULL;
+ xlo->xlo_device = NULL;
+ xlo->xlo_encryption = NULL;
+ xlo->xlo_offset = 0;
+ xlo->xlo_sizelimit = 0;
+ xlo->xlo_encrypt_key_size = 0;
+ memset(xlo->xlo_encrypt_key, 0, XLO_KEY_SIZE);
+ memset(xlo->xlo_crypt_name, 0, XLO_NAME_SIZE);
+ memset(xlo->xlo_file_name, 0, XLO_NAME_SIZE);
+ blk_queue_logical_block_size(xlo->xlo_queue, 512);
+ blk_queue_physical_block_size(xlo->xlo_queue, 512);
+ blk_queue_io_min(xlo->xlo_queue, 512);
+ if (bdev) {
+ bdput(bdev);
+ invalidate_bdev(bdev);
+ bdev->bd_inode->i_mapping->wb_err = 0;
+ }
+ set_capacity(xlo->xlo_disk, 0);
+ xloop_sysfs_exit(xlo);
+ if (bdev) {
+ bd_set_size(bdev, 0);
+ /* let user-space know about this change */
+ kobject_uevent(&disk_to_dev(bdev->bd_disk)->kobj, KOBJ_CHANGE);
+ }
+ mapping_set_gfp_mask(filp->f_mapping, gfp);
+ /* This is safe: open() is still holding a reference. */
+ module_put(THIS_MODULE);
+ blk_mq_unfreeze_queue(xlo->xlo_queue);
+
+ partscan = xlo->xlo_flags & XLO_FLAGS_PARTSCAN && bdev;
+ xlo_number = xlo->xlo_number;
+ xloop_unprepare_queue(xlo);
+out_unlock:
+ mutex_unlock(&xloop_ctl_mutex);
+ if (partscan) {
+ /*
+ * bd_mutex has been held already in release path, so don't
+ * acquire it if this function is called in such case.
+ *
+ * If the reread partition isn't from release path, xlo_refcnt
+ * must be at least one and it can only become zero when the
+ * current holder is released.
+ */
+ if (!release)
+ mutex_lock(&bdev->bd_mutex);
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 5, 0)
+ err = bdev_disk_changed(bdev, false);
+#else
+ err = blkdev_reread_part(bdev);
+#endif
+ if (!release)
+ mutex_unlock(&bdev->bd_mutex);
+ if (err)
+ pr_warn("%s: partition scan of xloop%d failed (rc=%d)\n",
+ __func__, xlo_number, err);
+ /* Device is gone, no point in returning error */
+ err = 0;
+ }
+
+ /*
+ * xlo->xlo_state is set to Xlo_unbound here after above partscan has
+ * finished.
+ *
+ * There cannot be anybody else entering __xloop_clr_fd() as
+ * xlo->xlo_backing_file is already cleared and Xlo_rundown state
+ * protects us from all the other places trying to change the 'xlo'
+ * device.
+ */
+ mutex_lock(&xloop_ctl_mutex);
+ xlo->xlo_flags = 0;
+ if (!part_shift)
+ xlo->xlo_disk->flags |= GENHD_FL_NO_PART_SCAN;
+ xlo->xlo_state = Xlo_unbound;
+ mutex_unlock(&xloop_ctl_mutex);
+
+ /*
+ * Need not hold xloop_ctl_mutex to fput backing file.
+ * Calling fput holding xloop_ctl_mutex triggers a circular
+ * lock dependency possibility warning as fput can take
+ * bd_mutex which is usually taken before xloop_ctl_mutex.
+ */
+ if (filp)
+ fput(filp);
+ return err;
+}
+
+static int xloop_clr_fd(struct xloop_device *xlo)
+{
+ int err;
+
+ err = mutex_lock_killable(&xloop_ctl_mutex);
+ if (err)
+ return err;
+ if (xlo->xlo_state != Xlo_bound) {
+ mutex_unlock(&xloop_ctl_mutex);
+ return -ENXIO;
+ }
+ /*
+ * If we've explicitly asked to tear down the xloop device,
+ * and it has an elevated reference count, set it for auto-teardown when
+ * the last reference goes away. This stops $!~#$@ udev from
+ * preventing teardown because it decided that it needs to run blkid on
+ * the xloopback device whenever they appear. xfstests is notorious for
+ * failing tests because blkid via udev races with a losetup
+ * /do something like mkfs/losetup -d causing the losetup -d
+ * command to fail with EBUSY.
+ */
+ if (atomic_read(&xlo->xlo_refcnt) > 1) {
+ xlo->xlo_flags |= XLO_FLAGS_AUTOCLEAR;
+ mutex_unlock(&xloop_ctl_mutex);
+ return 0;
+ }
+ xlo->xlo_state = Xlo_rundown;
+ mutex_unlock(&xloop_ctl_mutex);
+
+ return __xloop_clr_fd(xlo, false);
+}
+
+static int
+xloop_set_status(struct xloop_device *xlo, const struct xloop_info64 *info)
+{
+ int err;
+ struct block_device *bdev;
+ kuid_t uid = current_uid();
+ int prev_xlo_flags;
+ bool partscan = false;
+ bool size_changed = false;
+
+ 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)) {
+ err = -EPERM;
+ goto out_unlock;
+ }
+ if (xlo->xlo_state != Xlo_bound) {
+ err = -ENXIO;
+ goto out_unlock;
+ }
+
+ 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);
+ }
+
+ /* I/O need to be drained during transfer transition */
+ blk_mq_freeze_queue(xlo->xlo_queue);
+
+ if (size_changed && xlo->xlo_device->bd_inode->i_mapping->nrpages) {
+ /* If any pages were dirtied after invalidate_bdev(), try again */
+ err = -EAGAIN;
+ pr_warn("%s: xloop%d (%s) has still dirty pages (nrpages=%lu)\n",
+ __func__, xlo->xlo_number, xlo->xlo_file_name,
+ xlo->xlo_device->bd_inode->i_mapping->nrpages);
+ goto out_unfreeze;
+ }
+
+ prev_xlo_flags = xlo->xlo_flags;
+
+ err = xloop_set_status_from_info(xlo, info);
+ if (err)
+ goto out_unfreeze;
+
+ /* Mask out flags that can't be set using XLOOP_SET_STATUS. */
+ xlo->xlo_flags &= XLOOP_SET_STATUS_SETTABLE_FLAGS;
+ /* For those flags, use the previous values instead */
+ xlo->xlo_flags |= prev_xlo_flags & ~XLOOP_SET_STATUS_SETTABLE_FLAGS;
+ /* For flags that can't be cleared, use previous values too */
+ xlo->xlo_flags |= prev_xlo_flags & ~XLOOP_SET_STATUS_CLEARABLE_FLAGS;
+
+ if (xlo->xlo_fmt->file_fmt_type != info->xlo_file_fmt_type) {
+ /* xloop file format has changed, so change file format driver */
+ err = xloop_file_fmt_change(xlo->xlo_fmt, info->xlo_file_fmt_type);
+ if (err)
+ goto out_unfreeze;
+
+ /* After change of the file format, recalculate the capacity of
+ * the loop 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);
+ }
+
+ xloop_config_discard(xlo);
+
+ /* update dio if xlo_offset or transfer is changed */
+ __xloop_update_dio(xlo, xlo->use_dio);
+
+out_unfreeze:
+ blk_mq_unfreeze_queue(xlo->xlo_queue);
+
+ 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;
+ }
+out_unlock:
+ mutex_unlock(&xloop_ctl_mutex);
+ if (partscan)
+ xloop_reread_partitions(xlo, bdev);
+
+ return err;
+}
+
+static int
+xloop_get_status(struct xloop_device *xlo, struct xloop_info64 *info)
+{
+ struct path path;
+ struct kstat stat;
+ int ret;
+
+ ret = mutex_lock_killable(&xloop_ctl_mutex);
+ if (ret)
+ return ret;
+ if (xlo->xlo_state != Xlo_bound) {
+ mutex_unlock(&xloop_ctl_mutex);
+ return -ENXIO;
+ }
+
+ memset(info, 0, sizeof(*info));
+ info->xlo_number = xlo->xlo_number;
+ info->xlo_offset = xlo->xlo_offset;
+ info->xlo_sizelimit = xlo->xlo_sizelimit;
+ 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;
+ 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);
+ }
+
+ /* Drop xloop_ctl_mutex while we call into the filesystem. */
+ path = xlo->xlo_backing_file->f_path;
+ path_get(&path);
+ mutex_unlock(&xloop_ctl_mutex);
+ ret = vfs_getattr(&path, &stat, STATX_INO, AT_STATX_SYNC_AS_STAT);
+ if (!ret) {
+ info->xlo_device = huge_encode_dev(stat.dev);
+ info->xlo_inode = stat.ino;
+ info->xlo_rdevice = huge_encode_dev(stat.rdev);
+ }
+ path_put(&path);
+ return ret;
+}
+
+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;
+ info64->xlo_device = info->xlo_device;
+ info64->xlo_inode = info->xlo_inode;
+ info64->xlo_rdevice = info->xlo_rdevice;
+ info64->xlo_offset = info->xlo_offset;
+ info64->xlo_sizelimit = 0;
+ info64->xlo_encrypt_type = info->xlo_encrypt_type;
+ info64->xlo_encrypt_key_size = info->xlo_encrypt_key_size;
+ info64->xlo_flags = info->xlo_flags;
+ info64->xlo_init[0] = info->xlo_init[0];
+ info64->xlo_init[1] = info->xlo_init[1];
+ info64->xlo_file_fmt_type = info->xlo_file_fmt_type;
+ if (info->xlo_encrypt_type == XLO_CRYPT_CRYPTOAPI)
+ memcpy(info64->xlo_crypt_name, info->xlo_name, XLO_NAME_SIZE);
+ else
+ memcpy(info64->xlo_file_name, info->xlo_name, XLO_NAME_SIZE);
+ 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)
+{
+ memset(info, 0, sizeof(*info));
+ info->xlo_number = info64->xlo_number;
+ info->xlo_device = info64->xlo_device;
+ info->xlo_inode = info64->xlo_inode;
+ info->xlo_rdevice = info64->xlo_rdevice;
+ info->xlo_offset = info64->xlo_offset;
+ info->xlo_encrypt_type = info64->xlo_encrypt_type;
+ info->xlo_encrypt_key_size = info64->xlo_encrypt_key_size;
+ info->xlo_flags = info64->xlo_flags;
+ 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_encrypt_type == XLO_CRYPT_CRYPTOAPI)
+ memcpy(info->xlo_name, info64->xlo_crypt_name, XLO_NAME_SIZE);
+ else
+ memcpy(info->xlo_name, info64->xlo_file_name, XLO_NAME_SIZE);
+ 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)
+ return -EOVERFLOW;
+
+ return 0;
+}
+
+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)))
+ 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)
+{
+ struct xloop_info64 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) {
+ struct xloop_info info;
+ struct xloop_info64 info64;
+ int err;
+
+ if (!arg)
+ return -EINVAL;
+ err = xloop_get_status(xlo, &info64);
+ if (!err)
+ err = xloop_info64_to_old(&info64, &info);
+ if (!err && copy_to_user(arg, &info, sizeof(info)))
+ err = -EFAULT;
+
+ return err;
+}
+
+static int
+xloop_get_status64(struct xloop_device *xlo, struct xloop_info64 __user *arg) {
+ struct xloop_info64 info64;
+ int err;
+
+ if (!arg)
+ return -EINVAL;
+ err = xloop_get_status(xlo, &info64);
+ if (!err && copy_to_user(arg, &info64, sizeof(info64)))
+ err = -EFAULT;
+
+ return err;
+}
+
+static int xloop_set_capacity(struct xloop_device *xlo)
+{
+ loff_t size;
+
+ if (unlikely(xlo->xlo_state != Xlo_bound))
+ return -ENXIO;
+
+ size = get_xloop_size(xlo, xlo->xlo_backing_file);
+ xloop_set_size(xlo, size);
+
+ return 0;
+}
+
+static int xloop_set_dio(struct xloop_device *xlo, unsigned long arg)
+{
+ int error = -ENXIO;
+ if (xlo->xlo_state != Xlo_bound)
+ goto out;
+
+ __xloop_update_dio(xlo, !!arg);
+ if (xlo->use_dio == !!arg)
+ return 0;
+ error = -EINVAL;
+ out:
+ return error;
+}
+
+static int xloop_set_block_size(struct xloop_device *xlo, unsigned long arg)
+{
+ int err = 0;
+
+ if (xlo->xlo_state != Xlo_bound)
+ return -ENXIO;
+
+ err = xloop_validate_block_size(arg);
+ if (err)
+ return err;
+
+ if (xlo->xlo_queue->limits.logical_block_size == arg)
+ return 0;
+
+ sync_blockdev(xlo->xlo_device);
+ invalidate_bdev(xlo->xlo_device);
+
+ blk_mq_freeze_queue(xlo->xlo_queue);
+
+ /* invalidate_bdev should have truncated all the pages */
+ if (xlo->xlo_device->bd_inode->i_mapping->nrpages) {
+ err = -EAGAIN;
+ pr_warn("%s: xloop%d (%s) has still dirty pages (nrpages=%lu)\n",
+ __func__, xlo->xlo_number, xlo->xlo_file_name,
+ xlo->xlo_device->bd_inode->i_mapping->nrpages);
+ goto out_unfreeze;
+ }
+
+ blk_queue_logical_block_size(xlo->xlo_queue, arg);
+ blk_queue_physical_block_size(xlo->xlo_queue, arg);
+ blk_queue_io_min(xlo->xlo_queue, arg);
+ xloop_update_dio(xlo);
+out_unfreeze:
+ blk_mq_unfreeze_queue(xlo->xlo_queue);
+
+ return err;
+}
+
+static int xlo_simple_ioctl(struct xloop_device *xlo, unsigned int cmd,
+ unsigned long arg)
+{
+ int err;
+
+ err = mutex_lock_killable(&xloop_ctl_mutex);
+ if (err)
+ return err;
+ switch (cmd) {
+ case XLOOP_SET_CAPACITY:
+ err = xloop_set_capacity(xlo);
+ break;
+ case XLOOP_SET_DIRECT_IO:
+ err = xloop_set_dio(xlo, arg);
+ break;
+ case XLOOP_SET_BLOCK_SIZE:
+ err = xloop_set_block_size(xlo, arg);
+ break;
+ default:
+ err = xlo->ioctl ? xlo->ioctl(xlo, cmd, arg) : -EINVAL;
+ }
+ mutex_unlock(&xloop_ctl_mutex);
+ return err;
+}
+
+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;
+ int err;
+
+ switch (cmd) {
+ case XLOOP_SET_FD: {
+ /*
+ * Legacy case - pass in a zeroed out struct xloop_config with
+ * only the file descriptor set , which corresponds with the
+ * default parameters we'd have used otherwise.
+ */
+ struct xloop_config config;
+
+ memset(&config, 0, sizeof(config));
+ config.fd = arg;
+
+ return xloop_configure(xlo, mode, bdev, &config);
+ }
+ case XLOOP_CONFIGURE: {
+ struct xloop_config config;
+
+ if (copy_from_user(&config, argp, sizeof(config)))
+ return -EFAULT;
+
+ return xloop_configure(xlo, mode, bdev, &config);
+ }
+ case XLOOP_CHANGE_FD:
+ return xloop_change_fd(xlo, bdev, arg);
+ case XLOOP_CLR_FD:
+ return xloop_clr_fd(xlo);
+ case XLOOP_SET_STATUS:
+ err = -EPERM;
+ 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)) {
+ err = xloop_set_status64(xlo, argp);
+ }
+ break;
+ case XLOOP_GET_STATUS64:
+ return xloop_get_status64(xlo, argp);
+ case XLOOP_SET_CAPACITY:
+ case XLOOP_SET_DIRECT_IO:
+ case XLOOP_SET_BLOCK_SIZE:
+ if (!(mode & FMODE_WRITE) && !capable(CAP_SYS_ADMIN))
+ return -EPERM;
+ fallthrough;
+ default:
+ err = xlo_simple_ioctl(xlo, cmd, arg);
+ break;
+ }
+
+ return err;
+}
+
+#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;
+};
+
+/*
+ * 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)
+{
+ struct compat_xloop_info info;
+
+ if (copy_from_user(&info, arg, sizeof(info)))
+ return -EFAULT;
+
+ memset(info64, 0, sizeof(*info64));
+ info64->xlo_number = info.xlo_number;
+ info64->xlo_device = info.xlo_device;
+ info64->xlo_inode = info.xlo_inode;
+ info64->xlo_rdevice = info.xlo_rdevice;
+ info64->xlo_offset = info.xlo_offset;
+ info64->xlo_sizelimit = 0;
+ info64->xlo_encrypt_type = info.xlo_encrypt_type;
+ info64->xlo_encrypt_key_size = info.xlo_encrypt_key_size;
+ info64->xlo_flags = info.xlo_flags;
+ info64->xlo_init[0] = info.xlo_init[0];
+ info64->xlo_init[1] = info.xlo_init[1];
+ info64->xlo_file_fmt_type = info.xlo_file_fmt_type;
+ if (info.xlo_encrypt_type == XLO_CRYPT_CRYPTOAPI)
+ memcpy(info64->xlo_crypt_name, info.xlo_name, XLO_NAME_SIZE);
+ else
+ memcpy(info64->xlo_file_name, info.xlo_name, XLO_NAME_SIZE);
+ memcpy(info64->xlo_encrypt_key, info.xlo_encrypt_key, XLO_KEY_SIZE);
+ return 0;
+}
+
+/*
+ * 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)
+{
+ struct compat_xloop_info info;
+
+ memset(&info, 0, sizeof(info));
+ info.xlo_number = info64->xlo_number;
+ info.xlo_device = info64->xlo_device;
+ info.xlo_inode = info64->xlo_inode;
+ info.xlo_rdevice = info64->xlo_rdevice;
+ info.xlo_offset = info64->xlo_offset;
+ info.xlo_encrypt_type = info64->xlo_encrypt_type;
+ info.xlo_encrypt_key_size = info64->xlo_encrypt_key_size;
+ info.xlo_flags = info64->xlo_flags;
+ info.xlo_init[0] = info64->xlo_init[0];
+ info.xlo_init[1] = info64->xlo_init[1];
+ if (info.xlo_encrypt_type == XLO_CRYPT_CRYPTOAPI)
+ memcpy(info.xlo_name, info64->xlo_crypt_name, XLO_NAME_SIZE);
+ else
+ memcpy(info.xlo_name, info64->xlo_file_name, XLO_NAME_SIZE);
+ 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])
+ return -EOVERFLOW;
+
+ if (copy_to_user(arg, &info, sizeof(info)))
+ return -EFAULT;
+ return 0;
+}
+
+static int
+xloop_set_status_compat(struct xloop_device *xlo,
+ const struct compat_xloop_info __user *arg)
+{
+ struct xloop_info64 info64;
+ int ret;
+
+ ret = xloop_info64_from_compat(arg, &info64);
+ if (ret < 0)
+ return ret;
+ return xloop_set_status(xlo, &info64);
+}
+
+static int
+xloop_get_status_compat(struct xloop_device *xlo,
+ struct compat_xloop_info __user *arg)
+{
+ struct xloop_info64 info64;
+ int err;
+
+ if (!arg)
+ return -EINVAL;
+ err = xloop_get_status(xlo, &info64);
+ if (!err)
+ err = xloop_info64_to_compat(&info64, arg);
+ return err;
+}
+
+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) {
+ case XLOOP_SET_STATUS:
+ 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);
+ 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);
+ fallthrough;
+ case XLOOP_SET_FD:
+ case XLOOP_CHANGE_FD:
+ case XLOOP_SET_BLOCK_SIZE:
+ case XLOOP_SET_DIRECT_IO:
+ err = xlo_ioctl(bdev, mode, cmd, arg);
+ break;
+ default:
+ err = -ENOIOCTLCMD;
+ break;
+ }
+ return err;
+}
+#endif
+
+static int xlo_open(struct block_device *bdev, fmode_t mode)
+{
+ struct xloop_device *xlo;
+ int err;
+
+ err = mutex_lock_killable(&xloop_ctl_mutex);
+ if (err)
+ return err;
+ xlo = bdev->bd_disk->private_data;
+ if (!xlo) {
+ err = -ENXIO;
+ goto out;
+ }
+
+ atomic_inc(&xlo->xlo_refcnt);
+out:
+ mutex_unlock(&xloop_ctl_mutex);
+ return err;
+}
+
+static void xlo_release(struct gendisk *disk, fmode_t mode)
+{
+ struct xloop_device *xlo;
+
+ mutex_lock(&xloop_ctl_mutex);
+ xlo = disk->private_data;
+ if (atomic_dec_return(&xlo->xlo_refcnt))
+ goto out_unlock;
+
+ if (xlo->xlo_flags & XLO_FLAGS_AUTOCLEAR) {
+ if (xlo->xlo_state != Xlo_bound)
+ goto out_unlock;
+ xlo->xlo_state = Xlo_rundown;
+ mutex_unlock(&xloop_ctl_mutex);
+ /*
+ * In autoclear mode, stop the xloop thread
+ * and remove configuration after last close.
+ */
+ __xloop_clr_fd(xlo, true);
+ return;
+ } else if (xlo->xlo_state == Xlo_bound) {
+ /*
+ * Otherwise keep thread (if running) and config,
+ * but flush possible ongoing bios in thread.
+ */
+ blk_mq_freeze_queue(xlo->xlo_queue);
+ blk_mq_unfreeze_queue(xlo->xlo_queue);
+ }
+
+out_unlock:
+ mutex_unlock(&xloop_ctl_mutex);
+}
+
+static const struct block_device_operations xlo_fops = {
+ .owner = THIS_MODULE,
+ .open = xlo_open,
+ .release = xlo_release,
+ .ioctl = xlo_ioctl,
+#ifdef CONFIG_COMPAT
+ .compat_ioctl = xlo_compat_ioctl,
+#endif
+};
+
+/*
+ * And now the modules code and kernel interface.
+ */
+static int max_xloop;
+module_param(max_xloop, int, 0444);
+MODULE_PARM_DESC(max_xloop, "Maximum number of xloop devices");
+module_param(max_part, int, 0444);
+MODULE_PARM_DESC(max_part, "Maximum number of partitions per xloop device");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS_BLOCKDEV_MAJOR(LOOP_MAJOR);
+
+int xloop_register_transfer(struct xloop_func_table *funcs)
+{
+ unsigned int n = funcs->number;
+
+ if (n >= MAX_XLO_CRYPT || xfer_funcs[n])
+ return -EINVAL;
+ xfer_funcs[n] = funcs;
+ return 0;
+}
+
+static int unregister_transfer_cb(int id, void *ptr, void *data)
+{
+ struct xloop_device *xlo = ptr;
+ struct xloop_func_table *xfer = data;
+
+ mutex_lock(&xloop_ctl_mutex);
+ if (xlo->xlo_encryption == xfer)
+ xloop_release_xfer(xlo);
+ mutex_unlock(&xloop_ctl_mutex);
+ return 0;
+}
+
+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)
+ 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)
+{
+ struct request *rq = bd->rq;
+ struct xloop_cmd *cmd = blk_mq_rq_to_pdu(rq);
+ struct xloop_device *xlo = rq->q->queuedata;
+
+ blk_mq_start_request(rq);
+
+ if (xlo->xlo_state != Xlo_bound)
+ return BLK_STS_IOERR;
+
+ switch (req_op(rq)) {
+ case REQ_OP_FLUSH:
+ case REQ_OP_DISCARD:
+ case REQ_OP_WRITE_ZEROES:
+ cmd->use_aio = false;
+ break;
+ default:
+ cmd->use_aio = xlo->use_dio;
+ break;
+ }
+
+ /* always use the first bio's css */
+#ifdef CONFIG_BLK_CGROUP
+ if (cmd->use_aio && rq->bio && rq->bio->bi_blkg) {
+ cmd->css = &bio_blkcg(rq->bio)->css;
+ css_get(cmd->css);
+ } else
+#endif
+ cmd->css = NULL;
+ kthread_queue_work(&xlo->worker, &cmd->work);
+
+ return BLK_STS_OK;
+}
+
+static void xloop_handle_cmd(struct xloop_cmd *cmd)
+{
+ struct request *rq = blk_mq_rq_from_pdu(cmd);
+ const bool write = op_is_write(req_op(rq));
+ struct xloop_device *xlo = rq->q->queuedata;
+ int ret = 0;
+
+ if (write && (xlo->xlo_flags & XLO_FLAGS_READ_ONLY)) {
+ ret = -EIO;
+ goto failed;
+ }
+
+ ret = do_req_filebacked(xlo, rq);
+ failed:
+ /* complete non-aio request */
+ if (!cmd->use_aio || ret) {
+ if (ret == -EOPNOTSUPP)
+ cmd->ret = ret;
+ else
+ cmd->ret = ret ? -EIO : 0;
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 9, 0)
+ if (likely(!blk_should_fake_timeout(rq->q)))
+ blk_mq_complete_request(rq);
+#else
+ blk_mq_complete_request(rq);
+#endif
+ }
+}
+
+static void xloop_queue_work(struct kthread_work *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)
+{
+ struct xloop_cmd *cmd = blk_mq_rq_to_pdu(rq);
+
+ kthread_init_work(&cmd->work, xloop_queue_work);
+ return 0;
+}
+
+static const struct blk_mq_ops xloop_mq_ops = {
+ .queue_rq = xloop_queue_rq,
+ .init_request = xloop_init_request,
+ .complete = xlo_complete_rq,
+};
+
+static struct dentry *xloop_dbgfs_dir;
+
+static int xloop_add(struct xloop_device **l, int i)
+{
+ struct xloop_device *xlo;
+ struct gendisk *disk;
+ int err;
+
+ err = -ENOMEM;
+ xlo = kzalloc(sizeof(*xlo), GFP_KERNEL);
+ if (!xlo)
+ goto out;
+
+ xlo->xlo_state = Xlo_unbound;
+
+ /* allocate id, if @id >= 0, we're requesting that specific id */
+ if (i >= 0) {
+ err = idr_alloc(&xloop_index_idr, xlo, i, i + 1, GFP_KERNEL);
+ if (err == -ENOSPC)
+ err = -EEXIST;
+ } else {
+ err = idr_alloc(&xloop_index_idr, xlo, 0, 0, GFP_KERNEL);
+ }
+ if (err < 0)
+ goto out_free_dev;
+ i = err;
+
+ err = -ENOMEM;
+ xlo->tag_set.ops = &xloop_mq_ops;
+ xlo->tag_set.nr_hw_queues = 1;
+ xlo->tag_set.queue_depth = 128;
+ xlo->tag_set.numa_node = NUMA_NO_NODE;
+ xlo->tag_set.cmd_size = sizeof(struct xloop_cmd);
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 8, 0)
+ xlo->tag_set.flags = BLK_MQ_F_SHOULD_MERGE | BLK_MQ_F_STACKING;
+#else
+ xlo->tag_set.flags = BLK_MQ_F_SHOULD_MERGE;
+#endif
+ xlo->tag_set.driver_data = xlo;
+
+ err = blk_mq_alloc_tag_set(&xlo->tag_set);
+ if (err)
+ goto out_free_idr;
+
+ xlo->xlo_queue = blk_mq_init_queue(&xlo->tag_set);
+ if (IS_ERR(xlo->xlo_queue)) {
+ err = PTR_ERR(xlo->xlo_queue);
+ goto out_cleanup_tags;
+ }
+ xlo->xlo_queue->queuedata = xlo;
+
+ blk_queue_max_hw_sectors(xlo->xlo_queue, BLK_DEF_MAX_SECTORS);
+
+ /*
+ * By default, we do buffer IO, so it doesn't make sense to enable
+ * merge because the I/O submitted to backing file is handled page by
+ * page. For directio mode, merge does help to dispatch bigger request
+ * to underlayer disk. We will enable merge once directio is enabled.
+ */
+ blk_queue_flag_set(QUEUE_FLAG_NOMERGES, xlo->xlo_queue);
+
+ err = -ENOMEM;
+ xlo->xlo_fmt = xloop_file_fmt_alloc();
+ if (!xlo->xlo_fmt)
+ goto out_free_queue;
+
+ xloop_file_fmt_set_xlo(xlo->xlo_fmt, xlo);
+
+ err = -ENOMEM;
+ disk = xlo->xlo_disk = alloc_disk(1 << part_shift);
+ if (!disk)
+ goto out_free_file_fmt;
+
+ /*
+ * Disable partition scanning by default. The in-kernel partition
+ * scanning can be requested individually per-device during its
+ * setup. Userspace can always add and remove partitions from all
+ * devices. The needed partition minors are allocated from the
+ * extended minor space, the main xloop device numbers will continue
+ * to match the xloop minors, regardless of the number of partitions
+ * used.
+ *
+ * If max_part is given, partition scanning is globally enabled for
+ * all xloop devices. The minors for the main xloop devices will be
+ * multiples of max_part.
+ *
+ * Note: Global-for-all-devices, set-only-at-init, read-only module
+ * parameteters like 'max_xloop' and 'max_part' make things needlessly
+ * complicated, are too static, inflexible and may surprise
+ * userspace tools. Parameters like this in general should be avoided.
+ */
+ if (!part_shift)
+ disk->flags |= GENHD_FL_NO_PART_SCAN;
+ disk->flags |= GENHD_FL_EXT_DEVT;
+ atomic_set(&xlo->xlo_refcnt, 0);
+ xlo->xlo_number = i;
+ spin_lock_init(&xlo->xlo_lock);
+ disk->major = LOOP_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
+ * the 'block' directory exists, otherwise create the loop directory in
+ * the root directory */
+#ifdef CONFIG_DEBUG_FS
+ xlo->xlo_dbgfs_dir = debugfs_create_dir(disk->disk_name, xloop_dbgfs_dir);
+
+ if (IS_ERR_OR_NULL(xlo->xlo_dbgfs_dir)) {
+ err = -ENODEV;
+ xlo->xlo_dbgfs_dir = NULL;
+ goto out_free_file_fmt;
+ }
+#endif
+
+ return xlo->xlo_number;
+
+out_free_file_fmt:
+ xloop_file_fmt_free(xlo->xlo_fmt);
+out_free_queue:
+ blk_cleanup_queue(xlo->xlo_queue);
+out_cleanup_tags:
+ blk_mq_free_tag_set(&xlo->tag_set);
+out_free_idr:
+ idr_remove(&xloop_index_idr, i);
+out_free_dev:
+ kfree(xlo);
+out:
+ return err;
+}
+
+static void xloop_remove(struct xloop_device *xlo)
+{
+ xloop_file_fmt_free(xlo->xlo_fmt);
+ debugfs_remove(xlo->xlo_dbgfs_dir);
+ del_gendisk(xlo->xlo_disk);
+ blk_cleanup_queue(xlo->xlo_queue);
+ blk_mq_free_tag_set(&xlo->tag_set);
+ put_disk(xlo->xlo_disk);
+ kfree(xlo);
+}
+
+static int find_free_cb(int id, void *ptr, void *data)
+{
+ struct xloop_device *xlo = ptr;
+ struct xloop_device **l = data;
+
+ if (xlo->xlo_state == Xlo_unbound) {
+ *l = xlo;
+ return 1;
+ }
+ return 0;
+}
+
+static int xloop_lookup(struct xloop_device **l, int i)
+{
+ struct xloop_device *xlo;
+ int ret = -ENODEV;
+
+ if (i < 0) {
+ int err;
+
+ err = idr_for_each(&xloop_index_idr, &find_free_cb, &xlo);
+ if (err == 1) {
+ *l = xlo;
+ ret = xlo->xlo_number;
+ }
+ goto out;
+ }
+
+ /* lookup and return a specific i */
+ xlo = idr_find(&xloop_index_idr, i);
+ if (xlo) {
+ *l = xlo;
+ ret = xlo->xlo_number;
+ }
+out:
+ return ret;
+}
+
+static struct kobject *xloop_probe(dev_t dev, int *part, void *data)
+{
+ struct xloop_device *xlo;
+ struct kobject *kobj;
+ int err;
+
+ mutex_lock(&xloop_ctl_mutex);
+ err = xloop_lookup(&xlo, MINOR(dev) >> part_shift);
+ if (err < 0)
+ err = xloop_add(&xlo, MINOR(dev) >> part_shift);
+ if (err < 0)
+ kobj = NULL;
+ else
+ kobj = get_disk_and_module(xlo->xlo_disk);
+ mutex_unlock(&xloop_ctl_mutex);
+
+ *part = 0;
+ return kobj;
+}
+
+static long xloop_control_ioctl(struct file *file, unsigned int cmd,
+ unsigned long parm)
+{
+ struct xloop_device *xlo;
+ int ret;
+
+ ret = mutex_lock_killable(&xloop_ctl_mutex);
+ if (ret)
+ return ret;
+
+ ret = -ENOSYS;
+ switch (cmd) {
+ case XLOOP_CTL_ADD:
+ ret = xloop_lookup(&xlo, parm);
+ if (ret >= 0) {
+ ret = -EEXIST;
+ break;
+ }
+ ret = xloop_add(&xlo, parm);
+ break;
+ case XLOOP_CTL_REMOVE:
+ ret = xloop_lookup(&xlo, parm);
+ if (ret < 0)
+ break;
+ if (xlo->xlo_state != Xlo_unbound) {
+ ret = -EBUSY;
+ break;
+ }
+ if (atomic_read(&xlo->xlo_refcnt) > 0) {
+ ret = -EBUSY;
+ break;
+ }
+ xlo->xlo_disk->private_data = NULL;
+ idr_remove(&xloop_index_idr, xlo->xlo_number);
+ xloop_remove(xlo);
+ break;
+ case XLOOP_CTL_GET_FREE:
+ ret = xloop_lookup(&xlo, -1);
+ if (ret >= 0)
+ break;
+ ret = xloop_add(&xlo, -1);
+ }
+ mutex_unlock(&xloop_ctl_mutex);
+
+ return ret;
+}
+
+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,
+};
+
+static struct miscdevice xloop_misc = {
+ .minor = LOOP_CTRL_MINOR,
+ .name = "xloop-control",
+ .fops = &xloop_ctl_fops,
+};
+
+MODULE_ALIAS_MISCDEV(LOOP_CTRL_MINOR);
+MODULE_ALIAS("devname:xloop-control");
+
+static int __init xloop_init(void)
+{
+ int i, nr;
+ unsigned long range;
+ struct xloop_device *xlo;
+ int err;
+
+ part_shift = 0;
+ if (max_part > 0) {
+ part_shift = fls(max_part);
+
+ /*
+ * Adjust max_part according to part_shift as it is exported
+ * to user space so that user can decide correct minor number
+ * if [s]he want to create more devices.
+ *
+ * Note that -1 is required because partition 0 is reserved
+ * for the whole disk.
+ */
+ max_part = (1UL << part_shift) - 1;
+ }
+
+ if ((1UL << part_shift) > DISK_MAX_PARTS) {
+ err = -EINVAL;
+ goto err_out;
+ }
+
+ if (max_xloop > 1UL << (MINORBITS - part_shift)) {
+ err = -EINVAL;
+ goto err_out;
+ }
+
+ /*
+ * If max_xloop is specified, create that many devices upfront.
+ * This also becomes a hard limit. If max_xloop is not specified,
+ * create CONFIG_BLK_DEV_XLOOP_MIN_COUNT xloop devices at module
+ * init time. xloop devices can be requested on-demand with the
+ * /dev/xloop-control interface, or be instantiated by accessing
+ * a 'dead' device node.
+ */
+ if (max_xloop) {
+ nr = CONFIG_BLK_DEV_LOOP_MIN_COUNT;
+ range = 1UL << MINORBITS;
+ }
+
+ err = misc_register(&xloop_misc);
+ if (err < 0)
+ goto err_out;
+
+
+ if (register_blkdev(LOOP_MAJOR, "xloop")) {
+ err = -EIO;
+ goto misc_out;
+ }
+
+#ifdef CONFIG_DEBUG_FS
+ xloop_dbgfs_dir = debugfs_create_dir("xloop", NULL);
+ if (IS_ERR_OR_NULL(xloop_dbgfs_dir)) {
+ err = -ENODEV;
+ goto misc_out;
+ }
+#endif
+
+ blk_register_region(MKDEV(LOOP_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);
+ for (i = 0; i < nr; i++)
+ xloop_add(&xlo, i);
+ mutex_unlock(&xloop_ctl_mutex);
+
+ printk(KERN_INFO "xloop: module loaded\n");
+ return 0;
+
+misc_out:
+ misc_deregister(&xloop_misc);
+err_out:
+ return err;
+}
+
+static int xloop_exit_cb(int id, void *ptr, void *data)
+{
+ struct xloop_device *xlo = ptr;
+
+ xloop_remove(xlo);
+ return 0;
+}
+
+static void __exit xloop_exit(void)
+{
+ unsigned long range;
+
+ range = max_xloop ? max_xloop << part_shift : 1UL << MINORBITS;
+
+ mutex_lock(&xloop_ctl_mutex);
+
+ idr_for_each(&xloop_index_idr, &xloop_exit_cb, NULL);
+ idr_destroy(&xloop_index_idr);
+
+ blk_unregister_region(MKDEV(LOOP_MAJOR, 0), range);
+ unregister_blkdev(LOOP_MAJOR, "xloop");
+
+#ifdef CONFIG_DEBUG_FS
+ debugfs_remove(xloop_dbgfs_dir);
+#endif
+
+ misc_deregister(&xloop_misc);
+
+ mutex_unlock(&xloop_ctl_mutex);
+}
+
+module_init(xloop_init);
+module_exit(xloop_exit);
+
+#ifndef MODULE
+static int __init max_xloop_setup(char *str)
+{
+ max_xloop = simple_strtol(str, NULL, 0);
+ return 1;
+}
+
+__setup("max_xloop=", max_xloop_setup);
+#endif
diff --git a/kernel/loop_main.h b/kernel/loop_main.h
new file mode 100644
index 0000000..1b5851a
--- /dev/null
+++ b/kernel/loop_main.h
@@ -0,0 +1,105 @@
+/*
+ * loop_main.h
+ *
+ * Written by Theodore Ts'o, 3/29/93.
+ *
+ * Copyright 1993 by Theodore Ts'o. Redistribution of this file is
+ * permitted under the GNU General Public License.
+ */
+#ifndef _LINUX_XLOOP_H
+#define _LINUX_XLOOP_H
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include "uapi/linux/loop.h"
+#ifdef CONFIG_DEBUG_FS
+#include
+#endif
+
+#include "loop_file_fmt.h"
+
+/* Possible states of device */
+enum {
+ Xlo_unbound,
+ Xlo_bound,
+ Xlo_rundown,
+};
+
+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;
+ 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);
+
+ struct xloop_file_fmt *xlo_fmt;
+
+ struct file * xlo_backing_file;
+ struct block_device *xlo_device;
+ void *key_data;
+
+ 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;
+
+ 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;
+#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 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 *);
+ /* 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);
+ struct module *owner;
+};
+
+int xloop_register_transfer(struct xloop_func_table *funcs);
+int xloop_unregister_transfer(int number);
+
+#endif
diff --git a/kernel/uapi/linux/loop.h b/kernel/uapi/linux/loop.h
new file mode 100644
index 0000000..f93f6ad
--- /dev/null
+++ b/kernel/uapi/linux/loop.h
@@ -0,0 +1,125 @@
+/* SPDX-License-Identifier: GPL-1.0+ WITH Linux-syscall-note */
+/*
+ * include/linux/loop.h
+ *
+ * Written by Theodore Ts'o, 3/29/93.
+ *
+ * Copyright 1993 by Theodore Ts'o. Redistribution of this file is
+ * permitted under the GNU General Public License.
+ */
+#ifndef _UAPI_LINUX_XLOOP_H
+#define _UAPI_LINUX_XLOOP_H
+
+
+#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 that can be set using XLOOP_SET_STATUS(64) */
+#define XLOOP_SET_STATUS_SETTABLE_FLAGS (XLO_FLAGS_AUTOCLEAR | XLO_FLAGS_PARTSCAN)
+
+/* XLO_FLAGS that can be cleared using XLOOP_SET_STATUS(64) */
+#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)
+
+#include /* for __kernel_old_dev_t */
+#include /* for __u64 */
+
+/* Backwards compatibility version */
+struct xloop_info {
+ int xlo_number; /* ioctl r/o */
+ __kernel_old_dev_t xlo_device; /* ioctl r/o */
+ unsigned long xlo_inode; /* ioctl r/o */
+ __kernel_old_dev_t xlo_rdevice; /* ioctl r/o */
+ int xlo_offset;
+ int xlo_encrypt_type;
+ int xlo_encrypt_key_size; /* ioctl w/o */
+ int xlo_flags;
+ char xlo_name[XLO_NAME_SIZE];
+ unsigned char xlo_encrypt_key[XLO_KEY_SIZE]; /* ioctl w/o */
+ unsigned long xlo_init[2];
+ char reserved[4];
+ int xlo_file_fmt_type;
+};
+
+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;
+};
+
+/**
+ * struct xloop_config - Complete configuration for a xloop device.
+ * @fd: fd of the file to be used as a backing file for the xloop device.
+ * @block_size: block size to use; ignored if 0.
+ * @info: struct xloop_info64 to configure the xloop device with.
+ *
+ * This structure is used with the XLOOP_CONFIGURE ioctl, and can be used to
+ * atomically setup and configure all xloop device parameters at once.
+ */
+struct xloop_config {
+ __u32 fd;
+ __u32 block_size;
+ 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
+
+/*
+ * IOCTL commands --- we will commandeer 0x4C ('L')
+ */
+#define XLOOP_SET_FD 0x4C00
+#define XLOOP_CLR_FD 0x4C01
+#define XLOOP_SET_STATUS 0x4C02
+#define XLOOP_GET_STATUS 0x4C03
+#define XLOOP_SET_STATUS64 0x4C04
+#define XLOOP_GET_STATUS64 0x4C05
+#define XLOOP_CHANGE_FD 0x4C06
+#define XLOOP_SET_CAPACITY 0x4C07
+#define XLOOP_SET_DIRECT_IO 0x4C08
+#define XLOOP_SET_BLOCK_SIZE 0x4C09
+#define XLOOP_CONFIGURE 0x4C0A
+
+/* /dev/xloop-control interface */
+#define XLOOP_CTL_ADD 0x4C80
+#define XLOOP_CTL_REMOVE 0x4C81
+#define XLOOP_CTL_GET_FREE 0x4C82
+#endif /* _UAPI_LINUX_XLOOP_H */
diff --git a/loop_file_fmt.c b/loop_file_fmt.c
deleted file mode 100644
index 062ea0d..0000000
--- a/loop_file_fmt.c
+++ /dev/null
@@ -1,347 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * loop_file_fmt.c
- *
- * File format subsystem for the xloop device module.
- *
- * Copyright (C) 2019 Manuel Bentele
- */
-
-#include
-#include
-
-#include "loop_file_fmt.h"
-
-/* storage for all registered file format drivers */
-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)
-{
- int ret = 0;
-
- if (drv == NULL)
- return -EFAULT;
-
- if (drv->file_fmt_type > MAX_XLO_FILE_FMT)
- return -EINVAL;
-
- if (xloop_file_fmt_drivers[drv->file_fmt_type] == NULL) {
- xloop_file_fmt_drivers[drv->file_fmt_type] = drv;
- printk(KERN_INFO "xloop_file_fmt: successfully registered file "
- "format driver %s", drv->name);
- } else {
- printk(KERN_WARNING "xloop_file_fmt: driver for file format "
- "already registered");
- ret = -EBUSY;
- }
-
- return ret;
-}
-EXPORT_SYMBOL(xloop_file_fmt_register_driver);
-
-void xloop_file_fmt_unregister_driver(struct xloop_file_fmt_driver *drv)
-{
- if (drv == NULL)
- return;
-
- if (drv->file_fmt_type > MAX_XLO_FILE_FMT)
- return;
-
- xloop_file_fmt_drivers[drv->file_fmt_type] = NULL;
- printk(KERN_INFO "xloop_file_fmt: successfully unregistered file "
- "format driver %s", drv->name);
-}
-EXPORT_SYMBOL(xloop_file_fmt_unregister_driver);
-
-struct xloop_file_fmt *xloop_file_fmt_alloc(void)
-{
- return kzalloc(sizeof(struct xloop_file_fmt), GFP_KERNEL);
-}
-
-void xloop_file_fmt_free(struct xloop_file_fmt *xlo_fmt)
-{
- kfree(xlo_fmt);
-}
-
-int xloop_file_fmt_set_xlo(struct xloop_file_fmt *xlo_fmt, struct xloop_device *xlo)
-{
- if (xlo_fmt == NULL)
- return -EINVAL;
-
- xlo_fmt->xlo = xlo;
-
- return 0;
-}
-EXPORT_SYMBOL(xloop_file_fmt_set_xlo);
-
-struct xloop_device *xloop_file_fmt_get_xlo(struct xloop_file_fmt *xlo_fmt)
-{
- return xlo_fmt->xlo;
-}
-EXPORT_SYMBOL(xloop_file_fmt_get_xlo);
-
-int xloop_file_fmt_init(struct xloop_file_fmt *xlo_fmt,
- u32 file_fmt_type)
-{
- struct xloop_file_fmt_ops *ops;
- struct module *drv;
- int ret = 0;
-
- if (file_fmt_type > MAX_XLO_FILE_FMT)
- return -EINVAL;
-
- xlo_fmt->file_fmt_type = file_fmt_type;
-
- if (xlo_fmt->file_fmt_state != file_fmt_uninitialized) {
- printk(KERN_WARNING "xloop_file_fmt: file format is "
- "initialized already");
- return -EINVAL;
- }
-
- /* check if new file format driver is registered */
- if (xloop_file_fmt_drivers[xlo_fmt->file_fmt_type] == NULL) {
- printk(KERN_ERR "xloop_file_fmt: file format driver is not "
- "available");
- return -ENODEV;
- }
-
- printk(KERN_INFO "xloop_file_fmt: use file format driver %s",
- 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)) {
- printk(KERN_ERR "xloop_file_fmt: file format driver %s can not "
- "be accessed",
- xloop_file_fmt_drivers[xlo_fmt->file_fmt_type]->name);
- return -ENODEV;
- }
-
- ops = xloop_file_fmt_drivers[xlo_fmt->file_fmt_type]->ops;
- if (likely(ops->init)) {
- ret = ops->init(xlo_fmt);
- if (ret < 0)
- goto free_drv;
- }
-
- /* 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;
-
-free_drv:
- module_put(drv);
- xlo_fmt->file_fmt_state = file_fmt_uninitialized;
- return ret;
-}
-
-void xloop_file_fmt_exit(struct xloop_file_fmt *xlo_fmt)
-{
- struct xloop_file_fmt_ops *ops;
- struct module *drv;
-
- if (xlo_fmt->file_fmt_state != file_fmt_initialized) {
- printk(KERN_WARNING "xloop_file_fmt: file format is "
- "uninitialized already");
- return;
- }
-
- ops = xloop_file_fmt_drivers[xlo_fmt->file_fmt_type]->ops;
- if (likely(ops->exit))
- ops->exit(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 */
- xlo_fmt->file_fmt_state = file_fmt_uninitialized;
-}
-
-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)) {
- printk(KERN_ERR "xloop_file_fmt: file format is "
- "not initialized, can not read");
- return -EINVAL;
- }
-
- ops = xloop_file_fmt_drivers[xlo_fmt->file_fmt_type]->ops;
- if (likely(ops->read))
- return ops->read(xlo_fmt, rq);
- else
- return -EIO;
-}
-
-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)) {
- printk(KERN_ERR "xloop_file_fmt: file format is "
- "not initialized, can not read aio");
- return -EINVAL;
- }
-
- ops = xloop_file_fmt_drivers[xlo_fmt->file_fmt_type]->ops;
- if (likely(ops->read_aio))
- return ops->read_aio(xlo_fmt, rq);
- else
- return -EIO;
-}
-
-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)) {
- printk(KERN_ERR "xloop_file_fmt: file format is "
- "not initialized, can not write");
- return -EINVAL;
- }
-
- ops = xloop_file_fmt_drivers[xlo_fmt->file_fmt_type]->ops;
- if (likely(ops->write))
- return ops->write(xlo_fmt, rq);
- else
- return -EIO;
-}
-
-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)) {
- printk(KERN_ERR "xloop_file_fmt: file format is "
- "not initialized, can not write aio");
- return -EINVAL;
- }
-
- ops = xloop_file_fmt_drivers[xlo_fmt->file_fmt_type]->ops;
- if (likely(ops->write_aio))
- return ops->write_aio(xlo_fmt, rq);
- else
- return -EIO;
-}
-
-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)) {
- printk(KERN_ERR "xloop_file_fmt: file format is "
- "not initialized, can not write zeros");
- return -EINVAL;
- }
-
- ops = xloop_file_fmt_drivers[xlo_fmt->file_fmt_type]->ops;
- if (likely(ops->write_zeros))
- return ops->write_zeros(xlo_fmt, rq);
- else
- return -EIO;
-}
-
-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)) {
- printk(KERN_ERR "xloop_file_fmt: file format is "
- "not initialized, can not discard");
- return -EINVAL;
- }
-
- ops = xloop_file_fmt_drivers[xlo_fmt->file_fmt_type]->ops;
- if (likely(ops->discard))
- return ops->discard(xlo_fmt, rq);
- else
- return -EIO;
-}
-
-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)) {
- printk(KERN_ERR "xloop_file_fmt: file format is "
- "not initialized, can not flush");
- return -EINVAL;
- }
-
- ops = xloop_file_fmt_drivers[xlo_fmt->file_fmt_type]->ops;
- if (likely(ops->flush))
- return ops->flush(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)
-{
- struct xloop_file_fmt_ops *ops;
-
- if (unlikely(xlo_fmt->file_fmt_state != file_fmt_initialized)) {
- printk(KERN_ERR "xloop_file_fmt: file format is "
- "not initialized, can not read sector size");
- return 0;
- }
-
- ops = xloop_file_fmt_drivers[xlo_fmt->file_fmt_type]->ops;
- if (likely(ops->sector_size))
- return ops->sector_size(xlo_fmt, file, offset, sizelimit);
- else
- return 0;
-}
-
-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;
-
- /* 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 */
- return xloop_file_fmt_init(xlo_fmt, file_fmt_type_new);
-}
-
-ssize_t xloop_file_fmt_print_type(u32 file_fmt_type, char *file_fmt_name)
-{
- ssize_t len = 0;
-
- switch (file_fmt_type) {
- case XLO_FILE_FMT_RAW:
- len = sprintf(file_fmt_name, "%s", "RAW");
- break;
- case XLO_FILE_FMT_QCOW:
- len = sprintf(file_fmt_name, "%s", "QCOW");
- break;
- case XLO_FILE_FMT_VDI:
- len = sprintf(file_fmt_name, "%s", "VDI");
- break;
- case XLO_FILE_FMT_VMDK:
- len = sprintf(file_fmt_name, "%s", "VMDK");
- break;
- default:
- len = sprintf(file_fmt_name, "%s", "ERROR: Unsupported xloop "
- "file format!");
- break;
- }
-
- return len;
-}
-EXPORT_SYMBOL(xloop_file_fmt_print_type);
diff --git a/loop_file_fmt.h b/loop_file_fmt.h
deleted file mode 100644
index 38d6a3b..0000000
--- a/loop_file_fmt.h
+++ /dev/null
@@ -1,380 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * loop_file_fmt.h
- *
- * File format subsystem for the xloop device module.
- *
- * Copyright (C) 2019 Manuel Bentele
- */
-
-#ifndef _LINUX_XLOOP_FILE_FMT_H
-#define _LINUX_XLOOP_FILE_FMT_H
-
-#include "loop_main.h"
-
-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)
-
-/**
- * struct xloop_file_fmt_ops - File format subsystem operations
- *
- * Data structure representing the file format subsystem interface.
- */
-struct xloop_file_fmt_ops {
- /**
- * @init: Initialization callback function
- */
- int (*init) (struct xloop_file_fmt *xlo_fmt);
-
- /**
- * @exit: Release callback function
- */
- void (*exit) (struct xloop_file_fmt *xlo_fmt);
-
- /**
- * @read: Read IO callback function
- */
- 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);
-
- /**
- * @read_aio: Asynchronous read IO callback function
- */
- 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);
-
- /**
- * @zero: Zero (discard) IO callback function
- */
- 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);
-
- /**
- * @flush: Flush callback function
- */
- 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);
-};
-
-/**
- * struct xloop_file_fmt_driver - File format subsystem driver
- *
- * Data structure to implement file format drivers for the file format
- * subsystem.
- */
-struct xloop_file_fmt_driver {
- /**
- * @name: Name of the file format driver
- */
- const char *name;
-
- /**
- * @file_fmt_type: xloop file format type of the file format driver
- */
- const u32 file_fmt_type;
-
- /**
- * @ops: Driver's implemented file format operations
- */
- struct xloop_file_fmt_ops *ops;
-
- /**
- * @ops: Owner of the file format driver
- */
- struct module *owner;
-};
-
-/*
- * states of the file format
- *
- * transitions:
- * xloop_file_fmt_init(...)
- * ---> uninitialized ------------------------------> initialized
- * xloop_file_fmt_exit(...)
- * initialized ------------------------------> uninitialized
- * xloop_file_fmt_read(...)
- * initialized ------------------------------> initialized
- * xloop_file_fmt_read_aio(...)
- * initialized ------------------------------> initialized
- * xloop_file_fmt_write(...)
- * initialized ------------------------------> initialized
- * xloop_file_fmt_write_aio(...)
- * initialized ------------------------------> initialized
- * xloop_file_fmt_discard(...)
- * initialized ------------------------------> initialized
- * xloop_file_fmt_flush(...)
- * initialized ------------------------------> initialized
- * xloop_file_fmt_sector_size(...)
- * initialized ------------------------------> initialized
- *
- * xloop_file_fmt_change(...)
- * +-----------------------------------------------------------+
- * | exit(...) init(...) |
- * | initialized -------> uninitialized -------> initialized |
- * +-----------------------------------------------------------+
- */
-enum {
- file_fmt_uninitialized = 0,
- file_fmt_initialized
-};
-
-/**
- * struct xloop_file_fmt - xloop file format
- *
- * Data structure to use with the file format the xloop file format subsystem.
- */
-struct xloop_file_fmt {
- /**
- * @file_fmt_type: Current type of the xloop file format
- */
- u32 file_fmt_type;
-
- /**
- * @file_fmt_state: Current state of the xloop file format
- */
- int file_fmt_state;
-
- /**
- * @xlo: Link to a file format's xloop device
- */
- struct xloop_device *xlo;
-
- /**
- * @private_data: Optional link to a file format's driver specific data
- */
- void *private_data;
-};
-
-
-/* subsystem functions for the driver implementation */
-
-/**
- * xloop_file_fmt_register_driver - Register a xloop file format driver
- * @drv: File format driver
- *
- * Registers the specified xloop file format driver @drv by the xloop file format
- * subsystem.
- */
-extern int xloop_file_fmt_register_driver(struct xloop_file_fmt_driver *drv);
-
-/**
- * xloop_file_fmt_unregister_driver - Unregister a xloop file format driver
- * @drv: File format driver
- *
- * Unregisters the specified xloop file format driver @drv from the xloop file
- * format subsystem.
- */
-extern void xloop_file_fmt_unregister_driver(struct xloop_file_fmt_driver *drv);
-
-
-/* subsystem functions for subsystem usage */
-
-/**
- * xloop_file_fmt_alloc - Allocate a xloop file format
- *
- * Dynamically allocates a xloop file format and returns a pointer to the
- * created xloop file format.
- */
-extern struct xloop_file_fmt *xloop_file_fmt_alloc(void);
-
-/**
- * xloop_file_fmt_free - Free an allocated xloop file format
- * @xlo_fmt: xloop file format
- *
- * Frees the already allocated xloop file format @xlo_fmt.
- */
-extern void xloop_file_fmt_free(struct xloop_file_fmt *xlo_fmt);
-
-/**
- * xloop_file_fmt_set_xlo - Set the xloop file format's xloop device
- * @xlo_fmt: xloop file format
- * @xlo: xloop device
- *
- * 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);
-
-/**
- * xloop_file_fmt_get_xlo - Get the xloop file format's xloop device
- * @xlo_fmt: xloop file format
- *
- * Returns a pointer to the xloop device of the xloop file format @xlo_fmt.
- */
-extern struct xloop_device *xloop_file_fmt_get_xlo(struct xloop_file_fmt *xlo_fmt);
-
-/**
- * xloop_file_fmt_init - Initialize a xloop file format
- * @xlo_fmt: xloop file format
- * @file_fmt_type: Type of the file format
- *
- * Initializes the specified xloop file format @xlo_fmt and sets up the correct
- * file format type @file_fmt_type. Depending on @file_fmt_type, the correct
- * xloop file format driver is loaded in the subsystems backend. If no xloop file
- * 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);
-
-/**
- * xloop_file_fmt_exit - Release a xloop file format
- * @xlo_fmt: xloop file format
- *
- * Releases the specified xloop file format @xlo_fmt and all its resources.
- */
-extern void xloop_file_fmt_exit(struct xloop_file_fmt *xlo_fmt);
-
-/**
- * xloop_file_fmt_read - Read IO from a xloop file format
- * @xlo_fmt: xloop file format
- * @rq: IO Request
- *
- * Reads IO from the file format's xloop device by sending the IO read 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_read(struct xloop_file_fmt *xlo_fmt,
- struct request *rq);
-
-/**
- * xloop_file_fmt_read_aio - Read IO from a xloop file format asynchronously
- * @xlo_fmt: xloop file format
- * @rq: IO Request
- *
- * Reads IO from the file format's xloop device asynchronously by sending the
- * IO read aio 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_read_aio(struct xloop_file_fmt *xlo_fmt,
- struct request *rq);
-
-/**
- * xloop_file_fmt_write - Write IO to a xloop file format
- * @xlo_fmt: xloop file format
- * @rq: IO Request
- *
- * Write IO to the file format's xloop device by sending the IO write 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(struct xloop_file_fmt *xlo_fmt,
- struct request *rq);
-
-/**
- * xloop_file_fmt_write_aio - Write IO to a xloop file format asynchronously
- * @xlo_fmt: xloop file format
- * @rq: IO Request
- *
- * Write IO to the file format's xloop device asynchronously by sending the
- * IO write aio 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_aio(struct xloop_file_fmt *xlo_fmt,
- struct request *rq);
-
-/**
- * xloop_file_fmt_write_zeros - Zero (discard) IO on a xloop file format
- * @xlo_fmt: xloop file format
- * @rq: IO Request
- *
- * Zero (discard) IO on the file format's xloop device by sending the IO write
- * 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);
-
-/**
- * xloop_file_fmt_discard - Discard IO on a xloop file format
- * @xlo_fmt: xloop file format
- * @rq: IO Request
- *
- * Discard IO on the file format's xloop device by sending the IO discard
- * 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);
-
-/**
- * xloop_file_fmt_flush - Flush a xloop file format
- * @xlo_fmt: xloop file format
- *
- * Flush the file format's xloop device by calling the registered callback
- * function of the suitable xloop file format driver.
- */
-extern int xloop_file_fmt_flush(struct xloop_file_fmt *xlo_fmt);
-
-/**
- * xloop_file_fmt_sector_size - Get sector size of a xloop file format
- * @xlo_fmt: xloop file format
- * @file: xloop file formats file for sector size calculation
- * @offset: Offset within the file for sector size calculation
- * @sizelimit: Sizelimit of the file for sector size calculation
- *
- * Returns the physical sector size of the given xloop file format's file.
- * 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);
-
-/**
- * xloop_file_fmt_change - Change the xloop file format's type
- * @xlo_fmt: xloop file format
- * @file_fmt_type_new: xloop file format type
- *
- * Changes the file format type of the already initialized xloop file format
- * @xlo_fmt. Therefore, the function releases the old file format and frees all
- * 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);
-
-
-/* helper functions of the subsystem */
-
-/**
- * xloop_file_fmt_print_type - Convert file format type to string
- * @file_fmt_type: xloop file format type
- * @file_fmt_name: xloop file format type string
- *
- * 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);
-
-#endif
diff --git a/loop_file_fmt_qcow_cache.c b/loop_file_fmt_qcow_cache.c
deleted file mode 100644
index 4ef772a..0000000
--- a/loop_file_fmt_qcow_cache.c
+++ /dev/null
@@ -1,218 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * loop_file_fmt_qcow_cache.c
- *
- * QCOW file format driver for the xloop device module.
- *
- * Ported QCOW2 implementation of the QEMU project (GPL-2.0):
- * L2/refcount table cache for the QCOW2 format.
- *
- * The copyright (C) 2010 of the original code is owned by
- * Kevin Wolf
- *
- * Copyright (C) 2019 Manuel Bentele
- */
-
-#include
-#include
-#include
-#include
-#include
-#include
-
-#include "loop_file_fmt_qcow_main.h"
-#include "loop_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)
-{
- 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)
-{
- ptrdiff_t table_offset = (u8 *) table - (u8 *) c->table_array;
- int idx = table_offset / c->table_size;
- ASSERT(idx >= 0 && idx < c->size && table_offset % c->table_size == 0);
- 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)
-{
- struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
-
- if (c == qcow_data->refcount_block_cache) {
- return "refcount block";
- } else if (c == qcow_data->l2_table_cache) {
- return "L2 table";
- } else {
- /* do not abort, because this is not critical */
- return "unknown";
- }
-}
-
-struct xloop_file_fmt_qcow_cache *xloop_file_fmt_qcow_cache_create(
- struct xloop_file_fmt *xlo_fmt, int num_tables, unsigned table_size)
-{
-#ifdef CONFIG_DEBUG_DRIVER
- struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
-#endif
- struct xloop_file_fmt_qcow_cache *c;
-
- ASSERT(num_tables > 0);
- ASSERT(is_power_of_2(table_size));
- ASSERT(table_size >= (1 << QCOW_MIN_CLUSTER_BITS));
- ASSERT(table_size <= qcow_data->cluster_size);
-
- c = kzalloc(sizeof(*c), GFP_KERNEL);
- 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->table_array = vzalloc(num_tables * c->table_size);
-
- if (!c->entries || !c->table_array) {
- vfree(c->table_array);
- vfree(c->entries);
- kfree(c);
- c = NULL;
- }
-
- return c;
-}
-
-void xloop_file_fmt_qcow_cache_destroy(struct xloop_file_fmt *xlo_fmt)
-{
- struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
- struct xloop_file_fmt_qcow_cache *c = qcow_data->l2_table_cache;
- int 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_qcow_cache *c, int i)
-{
- if (!c->entries[i].dirty || !c->entries[i].offset) {
- return 0;
- } else {
- printk(KERN_ERR "xloop_file_fmt_qcow: Flush dirty cache tables "
- "is not supported yet\n");
- return -ENOSYS;
- }
-}
-
-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;
- int ret;
- int lookup_index;
- u64 min_lru_counter = U64_MAX;
- int min_lru_index = -1;
- u64 read_offset;
- size_t len;
-
- ASSERT(offset != 0);
-
- if (!IS_ALIGNED(offset, c->table_size)) {
- printk_ratelimited(KERN_ERR "xloop_file_fmt_qcow: Cannot get "
- "entry from %s cache: offset %llx is unaligned\n",
- __xloop_file_fmt_qcow_cache_get_name(xlo_fmt, c),
- offset);
- return -EIO;
- }
-
- /* Check if the table is already cached */
- i = lookup_index = (offset / c->table_size * 4) % c->size;
- do {
- 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) {
- 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");
- }
-
- /* Cache miss: write a table back and replace it */
- i = min_lru_index;
-
- ret = __xloop_file_fmt_qcow_cache_entry_flush(c, i);
- 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);
- if (len < 0) {
- len = ret;
- return ret;
- }
- }
-
- c->entries[i].offset = offset;
-
- /* And return the right table */
-found:
- c->entries[i].ref++;
- *table = __xloop_file_fmt_qcow_cache_get_table_addr(c, i);
-
- return 0;
-}
-
-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);
-}
-
-void xloop_file_fmt_qcow_cache_put(struct xloop_file_fmt *xlo_fmt, 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;
- int i = __xloop_file_fmt_qcow_cache_get_table_idx(c, *table);
-
- c->entries[i].ref--;
- *table = NULL;
-
- if (c->entries[i].ref == 0) {
- c->entries[i].lru_counter = ++c->lru_counter;
- }
-
- ASSERT(c->entries[i].ref >= 0);
-}
diff --git a/loop_file_fmt_qcow_cache.h b/loop_file_fmt_qcow_cache.h
deleted file mode 100644
index d2f1010..0000000
--- a/loop_file_fmt_qcow_cache.h
+++ /dev/null
@@ -1,51 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * xloop_file_fmt_qcow_cache.h
- *
- * Ported QCOW2 implementation of the QEMU project (GPL-2.0):
- * L2/refcount table cache for the QCOW2 format.
- *
- * The copyright (C) 2010 of the original code is owned by
- * Kevin Wolf
- *
- * Copyright (C) 2019 Manuel Bentele
- */
-
-#ifndef _LINUX_XLOOP_FILE_FMT_QCOW_CACHE_H
-#define _LINUX_XLOOP_FILE_FMT_QCOW_CACHE_H
-
-#include "loop_file_fmt.h"
-
-struct xloop_file_fmt_qcow_cache_table {
- s64 offset;
- u64 lru_counter;
- int ref;
- bool dirty;
-};
-
-struct xloop_file_fmt_qcow_cache {
- struct xloop_file_fmt_qcow_cache_table *entries;
- struct xloop_file_fmt_qcow_cache *depends;
- int size;
- int table_size;
- bool depends_on_flush;
- void *table_array;
- u64 lru_counter;
- 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 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 void xloop_file_fmt_qcow_cache_put(struct xloop_file_fmt *xlo_fmt,
- void **table);
-
-#endif
diff --git a/loop_file_fmt_qcow_cluster.c b/loop_file_fmt_qcow_cluster.c
deleted file mode 100644
index 593a173..0000000
--- a/loop_file_fmt_qcow_cluster.c
+++ /dev/null
@@ -1,270 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * xloop_file_fmt_qcow_cluster.c
- *
- * Ported QCOW2 implementation of the QEMU project (GPL-2.0):
- * Cluster calculation and lookup for the QCOW2 format.
- *
- * The copyright (C) 2004-2006 of the original code is owned by Fabrice Bellard.
- *
- * Copyright (C) 2019 Manuel Bentele
- */
-
-#include
-#include
-
-#include "loop_file_fmt.h"
-#include "loop_file_fmt_qcow_main.h"
-#include "loop_file_fmt_qcow_cache.h"
-#include "loop_file_fmt_qcow_cluster.h"
-
-/*
- * Loads a L2 slice into memory (L2 slices are the parts of L2 tables
- * that are loaded by the qcow2 cache). If the slice is in the cache,
- * 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)
-{
- struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
-
- int start_of_slice = sizeof(u64) * (
- 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);
-}
-
-/*
- * Checks how many clusters in a given L2 slice are contiguous in the image
- * file. As soon as one of the flags in the bitmask stop_flags changes compared
- * to the first cluster, the search is stopped and the cluster is not counted
- * as contiguous. (This allows it, for example, to stop at the first compressed
- * cluster which may require a different handling)
- */
-static int __xloop_file_fmt_qcow_cluster_count_contiguous(
- struct xloop_file_fmt *xlo_fmt, int nb_clusters, int cluster_size,
- u64 *l2_slice, u64 stop_flags)
-{
- int i;
- enum xloop_file_fmt_qcow_cluster_type first_cluster_type;
- u64 mask = stop_flags | L2E_OFFSET_MASK | QCOW_OFLAG_COMPRESSED;
- u64 first_entry = be64_to_cpu(l2_slice[0]);
- u64 offset = first_entry & mask;
-
- first_cluster_type = xloop_file_fmt_qcow_get_cluster_type(xlo_fmt,
- first_entry);
- if (first_cluster_type == QCOW_CLUSTER_UNALLOCATED) {
- return 0;
- }
-
- /* must be allocated */
- ASSERT(first_cluster_type == QCOW_CLUSTER_NORMAL ||
- first_cluster_type == QCOW_CLUSTER_ZERO_ALLOC);
-
- for (i = 0; i < nb_clusters; i++) {
- u64 l2_entry = be64_to_cpu(l2_slice[i]) & mask;
- if (offset + (u64) i * cluster_size != l2_entry) {
- break;
- }
- }
-
- return i;
-}
-
-/*
- * Checks how many consecutive unallocated clusters in a given L2
- * slice have the same cluster type.
- */
-static int __xloop_file_fmt_qcow_cluster_count_contiguous_unallocated(
- struct xloop_file_fmt *xlo_fmt, int nb_clusters, u64 *l2_slice,
- enum xloop_file_fmt_qcow_cluster_type wanted_type)
-{
- int i;
-
- ASSERT(wanted_type == QCOW_CLUSTER_ZERO_PLAIN ||
- wanted_type == QCOW_CLUSTER_UNALLOCATED);
-
- for (i = 0; i < nb_clusters; i++) {
- u64 entry = be64_to_cpu(l2_slice[i]);
- enum xloop_file_fmt_qcow_cluster_type type =
- xloop_file_fmt_qcow_get_cluster_type(xlo_fmt, entry);
-
- if (type != wanted_type) {
- break;
- }
- }
-
- return i;
-}
-
-/*
- * For a given offset of the virtual disk, find the cluster type and offset in
- * the qcow2 file. The offset is stored in *cluster_offset.
- *
- * On entry, *bytes is the maximum number of contiguous bytes starting at
- * offset that we are interested in.
- *
- * On exit, *bytes is the number of bytes starting at offset that have the same
- * cluster type and (if applicable) are stored contiguously in the image file.
- * Compressed clusters are always returned one by one.
- *
- * Returns the cluster type (QCOW2_CLUSTER_*) on success, -errno in error
- * cases.
- */
-int xloop_file_fmt_qcow_cluster_get_offset(struct xloop_file_fmt *xlo_fmt,
- u64 offset, unsigned int *bytes, u64 *cluster_offset)
-{
- struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
- unsigned int l2_index;
- u64 l1_index, l2_offset, *l2_slice;
- int c;
- unsigned int offset_in_cluster;
- u64 bytes_available, bytes_needed, nb_clusters;
- enum xloop_file_fmt_qcow_cluster_type type;
- int ret;
-
- 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
- * 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;
-
- if (bytes_needed > bytes_available) {
- bytes_needed = bytes_available;
- }
-
- *cluster_offset = 0;
-
- /* seek to the l2 offset in the l1 table */
- l1_index = xloop_file_fmt_qcow_offset_to_l1_index(qcow_data, offset);
- if (l1_index >= qcow_data->l1_size) {
- type = QCOW_CLUSTER_UNALLOCATED;
- goto out;
- }
-
- l2_offset = qcow_data->l1_table[l1_index] & L1E_OFFSET_MASK;
- if (!l2_offset) {
- type = QCOW_CLUSTER_UNALLOCATED;
- goto out;
- }
-
- if (xloop_file_fmt_qcow_offset_into_cluster(qcow_data, l2_offset)) {
- printk_ratelimited(KERN_ERR "xloop_file_fmt_qcow: 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) {
- 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);
- *cluster_offset = be64_to_cpu(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 */
- ASSERT(nb_clusters <= INT_MAX);
-
- type = xloop_file_fmt_qcow_get_cluster_type(xlo_fmt, *cluster_offset);
- if (qcow_data->qcow_version < 3 && (
- type == QCOW_CLUSTER_ZERO_PLAIN ||
- type == QCOW_CLUSTER_ZERO_ALLOC)) {
- printk_ratelimited(KERN_ERR "xloop_file_fmt_qcow: 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_CLUSTER_COMPRESSED:
- if (xloop_file_fmt_qcow_has_data_file(xlo_fmt)) {
- printk_ratelimited(KERN_ERR "xloop_file_fmt_qcow: "
- "compressed cluster entry found in image with "
- "external data file (L2 offset: %llx, "
- "L2 index: %x)", l2_offset, l2_index);
- ret = -EIO;
- goto fail;
- }
- /* Compressed clusters can only be processed one by one */
- c = 1;
- *cluster_offset &= L2E_COMPRESSED_OFFSET_SIZE_MASK;
- break;
- case QCOW_CLUSTER_ZERO_PLAIN:
- case QCOW_CLUSTER_UNALLOCATED:
- /* how many empty clusters ? */
- c = __xloop_file_fmt_qcow_cluster_count_contiguous_unallocated(
- xlo_fmt, nb_clusters, &l2_slice[l2_index], type);
- *cluster_offset = 0;
- break;
- case QCOW_CLUSTER_ZERO_ALLOC:
- case QCOW_CLUSTER_NORMAL:
- /* how many allocated clusters ? */
- c = __xloop_file_fmt_qcow_cluster_count_contiguous(xlo_fmt,
- nb_clusters, qcow_data->cluster_size,
- &l2_slice[l2_index], QCOW_OFLAG_ZERO);
- *cluster_offset &= L2E_OFFSET_MASK;
- if (xloop_file_fmt_qcow_offset_into_cluster(qcow_data,
- *cluster_offset)) {
- printk_ratelimited(KERN_ERR "xloop_file_fmt_qcow: "
- "cluster allocation offset %llx unaligned "
- "(L2 offset: %llx, L2 index: %x)\n",
- *cluster_offset, l2_offset, l2_index);
- ret = -EIO;
- goto fail;
- }
- if (xloop_file_fmt_qcow_has_data_file(xlo_fmt) &&
- *cluster_offset != offset - offset_in_cluster) {
- printk_ratelimited(KERN_ERR "xloop_file_fmt_qcow: "
- "external data file host cluster offset %llx "
- "does not match guest cluster offset: %llx, "
- "L2 index: %x)", *cluster_offset,
- offset - offset_in_cluster, l2_index);
- ret = -EIO;
- goto fail;
- }
- break;
- default:
- BUG();
- }
-
- xloop_file_fmt_qcow_cache_put(xlo_fmt, (void **) &l2_slice);
-
- bytes_available = (s64) c * qcow_data->cluster_size;
-
-out:
- if (bytes_available > bytes_needed) {
- bytes_available = bytes_needed;
- }
-
- /* bytes_available <= bytes_needed <= *bytes + offset_in_cluster;
- * subtracting offset_in_cluster will therefore definitely yield
- * something not exceeding UINT_MAX */
- ASSERT(bytes_available - offset_in_cluster <= UINT_MAX);
- *bytes = bytes_available - offset_in_cluster;
-
- return type;
-
-fail:
- xloop_file_fmt_qcow_cache_put(xlo_fmt, (void **) &l2_slice);
- return ret;
-}
diff --git a/loop_file_fmt_qcow_cluster.h b/loop_file_fmt_qcow_cluster.h
deleted file mode 100644
index 5078f29..0000000
--- a/loop_file_fmt_qcow_cluster.h
+++ /dev/null
@@ -1,23 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * xloop_file_fmt_qcow_cluster.h
- *
- * Ported QCOW2 implementation of the QEMU project (GPL-2.0):
- * Cluster calculation and lookup for the QCOW2 format.
- *
- * The copyright (C) 2004-2006 of the original code is owned by Fabrice Bellard.
- *
- * Copyright (C) 2019 Manuel Bentele
- */
-
-#ifndef _LINUX_XLOOP_FILE_FMT_QCOW_CLUSTER_H
-#define _LINUX_XLOOP_FILE_FMT_QCOW_CLUSTER_H
-
-#include "loop_file_fmt.h"
-
-extern int xloop_file_fmt_qcow_cluster_get_offset(struct xloop_file_fmt *xlo_fmt,
- u64 offset,
- unsigned int *bytes,
- u64 *cluster_offset);
-
-#endif
diff --git a/loop_file_fmt_qcow_main.c b/loop_file_fmt_qcow_main.c
deleted file mode 100644
index 7c3e360..0000000
--- a/loop_file_fmt_qcow_main.c
+++ /dev/null
@@ -1,953 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * xloop_file_fmt_qcow.c
- *
- * QCOW file format driver for the xloop device module.
- *
- * Copyright (C) 2019 Manuel Bentele
- */
-
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-
-#include "loop_file_fmt.h"
-#include "loop_file_fmt_qcow_main.h"
-#include "loop_file_fmt_qcow_cache.h"
-#include "loop_file_fmt_qcow_cluster.h"
-
-static int __qcow_file_fmt_header_read(struct file *file,
- struct xloop_file_fmt_qcow_header *header)
-{
- ssize_t len;
- loff_t offset;
- int ret = 0;
-
- /* read QCOW header */
- offset = 0;
- len = kernel_read(file, header, sizeof(*header), &offset);
- if (len < 0) {
- printk(KERN_ERR "xloop_file_fmt_qcow: could not read QCOW "
- "header");
- return len;
- }
-
- header->magic = be32_to_cpu(header->magic);
- header->version = be32_to_cpu(header->version);
- header->backing_file_offset = be64_to_cpu(header->backing_file_offset);
- header->backing_file_size = be32_to_cpu(header->backing_file_size);
- header->cluster_bits = be32_to_cpu(header->cluster_bits);
- header->size = be64_to_cpu(header->size);
- 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->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) {
- printk(KERN_ERR "xloop_file_fmt_qcow: image is not in QCOW "
- "format");
- return -EINVAL;
- }
-
- if (header->version < 2 || header->version > 3) {
- printk(KERN_ERR "xloop_file_fmt_qcow: unsupported QCOW version "
- "%d", 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;
- } 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->refcount_order = be32_to_cpu(header->refcount_order);
- header->header_length = be32_to_cpu(header->header_length);
-
- if (header->header_length < 104) {
- printk(KERN_ERR "xloop_file_fmt_qcow: QCOW header too "
- "short");
- return -EINVAL;
- }
- }
-
- 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)
-{
- struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
-
- if (entries > max_size_bytes / entry_len) {
- printk(KERN_INFO "xloop_file_fmt_qcow: %s too large",
- table_name);
- 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)
- ) {
- printk(KERN_INFO "xloop_file_fmt_qcow: %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)
-{
- struct xloop_device *xlo = xloop_file_fmt_get_xlo(xlo_fmt);
- return ((loff_t) blk_rq_pos(rq) << 9) + xlo->xlo_offset;
-}
-
-static int __qcow_file_fmt_compression_init(struct xloop_file_fmt *xlo_fmt)
-{
- struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
- int ret = 0;
-
- qcow_data->strm = kzalloc(sizeof(*qcow_data->strm), GFP_KERNEL);
- if (!qcow_data->strm) {
- ret = -ENOMEM;
- goto out;
- }
-
- qcow_data->strm->workspace = vzalloc(zlib_inflate_workspacesize());
- if (!qcow_data->strm->workspace) {
- ret = -ENOMEM;
- goto out_free_strm;
- }
-
- qcow_data->cmp_last_coffset = ULLONG_MAX;
- qcow_data->cmp_out_buf = vmalloc(qcow_data->cluster_size);
- if (!qcow_data->cmp_out_buf) {
- ret = -ENOMEM;
- goto out_free_workspace;
- }
-
- return ret;
-
-out_free_workspace:
- vfree(qcow_data->strm->workspace);
-out_free_strm:
- kfree(qcow_data->strm);
-out:
- return ret;
-}
-
-static void __qcow_file_fmt_compression_exit(struct xloop_file_fmt *xlo_fmt)
-{
- struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
-
- vfree(qcow_data->strm->workspace);
- kfree(qcow_data->strm);
- vfree(qcow_data->cmp_out_buf);
-}
-
-#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)
-{
- 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);
-
- 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);
- }
-
- 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)
-{
- 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));
-}
-
-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)
-{
- struct xloop_file_fmt *xlo_fmt = file->private_data;
- struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
- unsigned int cur_bytes = 1;
- u64 offset = 0;
- u64 cluster_offset = 0;
- s64 offset_in_cluster = 0;
- ssize_t len = 0;
- int ret = 0;
-
- /* read the share debugfs offset */
- ret = mutex_lock_interruptible(&qcow_data->dbgfs_qcow_offset_mutex);
- if (ret)
- return ret;
-
- offset = qcow_data->dbgfs_qcow_offset;
- mutex_unlock(&qcow_data->dbgfs_qcow_offset_mutex);
-
- /* calculate and print the cluster offset */
- ret = xloop_file_fmt_qcow_cluster_get_offset(xlo_fmt,
- offset, &cur_bytes, &cluster_offset);
- if (ret < 0)
- return -EINVAL;
-
- offset_in_cluster = xloop_file_fmt_qcow_offset_into_cluster(qcow_data,
- offset);
-
- len = sprintf(qcow_data->dbgfs_file_qcow_cluster_buf,
- "offset: %lld\ncluster_offset: %lld\noffset_in_cluster: %lld\n",
- offset, cluster_offset, offset_in_cluster);
-
- ASSERT(len < 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)
-{
- struct xloop_file_fmt *xlo_fmt = file->private_data;
- struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
- ssize_t len = 0;
- int ret = 0;
-
- 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);
- if (len < 0)
- return len;
-
- qcow_data->dbgfs_file_qcow_offset_buf[len] = '\0';
-
- ret = mutex_lock_interruptible(&qcow_data->dbgfs_qcow_offset_mutex);
- if (ret)
- return ret;
-
- ret = kstrtou64(qcow_data->dbgfs_file_qcow_offset_buf, 10,
- &qcow_data->dbgfs_qcow_offset);
- if (ret < 0)
- goto out;
-
- ret = len;
-out:
- mutex_unlock(&qcow_data->dbgfs_qcow_offset_mutex);
- 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 int __qcow_file_fmt_dbgfs_init(struct xloop_file_fmt *xlo_fmt)
-{
- struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
- struct xloop_device *xlo = xloop_file_fmt_get_xlo(xlo_fmt);
- int ret = 0;
-
- qcow_data->dbgfs_dir = debugfs_create_dir("QCOW", xlo->xlo_dbgfs_dir);
- if (IS_ERR_OR_NULL(qcow_data->dbgfs_dir)) {
- ret = -ENODEV;
- 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);
- 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);
- if (IS_ERR_OR_NULL(qcow_data->dbgfs_file_qcow_offset)) {
- qcow_data->dbgfs_file_qcow_offset = NULL;
- ret = -ENODEV;
- goto out_free_dbgfs_hdr;
- }
-
- qcow_data->dbgfs_qcow_offset = 0;
- mutex_init(&qcow_data->dbgfs_qcow_offset_mutex);
-
- return ret;
-
-out_free_dbgfs_hdr:
- debugfs_remove(qcow_data->dbgfs_file_qcow_header);
- qcow_data->dbgfs_file_qcow_header = NULL;
-out_free_dbgfs_dir:
- debugfs_remove(qcow_data->dbgfs_dir);
- qcow_data->dbgfs_dir = NULL;
-out:
- return ret;
-}
-
-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);
-
- mutex_destroy(&qcow_data->dbgfs_qcow_offset_mutex);
-
- if (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);
-}
-#endif
-
-static int qcow_file_fmt_init(struct xloop_file_fmt *xlo_fmt)
-{
- struct xloop_file_fmt_qcow_data *qcow_data;
- struct xloop_device *xlo = xloop_file_fmt_get_xlo(xlo_fmt);
- struct xloop_file_fmt_qcow_header header;
- u64 l1_vm_state_index;
- u64 l2_cache_size;
- u64 l2_cache_entry_size;
- ssize_t len;
- unsigned int i;
- int ret = 0;
-
- /* allocate memory for saving QCOW file format data */
- qcow_data = kzalloc(sizeof(*qcow_data), GFP_KERNEL);
- if (!qcow_data)
- return -ENOMEM;
-
- xlo_fmt->private_data = qcow_data;
-
- /* read the QCOW file header */
- ret = __qcow_file_fmt_header_read(xlo->xlo_backing_file, &header);
- 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 */
-#ifdef CONFIG_DEBUG_FS
- __qcow_file_fmt_header_to_buf(xlo_fmt, &header);
-#endif
-
- qcow_data->qcow_version = header.version;
-
- /* Initialise cluster size */
- if (header.cluster_bits < QCOW_MIN_CLUSTER_BITS
- || header.cluster_bits > QCOW_MAX_CLUSTER_BITS) {
- printk(KERN_ERR "xloop_file_fmt_qcow: unsupported cluster "
- "size: 2^%d", header.cluster_bits);
- ret = -EINVAL;
- goto free_qcow_data;
- }
-
- qcow_data->cluster_bits = header.cluster_bits;
- qcow_data->cluster_size = 1 << qcow_data->cluster_bits;
- qcow_data->cluster_sectors = 1 <<
- (qcow_data->cluster_bits - SECTOR_SHIFT);
-
- if (header.header_length > qcow_data->cluster_size) {
- printk(KERN_ERR "xloop_file_fmt_qcow: QCOW header exceeds "
- "cluster size");
- ret = -EINVAL;
- goto free_qcow_data;
- }
-
- if (header.backing_file_offset > qcow_data->cluster_size) {
- printk(KERN_ERR "xloop_file_fmt_qcow: invalid backing file "
- "offset");
- ret = -EINVAL;
- goto free_qcow_data;
- }
-
- if (header.backing_file_offset) {
- printk(KERN_ERR "xloop_file_fmt_qcow: backing file support not "
- "available");
- ret = -ENOTSUPP;
- goto free_qcow_data;
- }
-
- /* handle feature bits */
- qcow_data->incompatible_features = header.incompatible_features;
- qcow_data->compatible_features = header.compatible_features;
- qcow_data->autoclear_features = header.autoclear_features;
-
- if (qcow_data->incompatible_features & QCOW_INCOMPAT_DIRTY) {
- printk(KERN_ERR "xloop_file_fmt_qcow: image contains "
- "inconsistent refcounts");
- ret = -EACCES;
- goto free_qcow_data;
- }
-
- if (qcow_data->incompatible_features & QCOW_INCOMPAT_CORRUPT) {
- printk(KERN_ERR "xloop_file_fmt_qcow: image is corrupt; cannot "
- "be opened read/write");
- ret = -EACCES;
- goto free_qcow_data;
- }
-
- if (qcow_data->incompatible_features & QCOW_INCOMPAT_DATA_FILE) {
- printk(KERN_ERR "xloop_file_fmt_qcow: clusters in the external "
- "data file are not refcounted");
- ret = -EACCES;
- goto free_qcow_data;
- }
-
- /* Check support for various header values */
- if (header.refcount_order > 6) {
- printk(KERN_ERR "xloop_file_fmt_qcow: reference count entry "
- "width too large; may not exceed 64 bits");
- ret = -EINVAL;
- goto free_qcow_data;
- }
- qcow_data->refcount_order = header.refcount_order;
- qcow_data->refcount_bits = 1 << qcow_data->refcount_order;
- qcow_data->refcount_max = U64_C(1) << (qcow_data->refcount_bits - 1);
- qcow_data->refcount_max += qcow_data->refcount_max - 1;
-
- qcow_data->crypt_method_header = header.crypt_method;
- if (qcow_data->crypt_method_header) {
- printk(KERN_ERR "xloop_file_fmt_qcow: encryption support not "
- "available");
- ret = -ENOTSUPP;
- goto free_qcow_data;
- }
-
- /* L2 is always one cluster */
- qcow_data->l2_bits = qcow_data->cluster_bits - 3;
- 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_size = 1 << qcow_data->refcount_block_bits;
- qcow_data->size = header.size;
- qcow_data->csize_shift = (62 - (qcow_data->cluster_bits - 8));
- qcow_data->csize_mask = (1 << (qcow_data->cluster_bits - 8)) - 1;
- 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);
-
- if (header.refcount_table_clusters == 0) {
- printk(KERN_ERR "xloop_file_fmt_qcow: image does not contain a "
- "reference count table");
- 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) {
- goto free_qcow_data;
- }
-
- /* 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) {
- goto free_qcow_data;
- }
-
- /* read the level 1 table */
- ret = __qcow_file_fmt_validate_table(xlo_fmt, header.l1_table_offset,
- header.l1_size, sizeof(u64), 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);
- if (l1_vm_state_index > INT_MAX) {
- printk(KERN_ERR "xloop_file_fmt_qcow: image is too big");
- ret = -EFBIG;
- goto free_qcow_data;
- }
- qcow_data->l1_vm_state_index = l1_vm_state_index;
-
- /* 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) {
- printk(KERN_ERR "xloop_file_fmt_qcow: L1 table is too small");
- ret = -EINVAL;
- goto free_qcow_data;
- }
-
- if (qcow_data->l1_size > 0) {
- qcow_data->l1_table = vzalloc(round_up(qcow_data->l1_size *
- sizeof(u64), 512));
- if (qcow_data->l1_table == NULL) {
- printk(KERN_ERR "xloop_file_fmt_qcow: could not "
- "allocate L1 table");
- ret = -ENOMEM;
- goto free_qcow_data;
- }
- len = kernel_read(xlo->xlo_backing_file, qcow_data->l1_table,
- qcow_data->l1_size * sizeof(u64),
- &qcow_data->l1_table_offset);
- if (len < 0) {
- printk(KERN_ERR "xloop_file_fmt_qcow: could not read L1 "
- "table");
- 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]);
- }
- }
-
- /* Internal snapshots */
- qcow_data->snapshots_offset = header.snapshots_offset;
- qcow_data->nb_snapshots = header.nb_snapshots;
-
- if (qcow_data->nb_snapshots > 0) {
- printk(KERN_ERR "xloop_file_fmt_qcow: snapshots support not "
- "available");
- ret = -ENOTSUPP;
- goto free_l1_table;
- }
-
-
- /* create cache for L2 */
- l2_cache_size = qcow_data->size / (qcow_data->cluster_size / 8);
- l2_cache_entry_size = min(qcow_data->cluster_size, (int)4096);
-
- /* limit the L2 size to maximum QCOW_DEFAULT_L2_CACHE_MAX_SIZE */
- l2_cache_size = min(l2_cache_size, (u64)QCOW_DEFAULT_L2_CACHE_MAX_SIZE);
-
- /* calculate the number of cache tables */
- l2_cache_size /= l2_cache_entry_size;
- if (l2_cache_size < QCOW_MIN_L2_CACHE_SIZE) {
- l2_cache_size = QCOW_MIN_L2_CACHE_SIZE;
- }
-
- if (l2_cache_size > INT_MAX) {
- printk(KERN_ERR "xloop_file_fmt_qcow: L2 cache size too big");
- ret = -EINVAL;
- goto free_l1_table;
- }
-
- qcow_data->l2_slice_size = l2_cache_entry_size / sizeof(u64);
-
- 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;
- }
-
- /* initialize compression support */
- ret = __qcow_file_fmt_compression_init(xlo_fmt);
- if (ret < 0)
- goto free_l2_cache;
-
- /* initialize debugfs entries */
-#ifdef CONFIG_DEBUG_FS
- ret = __qcow_file_fmt_dbgfs_init(xlo_fmt);
- if (ret < 0)
- goto free_l2_cache;
-#endif
-
- return ret;
-
-free_l2_cache:
- xloop_file_fmt_qcow_cache_destroy(xlo_fmt);
-free_l1_table:
- vfree(qcow_data->l1_table);
-free_qcow_data:
- kfree(qcow_data);
- xlo_fmt->private_data = NULL;
- return ret;
-}
-
-static void qcow_file_fmt_exit(struct xloop_file_fmt *xlo_fmt)
-{
- struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
-
-#ifdef CONFIG_DEBUG_FS
- __qcow_file_fmt_dbgfs_exit(xlo_fmt);
-#endif
-
- __qcow_file_fmt_compression_exit(xlo_fmt);
-
- if (qcow_data->l1_table) {
- vfree(qcow_data->l1_table);
- }
-
- 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;
- }
-}
-
-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;
- int ret = 0;
-
- qcow_data->strm->avail_in = src_size;
- qcow_data->strm->next_in = (void *) src;
- qcow_data->strm->avail_out = dest_size;
- qcow_data->strm->next_out = dest;
-
- ret = zlib_inflateInit2(qcow_data->strm, -12);
- if (ret != Z_OK) {
- return -1;
- }
-
- ret = zlib_inflate(qcow_data->strm, Z_FINISH);
- if ((ret != Z_STREAM_END && ret != Z_BUF_ERROR)
- || qcow_data->strm->avail_out != 0) {
- /* We approve Z_BUF_ERROR because we need @dest buffer to be
- * filled, but @src buffer may be processed partly (because in
- * qcow2 we know size of compressed data with precision of one
- * sector) */
- ret = -1;
- } else {
- ret = 0;
- }
- return ret;
-}
-
-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);
- int ret = 0, csize, nb_csectors;
- u64 coffset;
- u8 *in_buf = NULL;
- ssize_t len;
- void *data;
- unsigned long irq_flags;
- 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);
-
-
- if (qcow_data->cmp_last_coffset != coffset) {
- in_buf = vmalloc(csize);
- if (!in_buf) {
- qcow_data->cmp_last_coffset = ULLONG_MAX;
- return -ENOMEM;
- }
- qcow_data->cmp_last_coffset = coffset;
- len = kernel_read(xlo->xlo_backing_file, in_buf, csize, &coffset);
- if (len < 0) {
- qcow_data->cmp_last_coffset = ULLONG_MAX;
- ret = len;
- 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) {
- qcow_data->cmp_last_coffset = ULLONG_MAX;
- ret = -EIO;
- goto out_free_in_buf;
- }
- }
-
- ASSERT(bytes <= bvec->bv_len);
- data = bvec_kmap_irq(bvec, &irq_flags) + bytes_done;
- memcpy(data, qcow_data->cmp_out_buf + offset_in_cluster, bytes);
- flush_dcache_page(bvec->bv_page);
- bvec_kunmap_irq(data, &irq_flags);
-
-out_free_in_buf:
- vfree(in_buf);
-
- return ret;
-}
-
-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);
- int offset_in_cluster;
- int ret;
- unsigned int cur_bytes; /* number of bytes in current iteration */
- u64 bytes;
- u64 cluster_offset = 0;
- u64 bytes_done = 0;
- void *data;
- unsigned long irq_flags;
- ssize_t len;
- loff_t pos_read;
-
- bytes = bvec->bv_len;
-
- while (bytes != 0) {
-
- /* prepare next request */
- cur_bytes = bytes;
-
- ret = xloop_file_fmt_qcow_cluster_get_offset(xlo_fmt, *ppos,
- &cur_bytes, &cluster_offset);
- if (ret < 0) {
- goto fail;
- }
-
- offset_in_cluster = xloop_file_fmt_qcow_offset_into_cluster(
- qcow_data, *ppos);
-
- switch (ret) {
- case QCOW_CLUSTER_UNALLOCATED:
- case QCOW_CLUSTER_ZERO_PLAIN:
- case QCOW_CLUSTER_ZERO_ALLOC:
- data = bvec_kmap_irq(bvec, &irq_flags) + bytes_done;
- memset(data, 0, cur_bytes);
- flush_dcache_page(bvec->bv_page);
- bvec_kunmap_irq(data, &irq_flags);
- break;
-
- case QCOW_CLUSTER_COMPRESSED:
- ret = __qcow_file_fmt_read_compressed(xlo_fmt, bvec,
- cluster_offset, *ppos, cur_bytes, bytes_done);
- if (ret < 0) {
- goto fail;
- }
-
- break;
-
- case QCOW_CLUSTER_NORMAL:
- if ((cluster_offset & 511) != 0) {
- ret = -EIO;
- goto fail;
- }
-
- pos_read = cluster_offset + offset_in_cluster;
-
- data = bvec_kmap_irq(bvec, &irq_flags) + bytes_done;
- len = kernel_read(xlo->xlo_backing_file, data, cur_bytes,
- &pos_read);
- flush_dcache_page(bvec->bv_page);
- bvec_kunmap_irq(data, &irq_flags);
-
- if (len < 0)
- return len;
-
- break;
-
- default:
- ret = -EIO;
- goto fail;
- }
-
- bytes -= cur_bytes;
- *ppos += cur_bytes;
- bytes_done += cur_bytes;
- }
-
- ret = 0;
-
-fail:
- return ret;
-}
-
-static int qcow_file_fmt_read(struct xloop_file_fmt *xlo_fmt,
- struct request *rq)
-{
- struct bio_vec bvec;
- struct req_iterator iter;
- loff_t pos;
- int ret = 0;
-
- pos = __qcow_file_fmt_rq_get_pos(xlo_fmt, rq);
-
- rq_for_each_segment(bvec, rq, iter) {
- ret = __qcow_file_fmt_read_bvec(xlo_fmt, &bvec, &pos);
- if (ret)
- return ret;
-
- cond_resched();
- }
-
- 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)
-{
- struct xloop_file_fmt_qcow_header header;
- loff_t xloopsize;
- int ret;
-
- /* temporary read the QCOW file header of other QCOW image file */
- ret = __qcow_file_fmt_header_read(file, &header);
- if (ret)
- return 0;
-
- /* compute xloopsize in bytes */
- xloopsize = header.size;
- if (offset > 0)
- xloopsize -= offset;
- /* offset is beyond i_size, weird but possible */
- if (xloopsize < 0)
- return 0;
-
- if (sizelimit > 0 && sizelimit < xloopsize)
- xloopsize = sizelimit;
- /*
- * Unfortunately, if we want to do I/O on the device,
- * the number of 512-byte sectors has to fit into a sector_t.
- */
- return xloopsize >> 9;
-}
-
-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,
- .write_zeros = NULL,
- .discard = NULL,
- .flush = NULL,
- .sector_size = qcow_file_fmt_sector_size,
-};
-
-static struct xloop_file_fmt_driver qcow_file_fmt_driver = {
- .name = "QCOW",
- .file_fmt_type = XLO_FILE_FMT_QCOW,
- .ops = &qcow_file_fmt_ops,
- .owner = THIS_MODULE,
-};
-
-static int __init xloop_file_fmt_qcow_init(void)
-{
- printk(KERN_INFO "xloop_file_fmt_qcow: init xloop device QCOW file "
- "format driver");
- return xloop_file_fmt_register_driver(&qcow_file_fmt_driver);
-}
-
-static void __exit xloop_file_fmt_qcow_exit(void)
-{
- printk(KERN_INFO "xloop_file_fmt_qcow: exit xloop device QCOW file "
- "format driver");
- xloop_file_fmt_unregister_driver(&qcow_file_fmt_driver);
-}
-
-module_init(xloop_file_fmt_qcow_init);
-module_exit(xloop_file_fmt_qcow_exit);
-
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Manuel Bentele ");
-MODULE_DESCRIPTION("xloop device QCOW file format driver");
-MODULE_SOFTDEP("pre: xloop");
diff --git a/loop_file_fmt_qcow_main.h b/loop_file_fmt_qcow_main.h
deleted file mode 100644
index 54b94c3..0000000
--- a/loop_file_fmt_qcow_main.h
+++ /dev/null
@@ -1,419 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * xloop_file_fmt_qcow.h
- *
- * QCOW file format driver for the xloop device module.
- *
- * Ported QCOW2 implementation of the QEMU project (GPL-2.0):
- * Declarations for the QCOW2 file format.
- *
- * The copyright (C) 2004-2006 of the original code is owned by Fabrice Bellard.
- *
- * Copyright (C) 2019 Manuel Bentele
- */
-
-#ifndef _LINUX_XLOOP_FILE_FMT_QCOW_H
-#define _LINUX_XLOOP_FILE_FMT_QCOW_H
-
-#include
-#include
-#include
-#include
-
-#ifdef CONFIG_DEBUG_FS
-#include
-#endif
-
-#include "loop_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)
-#else
-#define ASSERT(x) do { } while (0)
-#endif
-
-#define KiB (1024)
-#define MiB (1024 * 1024)
-
-#define QCOW_MAGIC (('Q' << 24) | ('F' << 16) | ('I' << 8) | 0xfb)
-
-#define QCOW_CRYPT_NONE 0
-#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
- * 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). */
-#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) */
-#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) */
-#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 */
-#define QCOW_MAX_SNAPSHOTS_SIZE (1024 * QCOW_MAX_SNAPSHOTS)
-
-/* Bitmap header extension constraints */
-#define QCOW_MAX_BITMAPS 65535
-#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)
-/* indicate that the cluster is compressed (they never have the copied flag) */
-#define QCOW_OFLAG_COMPRESSED (1ULL << 62)
-/* The cluster reads as all zeros */
-#define QCOW_OFLAG_ZERO (1ULL << 0)
-
-#define QCOW_MIN_CLUSTER_BITS 9
-#define QCOW_MAX_CLUSTER_BITS 21
-
-/* Defined in the qcow2 spec (compressed cluster descriptor) */
-#define QCOW_COMPRESSED_SECTOR_SIZE 512U
-#define QCOW_COMPRESSED_SECTOR_MASK (~(QCOW_COMPRESSED_SECTOR_SIZE - 1))
-
-/* Must be at least 2 to cover COW */
-#define QCOW_MIN_L2_CACHE_SIZE 2 /* cache entries */
-
-/* Must be at least 4 to cover all cases of refcount table growth */
-#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_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 */
-#define QCOW_OFFSET_BUF_LEN 32
-#define QCOW_CLUSTER_BUF_LEN 128
-
-struct xloop_file_fmt_qcow_header {
- u32 magic;
- u32 version;
- u64 backing_file_offset;
- u32 backing_file_size;
- u32 cluster_bits;
- u64 size; /* in bytes */
- u32 crypt_method;
- u32 l1_size;
- u64 l1_table_offset;
- u64 refcount_table_offset;
- u32 refcount_table_clusters;
- u32 nb_snapshots;
- u64 snapshots_offset;
-
- /* The following fields are only valid for version >= 3 */
- u64 incompatible_features;
- u64 compatible_features;
- u64 autoclear_features;
-
- u32 refcount_order;
- u32 header_length;
-} __attribute__((packed));
-
-struct xloop_file_fmt_qcow_snapshot_header {
- /* header is 8 byte aligned */
- u64 l1_table_offset;
-
- u32 l1_size;
- u16 id_str_size;
- u16 name_size;
-
- u32 date_sec;
- u32 date_nsec;
-
- u64 vm_clock_nsec;
-
- u32 vm_state_size;
- /* for extension */
- u32 extra_data_size;
- /* extra data follows */
- /* id_str follows */
- /* name follows */
-} __attribute__((packed));
-
-enum {
- 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 = 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_MASK = QCOW_INCOMPAT_DIRTY
- | QCOW_INCOMPAT_CORRUPT
- | QCOW_INCOMPAT_DATA_FILE,
-};
-
-/* compatible feature bits */
-enum {
- QCOW_COMPAT_LAZY_REFCOUNTS_BITNR = 0,
- QCOW_COMPAT_LAZY_REFCOUNTS = 1 << QCOW_COMPAT_LAZY_REFCOUNTS_BITNR,
-
- QCOW_COMPAT_FEAT_MASK = QCOW_COMPAT_LAZY_REFCOUNTS,
-};
-
-/* autoclear feature bits */
-enum {
- QCOW_AUTOCLEAR_BITMAPS_BITNR = 0,
- QCOW_AUTOCLEAR_DATA_FILE_RAW_BITNR = 1,
- 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,
-};
-
-struct xloop_file_fmt_qcow_data {
- u64 size;
- int cluster_bits;
- int cluster_size;
- int cluster_sectors;
- int l2_slice_size;
- 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;
-
- 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;
-
- 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;
-
- struct z_stream_s *strm;
- u8 *cmp_out_buf;
- u64 cmp_last_coffset;
-
- /* 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];
- 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;
-#endif
-};
-
-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;
-
- /** Number of bytes to copy */
- unsigned nb_bytes;
-};
-
-enum xloop_file_fmt_qcow_cluster_type {
- QCOW_CLUSTER_UNALLOCATED,
- QCOW_CLUSTER_ZERO_PLAIN,
- QCOW_CLUSTER_ZERO_ALLOC,
- QCOW_CLUSTER_NORMAL,
- QCOW_CLUSTER_COMPRESSED,
-};
-
-enum xloop_file_fmt_qcow_metadata_overlap {
- QCOW_OL_MAIN_HEADER_BITNR = 0,
- QCOW_OL_ACTIVE_L1_BITNR = 1,
- QCOW_OL_ACTIVE_L2_BITNR = 2,
- QCOW_OL_REFCOUNT_TABLE_BITNR = 3,
- QCOW_OL_REFCOUNT_BLOCK_BITNR = 4,
- QCOW_OL_SNAPSHOT_TABLE_BITNR = 5,
- QCOW_OL_INACTIVE_L1_BITNR = 6,
- QCOW_OL_INACTIVE_L2_BITNR = 7,
- QCOW_OL_BITMAP_DIRECTORY_BITNR = 8,
-
- 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),
-};
-
-/* 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)
-
-/* 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)
-
-/* Perform all overlap checks */
-#define QCOW_OL_ALL \
- (QCOW_OL_CACHED | QCOW_OL_INACTIVE_L2)
-
-#define L1E_OFFSET_MASK 0x00fffffffffffe00ULL
-#define L2E_OFFSET_MASK 0x00fffffffffffe00ULL
-#define L2E_COMPRESSED_OFFSET_SIZE_MASK 0x3fffffffffffffffULL
-
-#define REFT_OFFSET_MASK 0xfffffffffffffe00ULL
-
-#define INV_OFFSET (-1ULL)
-
-static inline bool xloop_file_fmt_qcow_has_data_file(
- struct xloop_file_fmt *xlo_fmt)
-{
- /* 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 *xlo_fmt)
-{
- struct xloop_file_fmt_qcow_data *qcow_data = xlo_fmt->private_data;
- 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)
-{
- 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)
-{
- return offset & (qcow_data->cluster_size - 1);
-}
-
-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;
-}
-
-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)
-{
- 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)
-{
- 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)
-{
- return (offset >> qcow_data->cluster_bits) &
- (qcow_data->l2_slice_size - 1);
-}
-
-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);
-}
-
-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)
-{
- if (l2_entry & QCOW_OFLAG_COMPRESSED) {
- return QCOW_CLUSTER_COMPRESSED;
- } else if (l2_entry & QCOW_OFLAG_ZERO) {
- if (l2_entry & L2E_OFFSET_MASK) {
- return QCOW_CLUSTER_ZERO_ALLOC;
- }
- return QCOW_CLUSTER_ZERO_PLAIN;
- } else if (!(l2_entry & L2E_OFFSET_MASK)) {
- /* 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(xlo_fmt) &&
- (l2_entry & QCOW_OFLAG_COPIED)) {
- return QCOW_CLUSTER_NORMAL;
- } else {
- return QCOW_CLUSTER_UNALLOCATED;
- }
- } else {
- return QCOW_CLUSTER_NORMAL;
- }
-}
-
-#endif
diff --git a/loop_file_fmt_raw.c b/loop_file_fmt_raw.c
deleted file mode 100644
index 11cc8cd..0000000
--- a/loop_file_fmt_raw.c
+++ /dev/null
@@ -1,465 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * xloop_file_fmt_raw.c
- *
- * RAW file format driver for the xloop device module.
- *
- * Copyright (C) 2019 Manuel Bentele
- */
-
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-
-#include "loop_file_fmt.h"
-
-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;
-}
-
-/* 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)
-{
- int ret;
-
- ret = xlo->transfer(xlo, cmd, rpage, roffs, lpage, loffs, size, rblock);
- if (likely(!ret))
- return 0;
-
- printk_ratelimited(KERN_ERR
- "xloop_file_fmt_raw: 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)
-{
- struct bio_vec bvec, b;
- struct req_iterator iter;
- struct iov_iter i;
- struct page *page;
- ssize_t len;
- int ret = 0;
-
- page = alloc_page(GFP_NOIO);
- if (unlikely(!page))
- return -ENOMEM;
-
- rq_for_each_segment(bvec, rq, iter) {
- loff_t offset = pos;
-
- b.bv_page = page;
- b.bv_offset = 0;
- b.bv_len = bvec.bv_len;
-
- iov_iter_bvec(&i, READ, &b, 1, b.bv_len);
- len = vfs_iter_read(xlo->xlo_backing_file, &i, &pos, 0);
- if (len < 0) {
- ret = len;
- goto out_free_page;
- }
-
- 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;
-
- flush_dcache_page(bvec.bv_page);
-
- if (len != bvec.bv_len) {
- struct bio *bio;
-
- __rq_for_each_bio(bio, rq)
- zero_fill_bio(bio);
- break;
- }
- }
-
- ret = 0;
-out_free_page:
- __free_page(page);
- return ret;
-}
-
-static int raw_file_fmt_read(struct xloop_file_fmt *xlo_fmt,
- struct request *rq)
-{
- struct bio_vec bvec;
- struct req_iterator iter;
- struct iov_iter i;
- ssize_t len;
- struct xloop_device *xlo;
- loff_t pos;
-
- xlo = xloop_file_fmt_get_xlo(xlo_fmt);
- pos = __raw_file_fmt_rq_get_pos(xlo_fmt, rq);
-
- if (xlo->transfer)
- return __raw_file_fmt_read_transfer(xlo, rq, pos);
-
- rq_for_each_segment(bvec, rq, iter) {
- iov_iter_bvec(&i, READ, &bvec, 1, bvec.bv_len);
- len = vfs_iter_read(xlo->xlo_backing_file, &i, &pos, 0);
- if (len < 0)
- return len;
-
- flush_dcache_page(bvec.bv_page);
-
- if (len != bvec.bv_len) {
- struct bio *bio;
-
- __rq_for_each_bio(bio, rq)
- zero_fill_bio(bio);
- break;
- }
- cond_resched();
- }
-
- return 0;
-}
-
-static void __raw_file_fmt_rw_aio_do_completion(struct xloop_cmd *cmd)
-{
- struct request *rq = blk_mq_rq_from_pdu(cmd);
-
- if (!atomic_dec_and_test(&cmd->ref))
- return;
- kfree(cmd->bvec);
- cmd->bvec = NULL;
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 9, 0)
- if (likely(!blk_should_fake_timeout(rq->q)))
- blk_mq_complete_request(rq);
-#else
- blk_mq_complete_request(rq);
-#endif
-}
-
-static void __raw_file_fmt_rw_aio_complete(struct kiocb *iocb, long ret, long ret2)
-{
- struct xloop_cmd *cmd = container_of(iocb, struct xloop_cmd, iocb);
-
- if (cmd->css)
- css_put(cmd->css);
- cmd->ret = ret;
- __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)
-{
- struct iov_iter iter;
- struct req_iterator rq_iter;
- struct bio_vec *bvec;
- struct request *rq = blk_mq_rq_from_pdu(cmd);
- struct bio *bio = rq->bio;
- struct file *file = xlo->xlo_backing_file;
- struct bio_vec tmp;
- unsigned int offset;
- int nr_bvec = 0;
- int ret;
-
- rq_for_each_bvec(tmp, rq, rq_iter)
- nr_bvec++;
-
- if (rq->bio != rq->biotail) {
-
- bvec = kmalloc_array(nr_bvec, sizeof(struct bio_vec),
- GFP_NOIO);
- if (!bvec)
- return -EIO;
- cmd->bvec = bvec;
-
- /*
- * The bios of the request may be started from the middle of
- * the 'bvec' because of bio splitting, so we can't directly
- * copy bio->bi_iov_vec to new bvec. The rq_for_each_bvec
- * API will take care of all details for us.
- */
- rq_for_each_bvec(tmp, rq, rq_iter) {
- *bvec = tmp;
- bvec++;
- }
- bvec = cmd->bvec;
- offset = 0;
- } else {
- /*
- * Same here, this bio may be started from the middle of the
- * 'bvec' because of bio splitting, so offset from the bvec
- * must be passed to iov iterator
- */
- offset = bio->bi_iter.bi_bvec_done;
- bvec = __bvec_iter_bvec(bio->bi_io_vec, bio->bi_iter);
- }
- atomic_set(&cmd->ref, 2);
-
- iov_iter_bvec(&iter, rw, bvec, nr_bvec, blk_rq_bytes(rq));
- iter.iov_offset = offset;
-
- cmd->iocb.ki_pos = pos;
- cmd->iocb.ki_filp = file;
- cmd->iocb.ki_complete = __raw_file_fmt_rw_aio_complete;
- cmd->iocb.ki_flags = IOCB_DIRECT;
- cmd->iocb.ki_ioprio = IOPRIO_PRIO_VALUE(IOPRIO_CLASS_NONE, 0);
- if (cmd->css)
- kthread_associate_blkcg(cmd->css);
-
- if (rw == WRITE)
- ret = call_write_iter(file, &cmd->iocb, &iter);
- else
- ret = call_read_iter(file, &cmd->iocb, &iter);
-
- __raw_file_fmt_rw_aio_do_completion(cmd);
- kthread_associate_blkcg(NULL);
-
- if (ret != -EIOCBQUEUED)
- cmd->iocb.ki_complete(&cmd->iocb, ret, 0);
- return 0;
-}
-
-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);
- loff_t pos = __raw_file_fmt_rq_get_pos(xlo_fmt, rq);
-
- 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)
-{
- struct iov_iter i;
- ssize_t bw;
-
- iov_iter_bvec(&i, WRITE, bvec, 1, bvec->bv_len);
-
- file_start_write(file);
- bw = vfs_iter_write(file, &i, ppos, 0);
- file_end_write(file);
-
- if (likely(bw == bvec->bv_len))
- return 0;
-
- printk_ratelimited(KERN_ERR
- "xloop_file_fmt_raw: Write error at byte offset %llu, length "
- "%i.\n", (unsigned long long)*ppos, bvec->bv_len);
- if (bw >= 0)
- bw = -EIO;
- return bw;
-}
-
-/*
- * This is the slow, transforming version that needs to double buffer the
- * 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)
-{
-struct bio_vec bvec, b;
- struct req_iterator iter;
- struct page *page;
- int ret = 0;
-
- page = alloc_page(GFP_NOIO);
- if (unlikely(!page))
- 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);
- if (unlikely(ret))
- break;
-
- b.bv_page = page;
- b.bv_offset = 0;
- b.bv_len = bvec.bv_len;
- ret = __raw_file_fmt_write_bvec(xlo->xlo_backing_file, &b, &pos);
- if (ret < 0)
- break;
- }
-
- __free_page(page);
- return ret;
-}
-
-static int raw_file_fmt_write(struct xloop_file_fmt *xlo_fmt,
- struct request *rq)
-{
- struct bio_vec bvec;
- struct req_iterator iter;
- int ret = 0;
- struct xloop_device *xlo;
- loff_t pos;
-
- xlo = xloop_file_fmt_get_xlo(xlo_fmt);
- pos = __raw_file_fmt_rq_get_pos(xlo_fmt, rq);
-
- if (xlo->transfer)
- return __raw_file_fmt_write_transfer(xlo, rq, pos);
-
- rq_for_each_segment(bvec, rq, iter) {
- ret = __raw_file_fmt_write_bvec(xlo->xlo_backing_file, &bvec, &pos);
- if (ret < 0)
- break;
- cond_resched();
- }
-
- return ret;
-}
-
-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);
- loff_t pos = __raw_file_fmt_rq_get_pos(xlo_fmt, rq);
-
- 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)
-{
- /*
- * We use fallocate to manipulate the space mappings used by the image
- * a.k.a. discard/zerorange. However we do not support this if
- * encryption is enabled, because it may give an attacker useful
- * information.
- */
- struct file *file = xlo->xlo_backing_file;
- struct request_queue *q = xlo->xlo_queue;
- int ret;
-
- mode |= FALLOC_FL_KEEP_SIZE;
-
- if (!blk_queue_discard(q)) {
- ret = -EOPNOTSUPP;
- goto out;
- }
-
- ret = file->f_op->fallocate(file, mode, pos, blk_rq_bytes(rq));
- if (unlikely(ret && ret != -EINVAL && ret != -EOPNOTSUPP))
- ret = -EIO;
-out:
- return ret;
-}
-
-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);
-
- /*
- * If the caller doesn't want deallocation, call zeroout to
- * 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);
-}
-
-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);
-
- return __raw_file_fmt_fallocate(xlo, rq, pos, FALLOC_FL_PUNCH_HOLE);
-}
-
-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)
-{
- loff_t xloopsize;
-
- /* Compute xloopsize in bytes */
- xloopsize = i_size_read(file->f_mapping->host);
- if (offset > 0)
- xloopsize -= offset;
- /* offset is beyond i_size, weird but possible */
- if (xloopsize < 0)
- return 0;
-
- if (sizelimit > 0 && sizelimit < xloopsize)
- xloopsize = sizelimit;
- /*
- * Unfortunately, if we want to do I/O on the device,
- * the number of 512-byte sectors has to fit into a sector_t.
- */
- return xloopsize >> 9;
-}
-
-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,
- .write_zeros = raw_file_fmt_write_zeros,
- .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",
- .file_fmt_type = XLO_FILE_FMT_RAW,
- .ops = &raw_file_fmt_ops,
- .owner = THIS_MODULE,
-};
-
-static int __init xloop_file_fmt_raw_init(void)
-{
- printk(KERN_INFO "xloop_file_fmt_raw: init xloop device RAW file format "
- "driver");
- return xloop_file_fmt_register_driver(&raw_file_fmt_driver);
-}
-
-static void __exit xloop_file_fmt_raw_exit(void)
-{
- printk(KERN_INFO "xloop_file_fmt_raw: exit xloop device RAW file format "
- "driver");
- xloop_file_fmt_unregister_driver(&raw_file_fmt_driver);
-}
-
-module_init(xloop_file_fmt_raw_init);
-module_exit(xloop_file_fmt_raw_exit);
-
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Manuel Bentele ");
-MODULE_DESCRIPTION("xloop device RAW file format driver");
-MODULE_SOFTDEP("pre: xloop");
diff --git a/loop_main.c b/loop_main.c
deleted file mode 100644
index 9cd9c99..0000000
--- a/loop_main.c
+++ /dev/null
@@ -1,2221 +0,0 @@
-/*
- * loop_main.c
- *
- * Written by Theodore Ts'o, 3/29/93
- *
- * Copyright 1993 by Theodore Ts'o. Redistribution of this file is
- * permitted under the GNU General Public License.
- *
- * DES encryption plus some minor changes by Werner Almesberger, 30-MAY-1993
- * more DES encryption plus IDEA encryption by Nicholas J. Leon, June 20, 1996
- *
- * Modularized and updated for 1.1.16 kernel - Mitch Dsouza 28th May 1994
- * Adapted for 1.3.59 kernel - Andries Brouwer, 1 Feb 1996
- *
- * Fixed do_xloop_request() re-entrancy - Vincent.Renardias@waw.com Mar 20, 1997
- *
- * Added devfs support - Richard Gooch 16-Jan-1998
- *
- * Handle sparse backing files correctly - Kenn Humborg, Jun 28, 1998
- *
- * Loadable modules and other fixes by AK, 1998
- *
- * Make real block number available to downstream transfer functions, enables
- * CBC (and relatives) mode encryption requiring unique IVs per data block.
- * Reed H. Petty, rhp@draper.net
- *
- * Maximum number of xloop devices now dynamic via max_xloop module parameter.
- * Russell Kroll 19990701
- *
- * Maximum number of xloop devices when compiled-in now selectable by passing
- * max_xloop=<1-255> to the kernel on boot.
- * Erik I. Bolsø, , Oct 31, 1999
- *
- * Completely rewrite request handling to be make_request_fn style and
- * non blocking, pushing work to a helper thread. Lots of fixes from
- * Al Viro too.
- * Jens Axboe , Nov 2000
- *
- * Support up to 256 xloop devices
- * Heinz Mauelshagen , Feb 2002
- *
- * Support for falling back on the write file operation when the address space
- * operations write_begin is not available on the backing filesystem.
- * Anton Altaparmakov, 16 Feb 2005
- *
- * Support for using file formats.
- * Manuel Bentele , 2019
- *
- * Still To Fix:
- * - Advisory locking is ignored here.
- * - Should use an own CAP_* category instead of CAP_SYS_ADMIN
- *
- */
-
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#ifdef CONFIG_DEBUG_FS
-#include
-#endif
-
-#include "loop_file_fmt.h"
-#include "loop_main.h"
-
-#include
-
-static DEFINE_IDR(xloop_index_idr);
-static DEFINE_MUTEX(xloop_ctl_mutex);
-
-static int max_part;
-static int part_shift;
-
-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)
-{
- char *raw_buf = kmap_atomic(raw_page) + raw_off;
- char *xloop_buf = kmap_atomic(xloop_page) + xloop_off;
- char *in, *out, *key;
- int i, keysize;
-
- if (cmd == READ) {
- in = raw_buf;
- out = xloop_buf;
- } else {
- in = xloop_buf;
- out = raw_buf;
- }
-
- key = xlo->xlo_encrypt_key;
- keysize = xlo->xlo_encrypt_key_size;
- for (i = 0; i < size; i++)
- *out++ = *in++ ^ key[(i & 511) % keysize];
-
- kunmap_atomic(xloop_buf);
- kunmap_atomic(raw_buf);
- cond_resched();
- return 0;
-}
-
-static int xor_init(struct xloop_device *xlo, const struct xloop_info64 *info)
-{
- if (unlikely(info->xlo_encrypt_key_size <= 0))
- return -EINVAL;
- return 0;
-}
-
-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
-};
-
-/* 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 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);
-}
-
-static void __xloop_update_dio(struct xloop_device *xlo, bool dio)
-{
- struct file *file = xlo->xlo_backing_file;
- struct address_space *mapping = file->f_mapping;
- struct inode *inode = mapping->host;
- unsigned short sb_bsize = 0;
- unsigned dio_align = 0;
- bool use_dio;
-
- if (inode->i_sb->s_bdev) {
- sb_bsize = bdev_logical_block_size(inode->i_sb->s_bdev);
- dio_align = sb_bsize - 1;
- }
-
- /*
- * We support direct I/O only if xlo_offset is aligned with the
- * logical I/O size of backing device, and the logical block
- * size of xloop is bigger than the backing device's and the xloop
- * needn't transform transfer.
- *
- * TODO: the above condition may be loosed in the future, and
- * direct I/O may be switched runtime at that time because most
- * 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)
- use_dio = true;
- else
- use_dio = false;
- } else {
- use_dio = false;
- }
-
- if (xlo->use_dio == use_dio)
- return;
-
- /* flush dirty pages before changing direct IO */
- xloop_file_fmt_flush(xlo->xlo_fmt);
-
- /*
- * The flag of XLO_FLAGS_DIRECT_IO is handled similarly with
- * XLO_FLAGS_READ_ONLY, both are set from kernel, and losetup
- * will get updated by ioctl(XLOOP_GET_STATUS)
- */
- if (xlo->xlo_state == Xlo_bound)
- blk_mq_freeze_queue(xlo->xlo_queue);
- xlo->use_dio = use_dio;
- if (use_dio) {
- blk_queue_flag_clear(QUEUE_FLAG_NOMERGES, xlo->xlo_queue);
- xlo->xlo_flags |= XLO_FLAGS_DIRECT_IO;
- } else {
- blk_queue_flag_set(QUEUE_FLAG_NOMERGES, xlo->xlo_queue);
- xlo->xlo_flags &= ~XLO_FLAGS_DIRECT_IO;
- }
- if (xlo->xlo_state == Xlo_bound)
- blk_mq_unfreeze_queue(xlo->xlo_queue);
-}
-
-/**
- * xloop_validate_block_size() - validates the passed in block size
- * @bsize: size to validate
- */
-static int
-xloop_validate_block_size(unsigned short bsize)
-{
- if (bsize < 512 || bsize > PAGE_SIZE || !is_power_of_2(bsize))
- return -EINVAL;
-
- return 0;
-}
-
-/**
- * xloop_set_size() - sets device size and notifies userspace
- * @xlo: struct xloop_device to set the size for
- * @size: new size of the xloop device
- *
- * Callers must validate that the size passed into this function fits into
- * a sector_t, eg using xloop_validate_size()
- */
-static void xloop_set_size(struct xloop_device *xlo, loff_t size)
-{
- struct block_device *bdev = xlo->xlo_device;
-#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 7, 0)
- sector_t capacity;
-#endif
-
- bd_set_size(bdev, size << SECTOR_SHIFT);
-
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 7, 0)
- 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);
- }
-#endif
-}
-
-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->ret < 0)
- ret = errno_to_blk_status(cmd->ret);
- goto end_io;
- }
-
- /*
- * Short READ - if we got some data, advance our request and
- * retry it. If we got no data, end the rest with EIO.
- */
- if (cmd->ret) {
- blk_update_request(rq, BLK_STS_OK, cmd->ret);
- cmd->ret = 0;
- blk_mq_requeue_request(rq, true);
- } else {
- if (cmd->use_aio) {
- struct bio *bio = rq->bio;
-
- while (bio) {
- zero_fill_bio(bio);
- bio = bio->bi_next;
- }
- }
- ret = BLK_STS_IOERR;
-end_io:
- blk_mq_end_request(rq, ret);
- }
-}
-
-static int do_req_filebacked(struct xloop_device *xlo, struct request *rq)
-{
- struct xloop_cmd *cmd = blk_mq_rq_to_pdu(rq);
-
- /*
- * xlo_write_simple and xlo_read_simple should have been covered
- * by io submit style function like xlo_rw_aio(), one blocker
- * is that xlo_read_simple() need to call flush_dcache_page after
- * the page is written from kernel, and it isn't easy to handle
- * this in io submit style function which submits all segments
- * of the req at one time. And direct read IO doesn't need to
- * run flush_dcache_page().
- */
- switch (req_op(rq)) {
- case REQ_OP_FLUSH:
- return xloop_file_fmt_flush(xlo->xlo_fmt);
- case REQ_OP_WRITE_ZEROES:
- return xloop_file_fmt_write_zeros(xlo->xlo_fmt, rq);
- case REQ_OP_DISCARD:
- return xloop_file_fmt_discard(xlo->xlo_fmt, rq);
- case REQ_OP_WRITE:
- if (cmd->use_aio)
- return xloop_file_fmt_write_aio(xlo->xlo_fmt, rq);
- else
- return xloop_file_fmt_write(xlo->xlo_fmt, rq);
- case REQ_OP_READ:
- if (cmd->use_aio)
- return xloop_file_fmt_read_aio(xlo->xlo_fmt, rq);
- else
- return xloop_file_fmt_read(xlo->xlo_fmt, rq);
- default:
- WARN_ON_ONCE(1);
- return -EIO;
- }
-}
-
-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);
-}
-
-static void xloop_reread_partitions(struct xloop_device *xlo,
- struct block_device *bdev)
-{
- int rc;
-
- mutex_lock(&bdev->bd_mutex);
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 5, 0)
- rc = bdev_disk_changed(bdev, false);
-#else
- rc = blkdev_reread_part(bdev);
-#endif
- mutex_unlock(&bdev->bd_mutex);
- if (rc)
- pr_warn("%s: partition scan of xloop%d (%s) failed (rc=%d)\n",
- __func__, xlo->xlo_number, xlo->xlo_file_name, rc);
-}
-
-static inline int is_xloop_device(struct file *file)
-{
- struct inode *i = file->f_mapping->host;
-
- return i && S_ISBLK(i->i_mode) && MAJOR(i->i_rdev) == LOOP_MAJOR;
-}
-
-static int xloop_validate_file(struct file *file, struct block_device *bdev)
-{
- struct inode *inode = file->f_mapping->host;
- struct file *f = file;
-
- /* Avoid recursion */
- while (is_xloop_device(f)) {
- struct xloop_device *l;
-
- if (f->f_mapping->host->i_bdev == bdev)
- return -EBADF;
-
- l = f->f_mapping->host->i_bdev->bd_disk->private_data;
- if (l->xlo_state != Xlo_bound) {
- return -EINVAL;
- }
- f = l->xlo_backing_file;
- }
- if (!S_ISREG(inode->i_mode) && !S_ISBLK(inode->i_mode))
- return -EINVAL;
- return 0;
-}
-
-/*
- * xloop_change_fd switched the backing store of a xloopback device to
- * a new file. This is useful for operating system installers to free up
- * the original file and in High Availability environments to switch to
- * an alternative location for the content in case of server meltdown.
- * 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)
-{
- struct file *file = NULL, *old_file;
- int error;
- bool partscan;
-
- error = mutex_lock_killable(&xloop_ctl_mutex);
- if (error)
- return error;
- error = -ENXIO;
- if (xlo->xlo_state != Xlo_bound)
- goto out_err;
-
- /* the xloop device has to be read-only */
- error = -EINVAL;
- if (!(xlo->xlo_flags & XLO_FLAGS_READ_ONLY))
- goto out_err;
-
- error = -EBADF;
- file = fget(arg);
- if (!file)
- goto out_err;
-
- error = xloop_validate_file(file, bdev);
- if (error)
- goto out_err;
-
- old_file = xlo->xlo_backing_file;
-
- error = -EINVAL;
-
- /* size of the new backing store needs to be the same */
- if (get_xloop_size(xlo, file) != get_xloop_size(xlo, old_file))
- goto out_err;
-
- /* and ... switch */
- blk_mq_freeze_queue(xlo->xlo_queue);
- 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));
- xloop_update_dio(xlo);
- blk_mq_unfreeze_queue(xlo->xlo_queue);
- partscan = xlo->xlo_flags & XLO_FLAGS_PARTSCAN;
- mutex_unlock(&xloop_ctl_mutex);
- /*
- * We must drop file reference outside of xloop_ctl_mutex as dropping
- * the file ref can take bd_mutex which creates circular locking
- * dependency.
- */
- fput(old_file);
- if (partscan)
- xloop_reread_partitions(xlo, bdev);
- return 0;
-
-out_err:
- mutex_unlock(&xloop_ctl_mutex);
- if (file)
- fput(file);
- return error;
-}
-
-/* xloop sysfs attributes */
-
-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;
-
- 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);
-
-static ssize_t xloop_attr_backing_file_show(struct xloop_device *xlo, char *buf)
-{
- ssize_t ret;
- char *p = NULL;
-
- spin_lock_irq(&xlo->xlo_lock);
- if (xlo->xlo_backing_file)
- p = file_path(xlo->xlo_backing_file, buf, PAGE_SIZE - 1);
- spin_unlock_irq(&xlo->xlo_lock);
-
- if (IS_ERR_OR_NULL(p))
- ret = PTR_ERR(p);
- else {
- ret = strlen(p);
- memmove(buf, p, ret);
- buf[ret++] = '\n';
- buf[ret] = 0;
- }
-
- return ret;
-}
-
-static ssize_t xloop_attr_file_fmt_type_show(struct xloop_device *xlo,
- char *buf)
-{
- ssize_t len = 0;
-
- len = xloop_file_fmt_print_type(xlo->xlo_fmt->file_fmt_type, buf);
- len += sprintf(buf + len, "\n");
-
- return len;
-}
-
-static ssize_t xloop_attr_offset_show(struct xloop_device *xlo, char *buf)
-{
- return sprintf(buf, "%llu\n", (unsigned long long)xlo->xlo_offset);
-}
-
-static ssize_t xloop_attr_sizelimit_show(struct xloop_device *xlo, char *buf)
-{
- return sprintf(buf, "%llu\n", (unsigned long long)xlo->xlo_sizelimit);
-}
-
-static ssize_t xloop_attr_autoclear_show(struct xloop_device *xlo, char *buf)
-{
- int autoclear = (xlo->xlo_flags & XLO_FLAGS_AUTOCLEAR);
-
- return sprintf(buf, "%s\n", autoclear ? "1" : "0");
-}
-
-static ssize_t xloop_attr_partscan_show(struct xloop_device *xlo, char *buf)
-{
- int partscan = (xlo->xlo_flags & XLO_FLAGS_PARTSCAN);
-
- return sprintf(buf, "%s\n", partscan ? "1" : "0");
-}
-
-static ssize_t xloop_attr_dio_show(struct xloop_device *xlo, char *buf)
-{
- int dio = (xlo->xlo_flags & XLO_FLAGS_DIRECT_IO);
-
- return sprintf(buf, "%s\n", dio ? "1" : "0");
-}
-
-XLOOP_ATTR_RO(backing_file);
-XLOOP_ATTR_RO(file_fmt_type);
-XLOOP_ATTR_RO(offset);
-XLOOP_ATTR_RO(sizelimit);
-XLOOP_ATTR_RO(autoclear);
-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,
-};
-
-static struct attribute_group xloop_attribute_group = {
- .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);
-}
-
-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);
-}
-
-static void xloop_config_discard(struct xloop_device *xlo)
-{
- struct file *file = xlo->xlo_backing_file;
- struct inode *inode = file->f_mapping->host;
- struct request_queue *q = xlo->xlo_queue;
- u32 granularity, max_discard_sectors;
-
- /*
- * If the backing device is a block device, mirror its zeroing
- * capability. Set the discard sectors to the block device's zeroing
- * capabilities because xloop discards result in blkdev_issue_zeroout(),
- * not blkdev_issue_discard(). This maintains consistent behavior with
- * file-backed xloop devices: discarded regions read back as zero.
- */
- if (S_ISBLK(inode->i_mode) && !xlo->xlo_encrypt_key_size) {
- struct request_queue *backingq;
-
- 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);
-
- /*
- * We use punch hole to reclaim the free space used by the
- * image a.k.a. discard. However we do not support discard if
- * encryption is enabled, because it may give an attacker
- * useful information.
- */
- } else if (!file->f_op->fallocate || xlo->xlo_encrypt_key_size) {
- max_discard_sectors = 0;
- granularity = 0;
-
- } else {
- max_discard_sectors = UINT_MAX >> 9;
- granularity = inode->i_sb->s_blocksize;
- }
-
- if (max_discard_sectors) {
- q->limits.discard_granularity = granularity;
- blk_queue_max_discard_sectors(q, max_discard_sectors);
- blk_queue_max_write_zeroes_sectors(q, max_discard_sectors);
- blk_queue_flag_set(QUEUE_FLAG_DISCARD, q);
- } else {
- q->limits.discard_granularity = 0;
- blk_queue_max_discard_sectors(q, 0);
- blk_queue_max_write_zeroes_sectors(q, 0);
- blk_queue_flag_clear(QUEUE_FLAG_DISCARD, q);
- }
- q->limits.discard_alignment = 0;
-}
-
-static void xloop_unprepare_queue(struct xloop_device *xlo)
-{
- kthread_flush_worker(&xlo->worker);
- kthread_stop(xlo->worker_task);
-}
-
-static int xloop_kthread_worker_fn(void *worker_ptr)
-{
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 8, 0)
- current->flags |= PF_LOCAL_THROTTLE | PF_MEMALLOC_NOIO;
-#else
- current->flags |= PF_LESS_THROTTLE | PF_MEMALLOC_NOIO;
-#endif
- return kthread_worker_fn(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);
- if (IS_ERR(xlo->worker_task))
- return -ENOMEM;
- set_user_nice(xlo->worker_task, MIN_NICE);
- return 0;
-}
-
-static void xloop_update_rotational(struct xloop_device *xlo)
-{
- struct file *file = xlo->xlo_backing_file;
- struct inode *file_inode = file->f_mapping->host;
- struct block_device *file_bdev = file_inode->i_sb->s_bdev;
- struct request_queue *q = xlo->xlo_queue;
- bool nonrot = true;
-
- /* not all filesystems (e.g. tmpfs) have a sb->s_bdev */
- if (file_bdev)
- nonrot = blk_queue_nonrot(bdev_get_queue(file_bdev));
-
- if (nonrot)
- blk_queue_flag_set(QUEUE_FLAG_NONROT, q);
- else
- blk_queue_flag_clear(QUEUE_FLAG_NONROT, q);
-}
-
-static int
-xloop_release_xfer(struct xloop_device *xlo)
-{
- int err = 0;
- struct xloop_func_table *xfer = xlo->xlo_encryption;
-
- if (xfer) {
- if (xfer->release)
- err = xfer->release(xlo);
- xlo->transfer = NULL;
- xlo->xlo_encryption = NULL;
- module_put(xfer->owner);
- }
- return err;
-}
-
-static int
-xloop_init_xfer(struct xloop_device *xlo, struct xloop_func_table *xfer,
- const struct xloop_info64 *i)
-{
- int err = 0;
-
- if (xfer) {
- struct module *owner = xfer->owner;
-
- if (!try_module_get(owner))
- return -EINVAL;
- if (xfer->init)
- err = xfer->init(xlo, i);
- if (err)
- module_put(owner);
- else
- xlo->xlo_encryption = xfer;
- }
- return err;
-}
-
-/**
- * xloop_set_status_from_info - configure device from xloop_info
- * @xlo: struct xloop_device to configure
- * @info: struct xloop_info64 to configure the device with
- *
- * 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)
-{
- int err;
- struct xloop_func_table *xfer;
- kuid_t uid = current_uid();
-
- if ((unsigned int) info->xlo_encrypt_key_size > XLO_KEY_SIZE)
- return -EINVAL;
-
- err = xloop_release_xfer(xlo);
- if (err)
- return err;
-
- if (info->xlo_encrypt_type) {
- unsigned int type = info->xlo_encrypt_type;
-
- if (type >= MAX_XLO_CRYPT)
- return -EINVAL;
- xfer = xfer_funcs[type];
- if (xfer == NULL)
- return -EINVAL;
- } else
- xfer = NULL;
-
- err = xloop_init_xfer(xlo, xfer, info);
- if (err)
- return err;
-
- xlo->xlo_offset = info->xlo_offset;
- 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;
-
- if (!xfer)
- xfer = &none_funcs;
- xlo->transfer = xfer->transfer;
- xlo->ioctl = xfer->ioctl;
-
- xlo->xlo_flags = info->xlo_flags;
-
- xlo->xlo_encrypt_key_size = info->xlo_encrypt_key_size;
- 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);
- 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)
-{
- struct file *file;
- struct inode *inode;
- struct address_space *mapping;
- struct block_device *claimed_bdev = NULL;
- int error;
- loff_t size;
- bool partscan;
- unsigned short bsize;
-
- /* This is safe, since we have a reference from open(). */
- __module_get(THIS_MODULE);
-
- error = -EBADF;
- file = fget(config->fd);
- if (!file)
- goto out;
-
- /*
- * If we don't hold exclusive handle for the device, upgrade to it
- * here to avoid changing device under exclusive owner.
- */
- if (!(mode & FMODE_EXCL)) {
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 9, 0)
- claimed_bdev = bdev->bd_contains;
- error = bd_prepare_to_claim(bdev, claimed_bdev, xloop_configure);
- if (error)
- goto out_putf;
-#else
- claimed_bdev = bd_start_claiming(bdev, xloop_configure);
- if (IS_ERR(claimed_bdev)) {
- error = PTR_ERR(claimed_bdev);
- goto out_putf;
- }
-#endif
- }
-
- error = mutex_lock_killable(&xloop_ctl_mutex);
- if (error)
- goto out_bdev;
-
- error = -EBUSY;
- if (xlo->xlo_state != Xlo_unbound)
- goto out_unlock;
-
- error = xloop_validate_file(file, bdev);
- if (error)
- goto out_unlock;
-
- mapping = file->f_mapping;
- inode = mapping->host;
-
- if ((config->info.xlo_flags & ~XLOOP_CONFIGURE_SETTABLE_FLAGS) != 0) {
- error = -EINVAL;
- goto out_unlock;
- }
-
- if (config->block_size) {
- error = xloop_validate_block_size(config->block_size);
- if (error)
- goto out_unlock;
- }
-
- error = xloop_set_status_from_info(xlo, &config->info);
- if (error)
- goto out_unlock;
-
- 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);
- if (error)
- goto out_unlock;
-
- error = xloop_file_fmt_init(xlo->xlo_fmt,
- config->info.xlo_file_fmt_type);
- if (error)
- goto out_unlock;
-
- set_device_ro(bdev, (xlo->xlo_flags & XLO_FLAGS_READ_ONLY) != 0);
-
- xlo->use_dio = xlo->xlo_flags & XLO_FLAGS_DIRECT_IO;
- 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));
-
- if (!(xlo->xlo_flags & XLO_FLAGS_READ_ONLY) && file->f_op->fsync)
- blk_queue_write_cache(xlo->xlo_queue, true, false);
-
- if (config->block_size)
- bsize = config->block_size;
- else if ((xlo->xlo_backing_file->f_flags & O_DIRECT) && inode->i_sb->s_bdev)
- /* In case of direct I/O, match underlying block size */
- bsize = bdev_logical_block_size(inode->i_sb->s_bdev);
- else
- bsize = 512;
-
- blk_queue_logical_block_size(xlo->xlo_queue, bsize);
- blk_queue_physical_block_size(xlo->xlo_queue, bsize);
- blk_queue_io_min(xlo->xlo_queue, bsize);
-
- xloop_update_rotational(xlo);
- xloop_update_dio(xlo);
- xloop_sysfs_init(xlo);
-
- 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);
-
- xlo->xlo_state = Xlo_bound;
- if (part_shift)
- xlo->xlo_flags |= XLO_FLAGS_PARTSCAN;
- partscan = xlo->xlo_flags & XLO_FLAGS_PARTSCAN;
- if (partscan)
- xlo->xlo_disk->flags &= ~GENHD_FL_NO_PART_SCAN;
-
- /* Grab the block_device to prevent its destruction after we
- * put /dev/xloopXX inode. Later in __xloop_clr_fd() we bdput(bdev).
- */
- bdgrab(bdev);
- mutex_unlock(&xloop_ctl_mutex);
- if (partscan)
- xloop_reread_partitions(xlo, bdev);
- if (claimed_bdev)
- bd_abort_claiming(bdev, claimed_bdev, xloop_configure);
- return 0;
-
-out_unlock:
- mutex_unlock(&xloop_ctl_mutex);
-out_bdev:
- if (claimed_bdev)
- bd_abort_claiming(bdev, claimed_bdev, xloop_configure);
-out_putf:
- fput(file);
-out:
- /* This is safe: open() is still holding a reference. */
- module_put(THIS_MODULE);
- return error;
-}
-
-static int __xloop_clr_fd(struct xloop_device *xlo, bool release)
-{
- struct file *filp = NULL;
- gfp_t gfp = xlo->old_gfp_mask;
- struct block_device *bdev = xlo->xlo_device;
- int err = 0;
- bool partscan = false;
- int xlo_number;
-
- mutex_lock(&xloop_ctl_mutex);
- if (WARN_ON_ONCE(xlo->xlo_state != Xlo_rundown)) {
- err = -ENXIO;
- goto out_unlock;
- }
-
- filp = xlo->xlo_backing_file;
- if (filp == NULL) {
- err = -EINVAL;
- goto out_unlock;
- }
-
- /* freeze request queue during the transition */
- blk_mq_freeze_queue(xlo->xlo_queue);
-
- xloop_file_fmt_exit(xlo->xlo_fmt);
-
- spin_lock_irq(&xlo->xlo_lock);
- xlo->xlo_backing_file = NULL;
- spin_unlock_irq(&xlo->xlo_lock);
-
- xloop_release_xfer(xlo);
- xlo->transfer = NULL;
- xlo->ioctl = NULL;
- xlo->xlo_device = NULL;
- xlo->xlo_encryption = NULL;
- xlo->xlo_offset = 0;
- xlo->xlo_sizelimit = 0;
- xlo->xlo_encrypt_key_size = 0;
- memset(xlo->xlo_encrypt_key, 0, XLO_KEY_SIZE);
- memset(xlo->xlo_crypt_name, 0, XLO_NAME_SIZE);
- memset(xlo->xlo_file_name, 0, XLO_NAME_SIZE);
- blk_queue_logical_block_size(xlo->xlo_queue, 512);
- blk_queue_physical_block_size(xlo->xlo_queue, 512);
- blk_queue_io_min(xlo->xlo_queue, 512);
- if (bdev) {
- bdput(bdev);
- invalidate_bdev(bdev);
- bdev->bd_inode->i_mapping->wb_err = 0;
- }
- set_capacity(xlo->xlo_disk, 0);
- xloop_sysfs_exit(xlo);
- if (bdev) {
- bd_set_size(bdev, 0);
- /* let user-space know about this change */
- kobject_uevent(&disk_to_dev(bdev->bd_disk)->kobj, KOBJ_CHANGE);
- }
- mapping_set_gfp_mask(filp->f_mapping, gfp);
- /* This is safe: open() is still holding a reference. */
- module_put(THIS_MODULE);
- blk_mq_unfreeze_queue(xlo->xlo_queue);
-
- partscan = xlo->xlo_flags & XLO_FLAGS_PARTSCAN && bdev;
- xlo_number = xlo->xlo_number;
- xloop_unprepare_queue(xlo);
-out_unlock:
- mutex_unlock(&xloop_ctl_mutex);
- if (partscan) {
- /*
- * bd_mutex has been held already in release path, so don't
- * acquire it if this function is called in such case.
- *
- * If the reread partition isn't from release path, xlo_refcnt
- * must be at least one and it can only become zero when the
- * current holder is released.
- */
- if (!release)
- mutex_lock(&bdev->bd_mutex);
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 5, 0)
- err = bdev_disk_changed(bdev, false);
-#else
- err = blkdev_reread_part(bdev);
-#endif
- if (!release)
- mutex_unlock(&bdev->bd_mutex);
- if (err)
- pr_warn("%s: partition scan of xloop%d failed (rc=%d)\n",
- __func__, xlo_number, err);
- /* Device is gone, no point in returning error */
- err = 0;
- }
-
- /*
- * xlo->xlo_state is set to Xlo_unbound here after above partscan has
- * finished.
- *
- * There cannot be anybody else entering __xloop_clr_fd() as
- * xlo->xlo_backing_file is already cleared and Xlo_rundown state
- * protects us from all the other places trying to change the 'xlo'
- * device.
- */
- mutex_lock(&xloop_ctl_mutex);
- xlo->xlo_flags = 0;
- if (!part_shift)
- xlo->xlo_disk->flags |= GENHD_FL_NO_PART_SCAN;
- xlo->xlo_state = Xlo_unbound;
- mutex_unlock(&xloop_ctl_mutex);
-
- /*
- * Need not hold xloop_ctl_mutex to fput backing file.
- * Calling fput holding xloop_ctl_mutex triggers a circular
- * lock dependency possibility warning as fput can take
- * bd_mutex which is usually taken before xloop_ctl_mutex.
- */
- if (filp)
- fput(filp);
- return err;
-}
-
-static int xloop_clr_fd(struct xloop_device *xlo)
-{
- int err;
-
- err = mutex_lock_killable(&xloop_ctl_mutex);
- if (err)
- return err;
- if (xlo->xlo_state != Xlo_bound) {
- mutex_unlock(&xloop_ctl_mutex);
- return -ENXIO;
- }
- /*
- * If we've explicitly asked to tear down the xloop device,
- * and it has an elevated reference count, set it for auto-teardown when
- * the last reference goes away. This stops $!~#$@ udev from
- * preventing teardown because it decided that it needs to run blkid on
- * the xloopback device whenever they appear. xfstests is notorious for
- * failing tests because blkid via udev races with a losetup
- * /do something like mkfs/losetup -d causing the losetup -d
- * command to fail with EBUSY.
- */
- if (atomic_read(&xlo->xlo_refcnt) > 1) {
- xlo->xlo_flags |= XLO_FLAGS_AUTOCLEAR;
- mutex_unlock(&xloop_ctl_mutex);
- return 0;
- }
- xlo->xlo_state = Xlo_rundown;
- mutex_unlock(&xloop_ctl_mutex);
-
- return __xloop_clr_fd(xlo, false);
-}
-
-static int
-xloop_set_status(struct xloop_device *xlo, const struct xloop_info64 *info)
-{
- int err;
- struct block_device *bdev;
- kuid_t uid = current_uid();
- int prev_xlo_flags;
- bool partscan = false;
- bool size_changed = false;
-
- 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)) {
- err = -EPERM;
- goto out_unlock;
- }
- if (xlo->xlo_state != Xlo_bound) {
- err = -ENXIO;
- goto out_unlock;
- }
-
- 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);
- }
-
- /* I/O need to be drained during transfer transition */
- blk_mq_freeze_queue(xlo->xlo_queue);
-
- if (size_changed && xlo->xlo_device->bd_inode->i_mapping->nrpages) {
- /* If any pages were dirtied after invalidate_bdev(), try again */
- err = -EAGAIN;
- pr_warn("%s: xloop%d (%s) has still dirty pages (nrpages=%lu)\n",
- __func__, xlo->xlo_number, xlo->xlo_file_name,
- xlo->xlo_device->bd_inode->i_mapping->nrpages);
- goto out_unfreeze;
- }
-
- prev_xlo_flags = xlo->xlo_flags;
-
- err = xloop_set_status_from_info(xlo, info);
- if (err)
- goto out_unfreeze;
-
- /* Mask out flags that can't be set using XLOOP_SET_STATUS. */
- xlo->xlo_flags &= XLOOP_SET_STATUS_SETTABLE_FLAGS;
- /* For those flags, use the previous values instead */
- xlo->xlo_flags |= prev_xlo_flags & ~XLOOP_SET_STATUS_SETTABLE_FLAGS;
- /* For flags that can't be cleared, use previous values too */
- xlo->xlo_flags |= prev_xlo_flags & ~XLOOP_SET_STATUS_CLEARABLE_FLAGS;
-
- if (xlo->xlo_fmt->file_fmt_type != info->xlo_file_fmt_type) {
- /* xloop file format has changed, so change file format driver */
- err = xloop_file_fmt_change(xlo->xlo_fmt, info->xlo_file_fmt_type);
- if (err)
- goto out_unfreeze;
-
- /* After change of the file format, recalculate the capacity of
- * the loop 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);
- }
-
- xloop_config_discard(xlo);
-
- /* update dio if xlo_offset or transfer is changed */
- __xloop_update_dio(xlo, xlo->use_dio);
-
-out_unfreeze:
- blk_mq_unfreeze_queue(xlo->xlo_queue);
-
- 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;
- }
-out_unlock:
- mutex_unlock(&xloop_ctl_mutex);
- if (partscan)
- xloop_reread_partitions(xlo, bdev);
-
- return err;
-}
-
-static int
-xloop_get_status(struct xloop_device *xlo, struct xloop_info64 *info)
-{
- struct path path;
- struct kstat stat;
- int ret;
-
- ret = mutex_lock_killable(&xloop_ctl_mutex);
- if (ret)
- return ret;
- if (xlo->xlo_state != Xlo_bound) {
- mutex_unlock(&xloop_ctl_mutex);
- return -ENXIO;
- }
-
- memset(info, 0, sizeof(*info));
- info->xlo_number = xlo->xlo_number;
- info->xlo_offset = xlo->xlo_offset;
- info->xlo_sizelimit = xlo->xlo_sizelimit;
- 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;
- 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);
- }
-
- /* Drop xloop_ctl_mutex while we call into the filesystem. */
- path = xlo->xlo_backing_file->f_path;
- path_get(&path);
- mutex_unlock(&xloop_ctl_mutex);
- ret = vfs_getattr(&path, &stat, STATX_INO, AT_STATX_SYNC_AS_STAT);
- if (!ret) {
- info->xlo_device = huge_encode_dev(stat.dev);
- info->xlo_inode = stat.ino;
- info->xlo_rdevice = huge_encode_dev(stat.rdev);
- }
- path_put(&path);
- return ret;
-}
-
-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;
- info64->xlo_device = info->xlo_device;
- info64->xlo_inode = info->xlo_inode;
- info64->xlo_rdevice = info->xlo_rdevice;
- info64->xlo_offset = info->xlo_offset;
- info64->xlo_sizelimit = 0;
- info64->xlo_encrypt_type = info->xlo_encrypt_type;
- info64->xlo_encrypt_key_size = info->xlo_encrypt_key_size;
- info64->xlo_flags = info->xlo_flags;
- info64->xlo_init[0] = info->xlo_init[0];
- info64->xlo_init[1] = info->xlo_init[1];
- info64->xlo_file_fmt_type = info->xlo_file_fmt_type;
- if (info->xlo_encrypt_type == XLO_CRYPT_CRYPTOAPI)
- memcpy(info64->xlo_crypt_name, info->xlo_name, XLO_NAME_SIZE);
- else
- memcpy(info64->xlo_file_name, info->xlo_name, XLO_NAME_SIZE);
- 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)
-{
- memset(info, 0, sizeof(*info));
- info->xlo_number = info64->xlo_number;
- info->xlo_device = info64->xlo_device;
- info->xlo_inode = info64->xlo_inode;
- info->xlo_rdevice = info64->xlo_rdevice;
- info->xlo_offset = info64->xlo_offset;
- info->xlo_encrypt_type = info64->xlo_encrypt_type;
- info->xlo_encrypt_key_size = info64->xlo_encrypt_key_size;
- info->xlo_flags = info64->xlo_flags;
- 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_encrypt_type == XLO_CRYPT_CRYPTOAPI)
- memcpy(info->xlo_name, info64->xlo_crypt_name, XLO_NAME_SIZE);
- else
- memcpy(info->xlo_name, info64->xlo_file_name, XLO_NAME_SIZE);
- 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)
- return -EOVERFLOW;
-
- return 0;
-}
-
-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)))
- 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)
-{
- struct xloop_info64 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) {
- struct xloop_info info;
- struct xloop_info64 info64;
- int err;
-
- if (!arg)
- return -EINVAL;
- err = xloop_get_status(xlo, &info64);
- if (!err)
- err = xloop_info64_to_old(&info64, &info);
- if (!err && copy_to_user(arg, &info, sizeof(info)))
- err = -EFAULT;
-
- return err;
-}
-
-static int
-xloop_get_status64(struct xloop_device *xlo, struct xloop_info64 __user *arg) {
- struct xloop_info64 info64;
- int err;
-
- if (!arg)
- return -EINVAL;
- err = xloop_get_status(xlo, &info64);
- if (!err && copy_to_user(arg, &info64, sizeof(info64)))
- err = -EFAULT;
-
- return err;
-}
-
-static int xloop_set_capacity(struct xloop_device *xlo)
-{
- loff_t size;
-
- if (unlikely(xlo->xlo_state != Xlo_bound))
- return -ENXIO;
-
- size = get_xloop_size(xlo, xlo->xlo_backing_file);
- xloop_set_size(xlo, size);
-
- return 0;
-}
-
-static int xloop_set_dio(struct xloop_device *xlo, unsigned long arg)
-{
- int error = -ENXIO;
- if (xlo->xlo_state != Xlo_bound)
- goto out;
-
- __xloop_update_dio(xlo, !!arg);
- if (xlo->use_dio == !!arg)
- return 0;
- error = -EINVAL;
- out:
- return error;
-}
-
-static int xloop_set_block_size(struct xloop_device *xlo, unsigned long arg)
-{
- int err = 0;
-
- if (xlo->xlo_state != Xlo_bound)
- return -ENXIO;
-
- err = xloop_validate_block_size(arg);
- if (err)
- return err;
-
- if (xlo->xlo_queue->limits.logical_block_size == arg)
- return 0;
-
- sync_blockdev(xlo->xlo_device);
- invalidate_bdev(xlo->xlo_device);
-
- blk_mq_freeze_queue(xlo->xlo_queue);
-
- /* invalidate_bdev should have truncated all the pages */
- if (xlo->xlo_device->bd_inode->i_mapping->nrpages) {
- err = -EAGAIN;
- pr_warn("%s: xloop%d (%s) has still dirty pages (nrpages=%lu)\n",
- __func__, xlo->xlo_number, xlo->xlo_file_name,
- xlo->xlo_device->bd_inode->i_mapping->nrpages);
- goto out_unfreeze;
- }
-
- blk_queue_logical_block_size(xlo->xlo_queue, arg);
- blk_queue_physical_block_size(xlo->xlo_queue, arg);
- blk_queue_io_min(xlo->xlo_queue, arg);
- xloop_update_dio(xlo);
-out_unfreeze:
- blk_mq_unfreeze_queue(xlo->xlo_queue);
-
- return err;
-}
-
-static int xlo_simple_ioctl(struct xloop_device *xlo, unsigned int cmd,
- unsigned long arg)
-{
- int err;
-
- err = mutex_lock_killable(&xloop_ctl_mutex);
- if (err)
- return err;
- switch (cmd) {
- case XLOOP_SET_CAPACITY:
- err = xloop_set_capacity(xlo);
- break;
- case XLOOP_SET_DIRECT_IO:
- err = xloop_set_dio(xlo, arg);
- break;
- case XLOOP_SET_BLOCK_SIZE:
- err = xloop_set_block_size(xlo, arg);
- break;
- default:
- err = xlo->ioctl ? xlo->ioctl(xlo, cmd, arg) : -EINVAL;
- }
- mutex_unlock(&xloop_ctl_mutex);
- return err;
-}
-
-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;
- int err;
-
- switch (cmd) {
- case XLOOP_SET_FD: {
- /*
- * Legacy case - pass in a zeroed out struct xloop_config with
- * only the file descriptor set , which corresponds with the
- * default parameters we'd have used otherwise.
- */
- struct xloop_config config;
-
- memset(&config, 0, sizeof(config));
- config.fd = arg;
-
- return xloop_configure(xlo, mode, bdev, &config);
- }
- case XLOOP_CONFIGURE: {
- struct xloop_config config;
-
- if (copy_from_user(&config, argp, sizeof(config)))
- return -EFAULT;
-
- return xloop_configure(xlo, mode, bdev, &config);
- }
- case XLOOP_CHANGE_FD:
- return xloop_change_fd(xlo, bdev, arg);
- case XLOOP_CLR_FD:
- return xloop_clr_fd(xlo);
- case XLOOP_SET_STATUS:
- err = -EPERM;
- 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)) {
- err = xloop_set_status64(xlo, argp);
- }
- break;
- case XLOOP_GET_STATUS64:
- return xloop_get_status64(xlo, argp);
- case XLOOP_SET_CAPACITY:
- case XLOOP_SET_DIRECT_IO:
- case XLOOP_SET_BLOCK_SIZE:
- if (!(mode & FMODE_WRITE) && !capable(CAP_SYS_ADMIN))
- return -EPERM;
- fallthrough;
- default:
- err = xlo_simple_ioctl(xlo, cmd, arg);
- break;
- }
-
- return err;
-}
-
-#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;
-};
-
-/*
- * 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)
-{
- struct compat_xloop_info info;
-
- if (copy_from_user(&info, arg, sizeof(info)))
- return -EFAULT;
-
- memset(info64, 0, sizeof(*info64));
- info64->xlo_number = info.xlo_number;
- info64->xlo_device = info.xlo_device;
- info64->xlo_inode = info.xlo_inode;
- info64->xlo_rdevice = info.xlo_rdevice;
- info64->xlo_offset = info.xlo_offset;
- info64->xlo_sizelimit = 0;
- info64->xlo_encrypt_type = info.xlo_encrypt_type;
- info64->xlo_encrypt_key_size = info.xlo_encrypt_key_size;
- info64->xlo_flags = info.xlo_flags;
- info64->xlo_init[0] = info.xlo_init[0];
- info64->xlo_init[1] = info.xlo_init[1];
- info64->xlo_file_fmt_type = info.xlo_file_fmt_type;
- if (info.xlo_encrypt_type == XLO_CRYPT_CRYPTOAPI)
- memcpy(info64->xlo_crypt_name, info.xlo_name, XLO_NAME_SIZE);
- else
- memcpy(info64->xlo_file_name, info.xlo_name, XLO_NAME_SIZE);
- memcpy(info64->xlo_encrypt_key, info.xlo_encrypt_key, XLO_KEY_SIZE);
- return 0;
-}
-
-/*
- * 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)
-{
- struct compat_xloop_info info;
-
- memset(&info, 0, sizeof(info));
- info.xlo_number = info64->xlo_number;
- info.xlo_device = info64->xlo_device;
- info.xlo_inode = info64->xlo_inode;
- info.xlo_rdevice = info64->xlo_rdevice;
- info.xlo_offset = info64->xlo_offset;
- info.xlo_encrypt_type = info64->xlo_encrypt_type;
- info.xlo_encrypt_key_size = info64->xlo_encrypt_key_size;
- info.xlo_flags = info64->xlo_flags;
- info.xlo_init[0] = info64->xlo_init[0];
- info.xlo_init[1] = info64->xlo_init[1];
- if (info.xlo_encrypt_type == XLO_CRYPT_CRYPTOAPI)
- memcpy(info.xlo_name, info64->xlo_crypt_name, XLO_NAME_SIZE);
- else
- memcpy(info.xlo_name, info64->xlo_file_name, XLO_NAME_SIZE);
- 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])
- return -EOVERFLOW;
-
- if (copy_to_user(arg, &info, sizeof(info)))
- return -EFAULT;
- return 0;
-}
-
-static int
-xloop_set_status_compat(struct xloop_device *xlo,
- const struct compat_xloop_info __user *arg)
-{
- struct xloop_info64 info64;
- int ret;
-
- ret = xloop_info64_from_compat(arg, &info64);
- if (ret < 0)
- return ret;
- return xloop_set_status(xlo, &info64);
-}
-
-static int
-xloop_get_status_compat(struct xloop_device *xlo,
- struct compat_xloop_info __user *arg)
-{
- struct xloop_info64 info64;
- int err;
-
- if (!arg)
- return -EINVAL;
- err = xloop_get_status(xlo, &info64);
- if (!err)
- err = xloop_info64_to_compat(&info64, arg);
- return err;
-}
-
-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) {
- case XLOOP_SET_STATUS:
- 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);
- 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);
- fallthrough;
- case XLOOP_SET_FD:
- case XLOOP_CHANGE_FD:
- case XLOOP_SET_BLOCK_SIZE:
- case XLOOP_SET_DIRECT_IO:
- err = xlo_ioctl(bdev, mode, cmd, arg);
- break;
- default:
- err = -ENOIOCTLCMD;
- break;
- }
- return err;
-}
-#endif
-
-static int xlo_open(struct block_device *bdev, fmode_t mode)
-{
- struct xloop_device *xlo;
- int err;
-
- err = mutex_lock_killable(&xloop_ctl_mutex);
- if (err)
- return err;
- xlo = bdev->bd_disk->private_data;
- if (!xlo) {
- err = -ENXIO;
- goto out;
- }
-
- atomic_inc(&xlo->xlo_refcnt);
-out:
- mutex_unlock(&xloop_ctl_mutex);
- return err;
-}
-
-static void xlo_release(struct gendisk *disk, fmode_t mode)
-{
- struct xloop_device *xlo;
-
- mutex_lock(&xloop_ctl_mutex);
- xlo = disk->private_data;
- if (atomic_dec_return(&xlo->xlo_refcnt))
- goto out_unlock;
-
- if (xlo->xlo_flags & XLO_FLAGS_AUTOCLEAR) {
- if (xlo->xlo_state != Xlo_bound)
- goto out_unlock;
- xlo->xlo_state = Xlo_rundown;
- mutex_unlock(&xloop_ctl_mutex);
- /*
- * In autoclear mode, stop the xloop thread
- * and remove configuration after last close.
- */
- __xloop_clr_fd(xlo, true);
- return;
- } else if (xlo->xlo_state == Xlo_bound) {
- /*
- * Otherwise keep thread (if running) and config,
- * but flush possible ongoing bios in thread.
- */
- blk_mq_freeze_queue(xlo->xlo_queue);
- blk_mq_unfreeze_queue(xlo->xlo_queue);
- }
-
-out_unlock:
- mutex_unlock(&xloop_ctl_mutex);
-}
-
-static const struct block_device_operations xlo_fops = {
- .owner = THIS_MODULE,
- .open = xlo_open,
- .release = xlo_release,
- .ioctl = xlo_ioctl,
-#ifdef CONFIG_COMPAT
- .compat_ioctl = xlo_compat_ioctl,
-#endif
-};
-
-/*
- * And now the modules code and kernel interface.
- */
-static int max_xloop;
-module_param(max_xloop, int, 0444);
-MODULE_PARM_DESC(max_xloop, "Maximum number of xloop devices");
-module_param(max_part, int, 0444);
-MODULE_PARM_DESC(max_part, "Maximum number of partitions per xloop device");
-MODULE_LICENSE("GPL");
-MODULE_ALIAS_BLOCKDEV_MAJOR(LOOP_MAJOR);
-
-int xloop_register_transfer(struct xloop_func_table *funcs)
-{
- unsigned int n = funcs->number;
-
- if (n >= MAX_XLO_CRYPT || xfer_funcs[n])
- return -EINVAL;
- xfer_funcs[n] = funcs;
- return 0;
-}
-
-static int unregister_transfer_cb(int id, void *ptr, void *data)
-{
- struct xloop_device *xlo = ptr;
- struct xloop_func_table *xfer = data;
-
- mutex_lock(&xloop_ctl_mutex);
- if (xlo->xlo_encryption == xfer)
- xloop_release_xfer(xlo);
- mutex_unlock(&xloop_ctl_mutex);
- return 0;
-}
-
-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)
- 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)
-{
- struct request *rq = bd->rq;
- struct xloop_cmd *cmd = blk_mq_rq_to_pdu(rq);
- struct xloop_device *xlo = rq->q->queuedata;
-
- blk_mq_start_request(rq);
-
- if (xlo->xlo_state != Xlo_bound)
- return BLK_STS_IOERR;
-
- switch (req_op(rq)) {
- case REQ_OP_FLUSH:
- case REQ_OP_DISCARD:
- case REQ_OP_WRITE_ZEROES:
- cmd->use_aio = false;
- break;
- default:
- cmd->use_aio = xlo->use_dio;
- break;
- }
-
- /* always use the first bio's css */
-#ifdef CONFIG_BLK_CGROUP
- if (cmd->use_aio && rq->bio && rq->bio->bi_blkg) {
- cmd->css = &bio_blkcg(rq->bio)->css;
- css_get(cmd->css);
- } else
-#endif
- cmd->css = NULL;
- kthread_queue_work(&xlo->worker, &cmd->work);
-
- return BLK_STS_OK;
-}
-
-static void xloop_handle_cmd(struct xloop_cmd *cmd)
-{
- struct request *rq = blk_mq_rq_from_pdu(cmd);
- const bool write = op_is_write(req_op(rq));
- struct xloop_device *xlo = rq->q->queuedata;
- int ret = 0;
-
- if (write && (xlo->xlo_flags & XLO_FLAGS_READ_ONLY)) {
- ret = -EIO;
- goto failed;
- }
-
- ret = do_req_filebacked(xlo, rq);
- failed:
- /* complete non-aio request */
- if (!cmd->use_aio || ret) {
- if (ret == -EOPNOTSUPP)
- cmd->ret = ret;
- else
- cmd->ret = ret ? -EIO : 0;
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 9, 0)
- if (likely(!blk_should_fake_timeout(rq->q)))
- blk_mq_complete_request(rq);
-#else
- blk_mq_complete_request(rq);
-#endif
- }
-}
-
-static void xloop_queue_work(struct kthread_work *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)
-{
- struct xloop_cmd *cmd = blk_mq_rq_to_pdu(rq);
-
- kthread_init_work(&cmd->work, xloop_queue_work);
- return 0;
-}
-
-static const struct blk_mq_ops xloop_mq_ops = {
- .queue_rq = xloop_queue_rq,
- .init_request = xloop_init_request,
- .complete = xlo_complete_rq,
-};
-
-static struct dentry *xloop_dbgfs_dir;
-
-static int xloop_add(struct xloop_device **l, int i)
-{
- struct xloop_device *xlo;
- struct gendisk *disk;
- int err;
-
- err = -ENOMEM;
- xlo = kzalloc(sizeof(*xlo), GFP_KERNEL);
- if (!xlo)
- goto out;
-
- xlo->xlo_state = Xlo_unbound;
-
- /* allocate id, if @id >= 0, we're requesting that specific id */
- if (i >= 0) {
- err = idr_alloc(&xloop_index_idr, xlo, i, i + 1, GFP_KERNEL);
- if (err == -ENOSPC)
- err = -EEXIST;
- } else {
- err = idr_alloc(&xloop_index_idr, xlo, 0, 0, GFP_KERNEL);
- }
- if (err < 0)
- goto out_free_dev;
- i = err;
-
- err = -ENOMEM;
- xlo->tag_set.ops = &xloop_mq_ops;
- xlo->tag_set.nr_hw_queues = 1;
- xlo->tag_set.queue_depth = 128;
- xlo->tag_set.numa_node = NUMA_NO_NODE;
- xlo->tag_set.cmd_size = sizeof(struct xloop_cmd);
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 8, 0)
- xlo->tag_set.flags = BLK_MQ_F_SHOULD_MERGE | BLK_MQ_F_STACKING;
-#else
- xlo->tag_set.flags = BLK_MQ_F_SHOULD_MERGE;
-#endif
- xlo->tag_set.driver_data = xlo;
-
- err = blk_mq_alloc_tag_set(&xlo->tag_set);
- if (err)
- goto out_free_idr;
-
- xlo->xlo_queue = blk_mq_init_queue(&xlo->tag_set);
- if (IS_ERR(xlo->xlo_queue)) {
- err = PTR_ERR(xlo->xlo_queue);
- goto out_cleanup_tags;
- }
- xlo->xlo_queue->queuedata = xlo;
-
- blk_queue_max_hw_sectors(xlo->xlo_queue, BLK_DEF_MAX_SECTORS);
-
- /*
- * By default, we do buffer IO, so it doesn't make sense to enable
- * merge because the I/O submitted to backing file is handled page by
- * page. For directio mode, merge does help to dispatch bigger request
- * to underlayer disk. We will enable merge once directio is enabled.
- */
- blk_queue_flag_set(QUEUE_FLAG_NOMERGES, xlo->xlo_queue);
-
- err = -ENOMEM;
- xlo->xlo_fmt = xloop_file_fmt_alloc();
- if (!xlo->xlo_fmt)
- goto out_free_queue;
-
- xloop_file_fmt_set_xlo(xlo->xlo_fmt, xlo);
-
- err = -ENOMEM;
- disk = xlo->xlo_disk = alloc_disk(1 << part_shift);
- if (!disk)
- goto out_free_file_fmt;
-
- /*
- * Disable partition scanning by default. The in-kernel partition
- * scanning can be requested individually per-device during its
- * setup. Userspace can always add and remove partitions from all
- * devices. The needed partition minors are allocated from the
- * extended minor space, the main xloop device numbers will continue
- * to match the xloop minors, regardless of the number of partitions
- * used.
- *
- * If max_part is given, partition scanning is globally enabled for
- * all xloop devices. The minors for the main xloop devices will be
- * multiples of max_part.
- *
- * Note: Global-for-all-devices, set-only-at-init, read-only module
- * parameteters like 'max_xloop' and 'max_part' make things needlessly
- * complicated, are too static, inflexible and may surprise
- * userspace tools. Parameters like this in general should be avoided.
- */
- if (!part_shift)
- disk->flags |= GENHD_FL_NO_PART_SCAN;
- disk->flags |= GENHD_FL_EXT_DEVT;
- atomic_set(&xlo->xlo_refcnt, 0);
- xlo->xlo_number = i;
- spin_lock_init(&xlo->xlo_lock);
- disk->major = LOOP_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
- * the 'block' directory exists, otherwise create the loop directory in
- * the root directory */
-#ifdef CONFIG_DEBUG_FS
- xlo->xlo_dbgfs_dir = debugfs_create_dir(disk->disk_name, xloop_dbgfs_dir);
-
- if (IS_ERR_OR_NULL(xlo->xlo_dbgfs_dir)) {
- err = -ENODEV;
- xlo->xlo_dbgfs_dir = NULL;
- goto out_free_file_fmt;
- }
-#endif
-
- return xlo->xlo_number;
-
-out_free_file_fmt:
- xloop_file_fmt_free(xlo->xlo_fmt);
-out_free_queue:
- blk_cleanup_queue(xlo->xlo_queue);
-out_cleanup_tags:
- blk_mq_free_tag_set(&xlo->tag_set);
-out_free_idr:
- idr_remove(&xloop_index_idr, i);
-out_free_dev:
- kfree(xlo);
-out:
- return err;
-}
-
-static void xloop_remove(struct xloop_device *xlo)
-{
- xloop_file_fmt_free(xlo->xlo_fmt);
- debugfs_remove(xlo->xlo_dbgfs_dir);
- del_gendisk(xlo->xlo_disk);
- blk_cleanup_queue(xlo->xlo_queue);
- blk_mq_free_tag_set(&xlo->tag_set);
- put_disk(xlo->xlo_disk);
- kfree(xlo);
-}
-
-static int find_free_cb(int id, void *ptr, void *data)
-{
- struct xloop_device *xlo = ptr;
- struct xloop_device **l = data;
-
- if (xlo->xlo_state == Xlo_unbound) {
- *l = xlo;
- return 1;
- }
- return 0;
-}
-
-static int xloop_lookup(struct xloop_device **l, int i)
-{
- struct xloop_device *xlo;
- int ret = -ENODEV;
-
- if (i < 0) {
- int err;
-
- err = idr_for_each(&xloop_index_idr, &find_free_cb, &xlo);
- if (err == 1) {
- *l = xlo;
- ret = xlo->xlo_number;
- }
- goto out;
- }
-
- /* lookup and return a specific i */
- xlo = idr_find(&xloop_index_idr, i);
- if (xlo) {
- *l = xlo;
- ret = xlo->xlo_number;
- }
-out:
- return ret;
-}
-
-static struct kobject *xloop_probe(dev_t dev, int *part, void *data)
-{
- struct xloop_device *xlo;
- struct kobject *kobj;
- int err;
-
- mutex_lock(&xloop_ctl_mutex);
- err = xloop_lookup(&xlo, MINOR(dev) >> part_shift);
- if (err < 0)
- err = xloop_add(&xlo, MINOR(dev) >> part_shift);
- if (err < 0)
- kobj = NULL;
- else
- kobj = get_disk_and_module(xlo->xlo_disk);
- mutex_unlock(&xloop_ctl_mutex);
-
- *part = 0;
- return kobj;
-}
-
-static long xloop_control_ioctl(struct file *file, unsigned int cmd,
- unsigned long parm)
-{
- struct xloop_device *xlo;
- int ret;
-
- ret = mutex_lock_killable(&xloop_ctl_mutex);
- if (ret)
- return ret;
-
- ret = -ENOSYS;
- switch (cmd) {
- case XLOOP_CTL_ADD:
- ret = xloop_lookup(&xlo, parm);
- if (ret >= 0) {
- ret = -EEXIST;
- break;
- }
- ret = xloop_add(&xlo, parm);
- break;
- case XLOOP_CTL_REMOVE:
- ret = xloop_lookup(&xlo, parm);
- if (ret < 0)
- break;
- if (xlo->xlo_state != Xlo_unbound) {
- ret = -EBUSY;
- break;
- }
- if (atomic_read(&xlo->xlo_refcnt) > 0) {
- ret = -EBUSY;
- break;
- }
- xlo->xlo_disk->private_data = NULL;
- idr_remove(&xloop_index_idr, xlo->xlo_number);
- xloop_remove(xlo);
- break;
- case XLOOP_CTL_GET_FREE:
- ret = xloop_lookup(&xlo, -1);
- if (ret >= 0)
- break;
- ret = xloop_add(&xlo, -1);
- }
- mutex_unlock(&xloop_ctl_mutex);
-
- return ret;
-}
-
-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,
-};
-
-static struct miscdevice xloop_misc = {
- .minor = LOOP_CTRL_MINOR,
- .name = "xloop-control",
- .fops = &xloop_ctl_fops,
-};
-
-MODULE_ALIAS_MISCDEV(LOOP_CTRL_MINOR);
-MODULE_ALIAS("devname:xloop-control");
-
-static int __init xloop_init(void)
-{
- int i, nr;
- unsigned long range;
- struct xloop_device *xlo;
- int err;
-
- part_shift = 0;
- if (max_part > 0) {
- part_shift = fls(max_part);
-
- /*
- * Adjust max_part according to part_shift as it is exported
- * to user space so that user can decide correct minor number
- * if [s]he want to create more devices.
- *
- * Note that -1 is required because partition 0 is reserved
- * for the whole disk.
- */
- max_part = (1UL << part_shift) - 1;
- }
-
- if ((1UL << part_shift) > DISK_MAX_PARTS) {
- err = -EINVAL;
- goto err_out;
- }
-
- if (max_xloop > 1UL << (MINORBITS - part_shift)) {
- err = -EINVAL;
- goto err_out;
- }
-
- /*
- * If max_xloop is specified, create that many devices upfront.
- * This also becomes a hard limit. If max_xloop is not specified,
- * create CONFIG_BLK_DEV_XLOOP_MIN_COUNT xloop devices at module
- * init time. xloop devices can be requested on-demand with the
- * /dev/xloop-control interface, or be instantiated by accessing
- * a 'dead' device node.
- */
- if (max_xloop) {
- nr = CONFIG_BLK_DEV_LOOP_MIN_COUNT;
- range = 1UL << MINORBITS;
- }
-
- err = misc_register(&xloop_misc);
- if (err < 0)
- goto err_out;
-
-
- if (register_blkdev(LOOP_MAJOR, "xloop")) {
- err = -EIO;
- goto misc_out;
- }
-
-#ifdef CONFIG_DEBUG_FS
- xloop_dbgfs_dir = debugfs_create_dir("xloop", NULL);
- if (IS_ERR_OR_NULL(xloop_dbgfs_dir)) {
- err = -ENODEV;
- goto misc_out;
- }
-#endif
-
- blk_register_region(MKDEV(LOOP_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);
- for (i = 0; i < nr; i++)
- xloop_add(&xlo, i);
- mutex_unlock(&xloop_ctl_mutex);
-
- printk(KERN_INFO "xloop: module loaded\n");
- return 0;
-
-misc_out:
- misc_deregister(&xloop_misc);
-err_out:
- return err;
-}
-
-static int xloop_exit_cb(int id, void *ptr, void *data)
-{
- struct xloop_device *xlo = ptr;
-
- xloop_remove(xlo);
- return 0;
-}
-
-static void __exit xloop_exit(void)
-{
- unsigned long range;
-
- range = max_xloop ? max_xloop << part_shift : 1UL << MINORBITS;
-
- mutex_lock(&xloop_ctl_mutex);
-
- idr_for_each(&xloop_index_idr, &xloop_exit_cb, NULL);
- idr_destroy(&xloop_index_idr);
-
- blk_unregister_region(MKDEV(LOOP_MAJOR, 0), range);
- unregister_blkdev(LOOP_MAJOR, "xloop");
-
-#ifdef CONFIG_DEBUG_FS
- debugfs_remove(xloop_dbgfs_dir);
-#endif
-
- misc_deregister(&xloop_misc);
-
- mutex_unlock(&xloop_ctl_mutex);
-}
-
-module_init(xloop_init);
-module_exit(xloop_exit);
-
-#ifndef MODULE
-static int __init max_xloop_setup(char *str)
-{
- max_xloop = simple_strtol(str, NULL, 0);
- return 1;
-}
-
-__setup("max_xloop=", max_xloop_setup);
-#endif
diff --git a/loop_main.h b/loop_main.h
deleted file mode 100644
index 1b5851a..0000000
--- a/loop_main.h
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
- * loop_main.h
- *
- * Written by Theodore Ts'o, 3/29/93.
- *
- * Copyright 1993 by Theodore Ts'o. Redistribution of this file is
- * permitted under the GNU General Public License.
- */
-#ifndef _LINUX_XLOOP_H
-#define _LINUX_XLOOP_H
-
-#include
-#include
-#include
-#include
-#include
-#include
-#include "uapi/linux/loop.h"
-#ifdef CONFIG_DEBUG_FS
-#include
-#endif
-
-#include "loop_file_fmt.h"
-
-/* Possible states of device */
-enum {
- Xlo_unbound,
- Xlo_bound,
- Xlo_rundown,
-};
-
-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;
- 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);
-
- struct xloop_file_fmt *xlo_fmt;
-
- struct file * xlo_backing_file;
- struct block_device *xlo_device;
- void *key_data;
-
- 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;
-
- 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;
-#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 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 *);
- /* 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);
- struct module *owner;
-};
-
-int xloop_register_transfer(struct xloop_func_table *funcs);
-int xloop_unregister_transfer(int number);
-
-#endif
diff --git a/uapi/linux/loop.h b/uapi/linux/loop.h
deleted file mode 100644
index f93f6ad..0000000
--- a/uapi/linux/loop.h
+++ /dev/null
@@ -1,125 +0,0 @@
-/* SPDX-License-Identifier: GPL-1.0+ WITH Linux-syscall-note */
-/*
- * include/linux/loop.h
- *
- * Written by Theodore Ts'o, 3/29/93.
- *
- * Copyright 1993 by Theodore Ts'o. Redistribution of this file is
- * permitted under the GNU General Public License.
- */
-#ifndef _UAPI_LINUX_XLOOP_H
-#define _UAPI_LINUX_XLOOP_H
-
-
-#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 that can be set using XLOOP_SET_STATUS(64) */
-#define XLOOP_SET_STATUS_SETTABLE_FLAGS (XLO_FLAGS_AUTOCLEAR | XLO_FLAGS_PARTSCAN)
-
-/* XLO_FLAGS that can be cleared using XLOOP_SET_STATUS(64) */
-#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)
-
-#include /* for __kernel_old_dev_t */
-#include /* for __u64 */
-
-/* Backwards compatibility version */
-struct xloop_info {
- int xlo_number; /* ioctl r/o */
- __kernel_old_dev_t xlo_device; /* ioctl r/o */
- unsigned long xlo_inode; /* ioctl r/o */
- __kernel_old_dev_t xlo_rdevice; /* ioctl r/o */
- int xlo_offset;
- int xlo_encrypt_type;
- int xlo_encrypt_key_size; /* ioctl w/o */
- int xlo_flags;
- char xlo_name[XLO_NAME_SIZE];
- unsigned char xlo_encrypt_key[XLO_KEY_SIZE]; /* ioctl w/o */
- unsigned long xlo_init[2];
- char reserved[4];
- int xlo_file_fmt_type;
-};
-
-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;
-};
-
-/**
- * struct xloop_config - Complete configuration for a xloop device.
- * @fd: fd of the file to be used as a backing file for the xloop device.
- * @block_size: block size to use; ignored if 0.
- * @info: struct xloop_info64 to configure the xloop device with.
- *
- * This structure is used with the XLOOP_CONFIGURE ioctl, and can be used to
- * atomically setup and configure all xloop device parameters at once.
- */
-struct xloop_config {
- __u32 fd;
- __u32 block_size;
- 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
-
-/*
- * IOCTL commands --- we will commandeer 0x4C ('L')
- */
-#define XLOOP_SET_FD 0x4C00
-#define XLOOP_CLR_FD 0x4C01
-#define XLOOP_SET_STATUS 0x4C02
-#define XLOOP_GET_STATUS 0x4C03
-#define XLOOP_SET_STATUS64 0x4C04
-#define XLOOP_GET_STATUS64 0x4C05
-#define XLOOP_CHANGE_FD 0x4C06
-#define XLOOP_SET_CAPACITY 0x4C07
-#define XLOOP_SET_DIRECT_IO 0x4C08
-#define XLOOP_SET_BLOCK_SIZE 0x4C09
-#define XLOOP_CONFIGURE 0x4C0A
-
-/* /dev/xloop-control interface */
-#define XLOOP_CTL_ADD 0x4C80
-#define XLOOP_CTL_REMOVE 0x4C81
-#define XLOOP_CTL_GET_FREE 0x4C82
-#endif /* _UAPI_LINUX_XLOOP_H */
diff --git a/utils/CMakeLists.txt b/utils/CMakeLists.txt
new file mode 100644
index 0000000..d1e359d
--- /dev/null
+++ b/utils/CMakeLists.txt
@@ -0,0 +1,15 @@
+cmake_minimum_required(VERSION 3.10)
+
+# set the project name
+project(xloop-utils)
+
+# include global headers
+include_directories(${CMAKE_CURRENT_SOURCE_DIR})
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include)
+
+# add include of config.h to each source file
+add_compile_options(-include ${CMAKE_CURRENT_SOURCE_DIR}/config.h)
+
+add_subdirectory(lib)
+add_subdirectory(libsmartcols)
+add_subdirectory(sys-utils)
diff --git a/utils/bash-completion/losetup b/utils/bash-completion/losetup
new file mode 100644
index 0000000..e085abe
--- /dev/null
+++ b/utils/bash-completion/losetup
@@ -0,0 +1,85 @@
+_losetup_module()
+{
+ local cur prev OPTS ARG
+ COMPREPLY=()
+ cur="${COMP_WORDS[COMP_CWORD]}"
+ prev="${COMP_WORDS[COMP_CWORD-1]}"
+ case $prev in
+ '-d'|'--detach')
+ ARG="$($1 --output NAME | awk '{if (1 < NR) {print}}')"
+ COMPREPLY=( $(compgen -W "$ARG" -- $cur) )
+ return 0
+ ;;
+ '-j'|'--associated')
+ ARG="$($1 --output BACK-FILE | awk '{if (1 < NR) {print}}')"
+ COMPREPLY=( $(compgen -W "$ARG" -- $cur) )
+ return 0
+ ;;
+ '-c'|'--set-capacity')
+ ARG="$(for I in /dev/loop[0-9]*; do if [ -e $I ]; then echo $I; fi; done)"
+ COMPREPLY=( $(compgen -W "$ARG" -- $cur) )
+ return 0
+ ;;
+ '-o'|'--offset'|'--sizelimit')
+ COMPREPLY=( $(compgen -W "number" -- $cur) )
+ return 0
+ ;;
+ '-t'|'--type')
+ ARG="RAW QCOW VDI VMDK"
+ COMPREPLY=( $(compgen -W "$ARG" -- $cur) )
+ return 0
+ ;;
+ '-O'|'--output')
+ local prefix realcur OUTPUT_ALL OUTPUT
+ realcur="${cur##*,}"
+ prefix="${cur%$realcur}"
+ OUTPUT_ALL="NAME AUTOCLEAR BACK-FILE BACK-INO
+ BACK-MAJ:MIN FILE-FORMAT MAJ:MIN OFFSET PARTSCAN RO
+ SIZELIMIT DIO"
+ for WORD in $OUTPUT_ALL; do
+ if ! [[ $prefix == *"$WORD"* ]]; then
+ OUTPUT="$WORD ${OUTPUT:-""}"
+ fi
+ done
+ compopt -o nospace
+ COMPREPLY=( $(compgen -P "$prefix" -W "$OUTPUT" -S ',' -- $realcur) )
+ return 0
+ ;;
+ '-h'|'--help'|'-V'|'--version')
+ return 0
+ ;;
+ esac
+ case $cur in
+ -*)
+ OPTS="--all
+ --detach
+ --detach-all
+ --find
+ --set-capacity
+ --associated
+ --nooverlap
+ --offset
+ --sizelimit
+ --partscan
+ --read-only
+ --show
+ --type
+ --verbose
+ --json
+ --list
+ --noheadings
+ --output
+ --output-all
+ --raw
+ --help
+ --version"
+ COMPREPLY=( $(compgen -W "${OPTS[*]}" -- $cur) )
+ return 0
+ ;;
+ esac
+ local IFS=$'\n'
+ compopt -o filenames
+ COMPREPLY=( $(compgen -f -- $cur) )
+ return 0
+}
+complete -F _losetup_module losetup
diff --git a/utils/config.h b/utils/config.h
new file mode 100644
index 0000000..f74c162
--- /dev/null
+++ b/utils/config.h
@@ -0,0 +1,897 @@
+/* config.h. Generated from config.h.in by configure. */
+/* config.h.in. Generated from configure.ac by autoheader. */
+
+/* Define if building universal (internal helper macro) */
+/* #undef AC_APPLE_UNIVERSAL_BUILD */
+
+/* Enable agetty --reload feature */
+#define AGETTY_RELOAD 1
+
+/* Should chfn and chsh require the user to enter the password? */
+#define CHFN_CHSH_PASSWORD 1
+
+/* Path to hwclock adjtime file */
+#define CONFIG_ADJTIME_PATH "/etc/adjtime"
+
+/* Define if cryptsetup is to be loaded via dlopen */
+/* #undef CRYPTSETUP_VIA_DLOPEN */
+
+/* Define to 1 if translation of program messages to the user's native
+ language is requested. */
+#define ENABLE_NLS 1
+
+/* search path for fs helpers */
+#define FS_SEARCH_PATH "/sbin:/sbin/fs.d:/sbin/fs"
+
+/* Define to 1 if you have the header file. */
+/* #undef HAVE_ASM_IO_H */
+
+/* Define if btrfs stuff is available */
+#define HAVE_BTRFS_SUPPORT 1
+
+/* Define to 1 if you have the header file. */
+#define HAVE_BYTESWAP_H 1
+
+/* Define to 1 if you have the Mac OS X function CFLocaleCopyCurrent in the
+ CoreFoundation framework. */
+/* #undef HAVE_CFLOCALECOPYCURRENT */
+
+/* Define to 1 if you have the Mac OS X function CFPreferencesCopyAppValue in
+ the CoreFoundation framework. */
+/* #undef HAVE_CFPREFERENCESCOPYAPPVALUE */
+
+/* Define to 1 if you have the `clearenv' function. */
+#define HAVE_CLEARENV 1
+
+/* Define to 1 if you have the `clock_gettime' function. */
+#define HAVE_CLOCK_GETTIME 1
+
+/* Define to 1 if the system has the type `cpu_set_t'. */
+#define HAVE_CPU_SET_T 1
+
+/* Define if cryptsetup is available */
+/* #undef HAVE_CRYPTSETUP */
+
+/* Define if crypt_activate_by_signed_key exist in -lcryptsetup */
+/* #undef HAVE_CRYPT_ACTIVATE_BY_SIGNED_KEY */
+
+/* Define to 1 if you have the header file. */
+#define HAVE_CRYPT_H 1
+
+/* Define if the GNU dcgettext() function is already present or preinstalled.
+ */
+#define HAVE_DCGETTEXT 1
+
+/* Define to 1 if you have the declaration of `BLK_ZONE_REP_CAPACITY', and to
+ 0 if you don't. */
+#define HAVE_DECL_BLK_ZONE_REP_CAPACITY 0
+
+/* Define to 1 if you have the declaration of `CPU_ALLOC', and to 0 if you
+ don't. */
+#define HAVE_DECL_CPU_ALLOC 1
+
+/* Define to 1 if you have the declaration of `dirfd', and to 0 if you don't.
+ */
+/* #undef HAVE_DECL_DIRFD */
+
+/* Define to 1 if you have the declaration of `tzname', and to 0 if you don't.
+ */
+/* #undef HAVE_DECL_TZNAME */
+
+/* Define to 1 if you have the declaration of `_NL_TIME_WEEK_1STDAY', and to 0
+ if you don't. */
+#define HAVE_DECL__NL_TIME_WEEK_1STDAY 1
+
+/* Define to 1 if you have the `dirfd' function. */
+#define HAVE_DIRFD 1
+
+/* Define to 1 if `dd_fd' is a member of `DIR'. */
+/* #undef HAVE_DIR_DD_FD */
+
+/* Define to 1 if you have the header file. */
+#define HAVE_DLFCN_H 1
+
+/* Define to 1 if you have the `eaccess' function. */
+#define HAVE_EACCESS 1
+
+/* Define to 1 if you have the header file. */
+#define HAVE_ENDIAN_H 1
+
+/* Define to 1 if have **environ prototype */
+#define HAVE_ENVIRON_DECL 1
+
+/* Define to 1 if you have the `err' function. */
+#define HAVE_ERR 1
+
+/* Define to 1 if you have the header file. */
+#define HAVE_ERRNO_H 1
+
+/* Define to 1 if you have the `errx' function. */
+#define HAVE_ERRX 1
+
+/* Define to 1 if you have the header file. */
+#define HAVE_ERR_H 1
+
+/* Define to 1 if you have the `explicit_bzero' function. */
+#define HAVE_EXPLICIT_BZERO 1
+
+/* Have valid fallocate() function */
+#define HAVE_FALLOCATE 1
+
+/* Define to 1 if you have the header file. */
+#define HAVE_FCNTL_H 1
+
+/* Define to 1 if you have the `fpurge' function. */
+/* #undef HAVE_FPURGE */
+
+/* Define to 1 if fseeko (and presumably ftello) exists and is declared. */
+#define HAVE_FSEEKO 1
+
+/* Define to 1 if you have the `fstatat' function. */
+#define HAVE_FSTATAT 1
+
+/* Define to 1 if you have the `fsync' function. */
+#define HAVE_FSYNC 1
+
+/* Define to 1 if you have the `futimens' function. */
+#define HAVE_FUTIMENS 1
+
+/* Define to 1 if you have the `getdomainname' function. */
+#define HAVE_GETDOMAINNAME 1
+
+/* Define to 1 if you have the `getdtablesize' function. */
+#define HAVE_GETDTABLESIZE 1
+
+/* Define to 1 if you have the `getexecname' function. */
+/* #undef HAVE_GETEXECNAME */
+
+/* Define to 1 if you have the `getmntinfo' function. */
+/* #undef HAVE_GETMNTINFO */
+
+/* Define to 1 if you have the header file. */
+#define HAVE_GETOPT_H 1
+
+/* Define to 1 if you have the `getrandom' function. */
+#define HAVE_GETRANDOM 1
+
+/* Define to 1 if you have the `getrlimit' function. */
+#define HAVE_GETRLIMIT 1
+
+/* Define to 1 if you have the `getsgnam' function. */
+#define HAVE_GETSGNAM 1
+
+/* Define if the GNU gettext() function is already present or preinstalled. */
+#define HAVE_GETTEXT 1
+
+/* Define to 1 if you have the `getusershell' function. */
+#define HAVE_GETUSERSHELL 1
+
+/* Define if you have the iconv() function and it works. */
+/* #undef HAVE_ICONV */
+
+/* Define to 1 if you have the `inotify_init' function. */
+#define HAVE_INOTIFY_INIT 1
+
+/* Define to 1 if you have the `inotify_init1' function. */
+#define HAVE_INOTIFY_INIT1 1
+
+/* Define to 1 if you have the header file. */
+#define HAVE_INTTYPES_H 1
+
+/* Define to 1 if you have the `ioperm' function. */
+#define HAVE_IOPERM 1
+
+/* Define to 1 if you have the `iopl' function. */
+#define HAVE_IOPL 1
+
+/* Define to 1 if you have the `isnan' function. */
+#define HAVE_ISNAN 1
+
+/* Define to 1 if you have the `jrand48' function. */
+#define HAVE_JRAND48 1
+
+/* Define if langinfo.h defines ALTMON_x constants */
+#define HAVE_LANGINFO_ALTMON 1
+
+/* Define to 1 if you have the header file. */
+#define HAVE_LANGINFO_H 1
+
+/* Define if langinfo.h defines _NL_ABALTMON_x constants */
+#define HAVE_LANGINFO_NL_ABALTMON 1
+
+/* Define to 1 if you have the header file. */
+#define HAVE_LASTLOG_H 1
+
+/* Define to 1 if you have the `lchown' function. */
+#define HAVE_LCHOWN 1
+
+/* Define to 1 if you have the `audit' library (-laudit). */
+/* #undef HAVE_LIBAUDIT */
+
+/* Define to 1 if you have the -lblkid. */
+#define HAVE_LIBBLKID 1
+
+/* Define to 1 if you have the `cap-ng' library (-lcap-ng). */
+#define HAVE_LIBCAP_NG 1
+
+/* Do we need -lcrypt? */
+#define HAVE_LIBCRYPT 1
+
+/* Define if libeconf is available */
+/* #undef HAVE_LIBECONF */
+
+/* Define if libmount available. */
+#define HAVE_LIBMOUNT 1
+
+/* Define if ncurses library available */
+/* #undef HAVE_LIBNCURSES */
+
+/* Define if ncursesw library available */
+#define HAVE_LIBNCURSESW 1
+
+/* Define to 1 if you have the `readline' library (-lreadline). */
+#define HAVE_LIBREADLINE 1
+
+/* Define if librtas exists */
+/* #undef HAVE_LIBRTAS */
+
+/* Define if SELinux is available */
+/* #undef HAVE_LIBSELINUX */
+
+/* Define if libsystemd is available */
+#define HAVE_LIBSYSTEMD 1
+
+/* Define if libtinfo or libtinfow available. */
+#define HAVE_LIBTINFO 1
+
+/* Define to 1 if you have the `udev' library (-ludev). */
+#define HAVE_LIBUDEV 1
+
+/* Define if libuser is available */
+/* #undef HAVE_LIBUSER */
+
+/* Define to 1 if you have the `utempter' library (-lutempter). */
+/* #undef HAVE_LIBUTEMPTER */
+
+/* Define to 1 if you have the `util' library (-lutil). */
+#define HAVE_LIBUTIL 1
+
+/* Define to 1 if you have the header file. */
+/* #undef HAVE_LIBUTIL_H */
+
+/* Define to 1 if you have the -luuid. */
+#define HAVE_LIBUUID 1
+
+/* Define to 1 if you have the header file. */
+#define HAVE_LINUX_BLKPG_H 1
+
+/* Define to 1 if you have the header file. */
+#define HAVE_LINUX_BLKZONED_H 1
+
+/* Define to 1 if you have the header file. */
+#define HAVE_LINUX_BTRFS_H 1
+
+/* Define to 1 if you have the header file. */
+#define HAVE_LINUX_CAPABILITY_H 1
+
+/* Define to 1 if you have the header file. */
+#define HAVE_LINUX_CDROM_H 1
+
+/* Define to 1 if you have the header file. */
+/* #undef HAVE_LINUX_COMPILER_H */
+
+/* Define to 1 if you have the header file. */
+#define HAVE_LINUX_FALLOC_H 1
+
+/* Define to 1 if you have the header file. */
+#define HAVE_LINUX_FD_H 1
+
+/* Define to 1 if you have the header file. */
+/* #undef HAVE_LINUX_FS_H */
+
+/* Define to 1 if you have the header file. */
+#define HAVE_LINUX_GSMMUX_H 1
+
+/* Define to 1 if you have the header file. */
+#define HAVE_LINUX_MAJOR_H 1
+
+/* Define to 1 if you have the header file. */
+#define HAVE_LINUX_NET_NAMESPACE_H 1
+
+/* Define to 1 if you have the header file. */
+#define HAVE_LINUX_RAW_H 1
+
+/* Define to 1 if you have the header file. */
+#define HAVE_LINUX_SECUREBITS_H 1
+
+/* Define to 1 if you have the header file. */
+#define HAVE_LINUX_TIOCL_H 1
+
+/* Define to 1 if you have the header file. */
+#define HAVE_LINUX_VERSION_H 1
+
+/* Define to 1 if you have the header file. */
+#define HAVE_LINUX_WATCHDOG_H 1
+
+/* Define to 1 if you have the `llseek' function. */
+/* #undef HAVE_LLSEEK */
+
+/* Define to 1 if you have the header file. */
+#define HAVE_LOCALE_H 1
+
+/* Define to 1 if the system has the type `loff_t'. */
+#define HAVE_LOFF_T 1
+
+/* Define to 1 if you have the libmagic present. */
+#define HAVE_MAGIC 1
+
+/* Define to 1 if you have the header file. */
+#define HAVE_MEMORY_H 1
+
+/* Define to 1 if you have the `mempcpy' function. */
+#define HAVE_MEMPCPY 1
+
+/* Define to 1 if you have the `mkostemp' function. */
+#define HAVE_MKOSTEMP 1
+
+/* Define to 1 if you have the header file. */
+#define HAVE_MNTENT_H 1
+
+/* Define to 1 if you have the `nanosleep' function. */
+#define HAVE_NANOSLEEP 1
+
+/* Define to 1 if you have the header file. */
+/* #undef HAVE_NCURSESW_NCURSES_H */
+
+/* Define to 1 if you have the header file. */
+/* #undef HAVE_NCURSESW_TERM_H */
+
+/* Define to 1 if you have the header file. */
+#define HAVE_NCURSES_H 1
+
+/* Define to 1 if you have the header file. */
+/* #undef HAVE_NCURSES_NCURSES_H */
+
+/* Define to 1 if you have the header file. */
+/* #undef HAVE_NCURSES_TERM_H */
+
+/* Define to 1 if you have the header file. */
+#define HAVE_NETINET_IN_H 1
+
+/* Define to 1 if you have the header file. */
+/* #undef HAVE_NET_IF_DL_H */
+
+/* Define to 1 if you have the header file. */
+#define HAVE_NET_IF_H 1
+
+/* Define to 1 if you have the `ntp_gettime' function. */
+#define HAVE_NTP_GETTIME 1
+
+/* Define to 1 if you have the `openat' function. */
+#define HAVE_OPENAT 1
+
+/* Define to 1 if you have the `open_memstream' function. */
+#define HAVE_OPEN_MEMSTREAM 1
+
+/* Define to 1 if you have the header file. */
+#define HAVE_PATHS_H 1
+
+/* Define if libpcre2 is available */
+#define HAVE_PCRE 1
+
+/* Define to 1 if you have the `personality' function. */
+#define HAVE_PERSONALITY 1
+
+/* Define to 1 if you have the `pidfd_open' function. */
+/* #undef HAVE_PIDFD_OPEN */
+
+/* Define to 1 if you have the `pidfd_send_signal' function. */
+/* #undef HAVE_PIDFD_SEND_SIGNAL */
+
+/* Define to 1 if you have the `posix_fadvise' function. */
+#define HAVE_POSIX_FADVISE 1
+
+/* Have valid posix_fallocate() function */
+#define HAVE_POSIX_FALLOCATE 1
+
+/* Define to 1 if you have the `prctl' function. */
+#define HAVE_PRCTL 1
+
+/* Define to 1 if you have the `prlimit' function. */
+#define HAVE_PRLIMIT 1
+
+/* Define if program_invocation_short_name is defined */
+#define HAVE_PROGRAM_INVOCATION_SHORT_NAME 1
+
+/* have PTY support */
+#define HAVE_PTY 1
+
+/* Define to 1 if you have the header file. */
+#define HAVE_PTY_H 1
+
+/* Define to 1 if you have the `qsort_r' function. */
+#define HAVE_QSORT_R 1
+
+/* Define to 1 if you have the `reboot' function. */
+#define HAVE_REBOOT 1
+
+/* Define if curses library has the resizeterm(). */
+#define HAVE_RESIZETERM 1
+
+/* Define to 1 if you have the `rpmatch' function. */
+#define HAVE_RPMATCH 1
+
+/* Define if struct sockaddr contains sa_len */
+/* #undef HAVE_SA_LEN */
+
+/* Define to 1 if you have the `scandirat' function. */
+#define HAVE_SCANDIRAT 1
+
+/* Define to 1 if you have the `sched_setattr' function. */
+/* #undef HAVE_SCHED_SETATTR */
+
+/* Define to 1 if you have the `sched_setscheduler' function. */
+#define HAVE_SCHED_SETSCHEDULER 1
+
+/* Define to 1 if you have the `secure_getenv' function. */
+#define HAVE_SECURE_GETENV 1
+
+/* Define to 1 if you have the `security_get_initial_context' function. */
+/* #undef HAVE_SECURITY_GET_INITIAL_CONTEXT */
+
+/* Define to 1 if you have the header file. */
+/* #undef HAVE_SECURITY_OPENPAM_H */
+
+/* Define to 1 if you have the header file. */
+#define HAVE_SECURITY_PAM_APPL_H 1
+
+/* Define to 1 if you have the header file. */
+#define HAVE_SECURITY_PAM_MISC_H 1
+
+/* Define to 1 if you have the `setitimer' function. */
+/* #undef HAVE_SETITIMER */
+
+/* Define to 1 if you have the `setns' function. */
+#define HAVE_SETNS 1
+
+/* Define to 1 if you have the `setprogname' function. */
+/* #undef HAVE_SETPROGNAME */
+
+/* Define to 1 if you have the `setresgid' function. */
+#define HAVE_SETRESGID 1
+
+/* Define to 1 if you have the `setresuid' function. */
+#define HAVE_SETRESUID 1
+
+/* Define to 1 if you have the