diff options
21 files changed, 3628 insertions, 422 deletions
diff --git a/Documentation/admin-guide/blockdev/index.rst b/Documentation/admin-guide/blockdev/index.rst index b903cf152091..127e921a0ccc 100644 --- a/Documentation/admin-guide/blockdev/index.rst +++ b/Documentation/admin-guide/blockdev/index.rst @@ -8,6 +8,7 @@ The Linux RapidIO Subsystem :maxdepth: 1 floppy + loop nbd paride ramdisk diff --git a/Documentation/admin-guide/blockdev/loop.rst b/Documentation/admin-guide/blockdev/loop.rst new file mode 100644 index 000000000000..a11457479cb4 --- /dev/null +++ b/Documentation/admin-guide/blockdev/loop.rst @@ -0,0 +1,83 @@ +Loopback Block Device +===================== + +Overview +-------- + +The loopback device driver allows 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. + +To use the loop device, you need the losetup utility, found in the `util-linux +package <https://www.kernel.org/pub/linux/utils/util-linux/>`_. + +.. note:: + Note that this loop device has nothing to do with the loopback device \ + used for network connections from the machine to itself. + + +Parameters +---------- + +Kernel Command Line Parameters +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + max_loop + The number of loop block devices that get unconditionally + pre-created at init time. The default number is configured by + BLK_DEV_LOOP_MIN_COUNT. Instead of statically allocating a + predefined number, loop devices can be requested on-demand + with the /dev/loop-control interface. + + +Module parameters +~~~~~~~~~~~~~~~~~ + + max_part + Maximum number of partitions per loop device (default: 0). + + If max_part is given, partition scanning is globally enabled + for all loop devices. + + max_loop + Maximum number of loop devices that should be initialized + (default: 8). The default number is configured by + BLK_DEV_LOOP_MIN_COUNT. + + +File format drivers +------------------- + +The loopback device driver provides an interface for kernel modules to +implement custom file formats. By default, an initialized loop device uses the +**RAW** file format driver. + +.. note:: + If you want to create and set up a new loop device with the losetup \ + utility make sure that the suitable file format driver is loaded \ + before. + +The following file format drivers are available. + + +RAW +~~~ + +The RAW file format driver implements the binary reading and writing of a disk +image file. It supports discarding, asynchrounous IO, flushing and cryptoloop +support. + +The driver's kernel module is named *loop_file_fmt_raw*. + + +QCOW +~~~~ + +The QCOW file format driver implements QEMU's copy on write file format in +version 2. At the moment, the file format driver only supports the reading +of QCOW2 disk image files. It does not support writing to QCOW2 images, the +recovery of broken QCOW images, snapshots and reference counts. + +The driver's kernel module is named *loop_file_fmt_qcow*. diff --git a/Documentation/driver-api/index.rst b/Documentation/driver-api/index.rst index d12a80f386a6..605a3a398ce3 100644 --- a/Documentation/driver-api/index.rst +++ b/Documentation/driver-api/index.rst @@ -51,6 +51,7 @@ available subsections can be seen below. mmc/index nvdimm/index w1 + loop-file-fmt rapidio/index s390-drivers vme diff --git a/Documentation/driver-api/loop-file-fmt.rst b/Documentation/driver-api/loop-file-fmt.rst new file mode 100644 index 000000000000..335fde30f364 --- /dev/null +++ b/Documentation/driver-api/loop-file-fmt.rst @@ -0,0 +1,135 @@ +=========================================== +Loopback block device file format subsystem +=========================================== + +This document outlines the file format subsystem used in the loopback block +device module. This subsystem deals with the abstraction of direct file access +to allow the implementation of various disk file formats. The subsystem can +handle ... + + - read + - write + - discard + - flush + - sector size + +... operations of a loop device. + +Therefore, the subsystem provides an internal API for the loop device module to +access its functionality and exports a file format driver API to implement any +file format driver for loop devices. + + +Use the file format subsystem +============================= + +At the moment, the file format subsystem is only intended to be used from the +loopback device module to provide a specific file format implementation per +configured loop device. Therefore, the loop device module can use the following +internal file format API functions to set up loop file formats and access the +file format subsystem. + + +Internal subsystem API +---------------------- + +.. kernel-doc:: drivers/block/loop/loop_file_fmt.h + :functions: loop_file_fmt_alloc loop_file_fmt_free \ + loop_file_fmt_set_lo loop_file_fmt_get_lo + loop_file_fmt_init loop_file_fmt_exit \ + loop_file_fmt_read loop_file_fmt_read_aio \ + loop_file_fmt_write loop_file_fmt_write_aio \ + loop_file_fmt_discard loop_file_fmt_flush \ + loop_file_fmt_sector_size loop_file_fmt_change + + +Finite state machine +-------------------- + +To prevent a misuse of the internal file format API, the file format subsystem +implements an finite state machine. The state machine consists of two states +and a transition for each internal API function. The state +*file_fmt_uninitialized* of a loop file format denotes that the file format is +already allocated but not initialized. After the initialization, the file +format's state is set to *file_fmt_initialized*. In this state, all IO related +file format operations can be accessed. + +.. note:: If an internal API call does not succeed the file format's state \ + does not change accordingly to its transition and remains in the \ + original state before the API call. + +The entire implemented finite state machine looks like the following: + +.. kernel-render:: DOT + :alt: loop file format states + :caption: File format states and transitions + + digraph file_fmt_states { + rankdir = LR; + node [ shape = point, label = "" ] ENTRY, EXIT; + node [ shape = circle, label = "file_fmt_uninitialized" ] UN; + node [ shape = doublecircle, label = "file_fmt_initialized" ] IN; + subgraph helper { + rank = "same"; + ENTRY -> UN [ label = "loop_file_fmt_alloc()" ]; + UN -> EXIT [ label = "loop_file_fmt_free()" ]; + } + UN -> IN [ label = "loop_file_fmt_init()" ]; + IN -> UN [ label = "loop_file_fmt_exit()" ]; + IN -> IN [ label = "loop_file_fmt_read()\nloop_file_fmt_read_aio()\nloop_file_fmt_write()\n loop_file_fmt_write_aio()\nloop_file_fmt_discard()\nloop_file_fmt_flush()\nloop_file_fmt_sector_size()\nloop_file_fmt_change()" ]; + } + + +Write file format drivers +========================= + +A file format driver for the loop file format subsystem is implemented as +kernel module. In the kernel module's code, the file format driver structure is +statically allocated and must be initialized. An example definition would look +like:: + + struct loop_file_fmt_driver raw_file_fmt_driver = { + .name = "RAW", + .file_fmt_type = LO_FILE_FMT_RAW, + .ops = &raw_file_fmt_ops, + .owner = THIS_MODULE + }; + +The definition assigns a *name* to the file format driver. The *file_fmt_type* +field is set to the file format type that the driver implements. The *owner* +specifies the driver's owner and is used to lock the kernel module of the +driver if the file format driver is in use. The most important field of a loop +file format driver is the specification of its implementation. Therefore, the +*ops* field proposes all file format operations that the driver implement by +link to a statically allocated operations structure. + +.. note:: All fields of the **loop_file_fmt_driver** structure must be \ + initialized and set up accordingly, otherwise the driver does not \ + work properly. + +An example of such an operations structure looks like:: + + struct loop_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, + .discard = raw_file_fmt_discard, + .flush = raw_file_fmt_flush, + .sector_size = raw_file_fmt_sector_size + }; + +The operations structure consists of a bunch of functions pointers which are +set in this example to some functions of the binary raw disk file format +implemented in the example driver. If a function is not available in the +driver's implementation the function pointer in the operations structure must +be set to *NULL*. + +If all definitions are available and set up correctly the driver can be +registered and later on unregistered by using the following functions exported +by the file format subsystem: + +.. kernel-doc:: drivers/block/loop/loop_file_fmt.h + :functions: loop_file_fmt_register_driver loop_file_fmt_unregister_driver diff --git a/drivers/block/Kconfig b/drivers/block/Kconfig index 1bb8ec575352..5088d7c8b3b0 100644 --- a/drivers/block/Kconfig +++ b/drivers/block/Kconfig @@ -171,78 +171,7 @@ config BLK_DEV_COW_COMMON bool default BLK_DEV_UBD -config BLK_DEV_LOOP - 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 - <https://www.kernel.org/pub/linux/utils/util-linux/>. - - 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_LOOP_MIN_COUNT - int "Number of loop devices to pre-create at init time" - depends on BLK_DEV_LOOP - 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_LOOP - ---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. +source "drivers/block/loop/Kconfig" source "drivers/block/drbd/Kconfig" diff --git a/drivers/block/Makefile b/drivers/block/Makefile index a53cc1e3a2d3..1280cc7003a2 100644 --- a/drivers/block/Makefile +++ b/drivers/block/Makefile @@ -15,7 +15,7 @@ obj-$(CONFIG_PS3_VRAM) += ps3vram.o obj-$(CONFIG_ATARI_FLOPPY) += ataflop.o obj-$(CONFIG_AMIGA_Z2RAM) += z2ram.o obj-$(CONFIG_BLK_DEV_RAM) += brd.o -obj-$(CONFIG_BLK_DEV_LOOP) += loop.o +obj-$(CONFIG_BLK_DEV_LOOP) += loop/ obj-$(CONFIG_XILINX_SYSACE) += xsysace.o obj-$(CONFIG_CDROM_PKTCDVD) += pktcdvd.o obj-$(CONFIG_SUNVDC) += sunvdc.o @@ -23,7 +23,7 @@ obj-$(CONFIG_BLK_DEV_SKD) += skd.o obj-$(CONFIG_BLK_DEV_UMEM) += umem.o obj-$(CONFIG_BLK_DEV_NBD) += nbd.o -obj-$(CONFIG_BLK_DEV_CRYPTOLOOP) += cryptoloop.o +obj-$(CONFIG_BLK_DEV_CRYPTOLOOP) += loop/ obj-$(CONFIG_VIRTIO_BLK) += virtio_blk.o obj-$(CONFIG_BLK_DEV_SX8) += sx8.o diff --git a/drivers/block/loop/Kconfig b/drivers/block/loop/Kconfig new file mode 100644 index 000000000000..238ae96189d7 --- /dev/null +++ b/drivers/block/loop/Kconfig @@ -0,0 +1,93 @@ +# SPDX-License-Identifier: GPL-2.0 +# +# Loop device driver configuration +# + +config BLK_DEV_LOOP + 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 + <https://www.kernel.org/pub/linux/utils/util-linux/>. + + 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_LOOP_MIN_COUNT + int "Number of loop devices to pre-create at init time" + depends on BLK_DEV_LOOP + 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_LOOP + ---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_LOOP_FILE_FMT_RAW + tristate "Loop device binary file format support" + depends on BLK_DEV_LOOP + ---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_LOOP_FILE_FMT_QCOW + tristate "Loop device QCOW file format support" + depends on BLK_DEV_LOOP + 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/drivers/block/loop/Makefile b/drivers/block/loop/Makefile new file mode 100644 index 000000000000..a82cd7a06226 --- /dev/null +++ b/drivers/block/loop/Makefile @@ -0,0 +1,11 @@ +# SPDX-License-Identifier: GPL-2.0 + +loop-y += loop_main.o loop_file_fmt.o +obj-$(CONFIG_BLK_DEV_LOOP) += loop.o + +obj-$(CONFIG_BLK_DEV_CRYPTOLOOP) += cryptoloop.o + +obj-$(CONFIG_BLK_DEV_LOOP_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_LOOP_FILE_FMT_QCOW) += loop_file_fmt_qcow.o diff --git a/drivers/block/cryptoloop.c b/drivers/block/loop/cryptoloop.c index 3cabc335ae74..28e1c90e337e 100644 --- a/drivers/block/cryptoloop.c +++ b/drivers/block/loop/cryptoloop.c @@ -15,7 +15,7 @@ #include <linux/blkdev.h> #include <linux/scatterlist.h> #include <linux/uaccess.h> -#include "loop.h" +#include "loop_main.h" MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("loop blockdevice transferfunction adaptor / CryptoAPI"); diff --git a/drivers/block/loop/loop_file_fmt.c b/drivers/block/loop/loop_file_fmt.c new file mode 100644 index 000000000000..706a0caa78c5 --- /dev/null +++ b/drivers/block/loop/loop_file_fmt.c @@ -0,0 +1,328 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * loop_file_fmt.c + * + * File format subsystem for the loop device module. + * + * Copyright (C) 2019 Manuel Bentele <development@manuel-bentele.de> + */ + +#include <linux/kernel.h> +#include <linux/module.h> + +#include "loop_file_fmt.h" + +/* storage for all registered file format drivers */ +static struct loop_file_fmt_driver *loop_file_fmt_drivers[MAX_LO_FILE_FMT] = { + NULL +}; + +int loop_file_fmt_register_driver(struct loop_file_fmt_driver *drv) +{ + int ret = 0; + + if (drv == NULL) + return -EFAULT; + + if (drv->file_fmt_type > MAX_LO_FILE_FMT) + return -EINVAL; + + if (loop_file_fmt_drivers[drv->file_fmt_type] == NULL) { + loop_file_fmt_drivers[drv->file_fmt_type] = drv; + printk(KERN_INFO "loop_file_fmt: successfully registered file " + "format driver %s", drv->name); + } else { + printk(KERN_WARNING "loop_file_fmt: driver for file format " + "already registered"); + ret = -EBUSY; + } + + return ret; +} +EXPORT_SYMBOL(loop_file_fmt_register_driver); + +void loop_file_fmt_unregister_driver(struct loop_file_fmt_driver *drv) +{ + if (drv == NULL) + return; + + if (drv->file_fmt_type > MAX_LO_FILE_FMT) + return; + + loop_file_fmt_drivers[drv->file_fmt_type] = NULL; + printk(KERN_INFO "loop_file_fmt: successfully unregistered file " + "format driver %s", drv->name); +} +EXPORT_SYMBOL(loop_file_fmt_unregister_driver); + +struct loop_file_fmt *loop_file_fmt_alloc(void) +{ + return kzalloc(sizeof(struct loop_file_fmt), GFP_KERNEL); +} + +void loop_file_fmt_free(struct loop_file_fmt *lo_fmt) +{ + kfree(lo_fmt); +} + +int loop_file_fmt_set_lo(struct loop_file_fmt *lo_fmt, struct loop_device *lo) +{ + if (lo_fmt == NULL) + return -EINVAL; + + lo_fmt->lo = lo; + + return 0; +} +EXPORT_SYMBOL(loop_file_fmt_set_lo); + +struct loop_device *loop_file_fmt_get_lo(struct loop_file_fmt *lo_fmt) +{ + return lo_fmt->lo; +} +EXPORT_SYMBOL(loop_file_fmt_get_lo); + +int loop_file_fmt_init(struct loop_file_fmt *lo_fmt, + u32 file_fmt_type) +{ + struct loop_file_fmt_ops *ops; + struct module *drv; + int ret = 0; + + if (file_fmt_type > MAX_LO_FILE_FMT) + return -EINVAL; + + lo_fmt->file_fmt_type = file_fmt_type; + + if (lo_fmt->file_fmt_state != file_fmt_uninitialized) { + printk(KERN_WARNING "loop_file_fmt: file format is " + "initialized already"); + return -EINVAL; + } + + /* check if new file format driver is registered */ + if (loop_file_fmt_drivers[lo_fmt->file_fmt_type] == NULL) { + printk(KERN_ERR "loop_file_fmt: file format driver is not " + "available"); + return -ENODEV; + } + + printk(KERN_INFO "loop_file_fmt: use file format driver %s", + loop_file_fmt_drivers[lo_fmt->file_fmt_type]->name); + + drv = loop_file_fmt_drivers[lo_fmt->file_fmt_type]->owner; + if (!try_module_get(drv)) { + printk(KERN_ERR "loop_file_fmt: file format driver %s can not " + "be accessed", + loop_file_fmt_drivers[lo_fmt->file_fmt_type]->name); + return -ENODEV; + } + + ops = loop_file_fmt_drivers[lo_fmt->file_fmt_type]->ops; + if (likely(ops->init)) { + ret = ops->init(lo_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 */ + lo_fmt->file_fmt_state = file_fmt_initialized; + + return ret; + +free_drv: + module_put(drv); + lo_fmt->file_fmt_state = file_fmt_uninitialized; + return ret; +} + +void loop_file_fmt_exit(struct loop_file_fmt *lo_fmt) +{ + struct loop_file_fmt_ops *ops; + struct module *drv; + + if (lo_fmt->file_fmt_state != file_fmt_initialized) { + printk(KERN_WARNING "loop_file_fmt: file format is " + "uninitialized already"); + return; + } + + ops = loop_file_fmt_drivers[lo_fmt->file_fmt_type]->ops; + if (likely(ops->exit)) + ops->exit(lo_fmt); + + drv = loop_file_fmt_drivers[lo_fmt->file_fmt_type]->owner; + module_put(drv); + + /* after decreasing the refcount of file format driver module, + * the file format is uninitialized */ + lo_fmt->file_fmt_state = file_fmt_uninitialized; +} + +int loop_file_fmt_read(struct loop_file_fmt *lo_fmt, + struct request *rq) +{ + struct loop_file_fmt_ops *ops; + + if (unlikely(lo_fmt->file_fmt_state != file_fmt_initialized)) { + printk(KERN_ERR "loop_file_fmt: file format is " + "not initialized, can not read"); + return -EINVAL; + } + + ops = loop_file_fmt_drivers[lo_fmt->file_fmt_type]->ops; + if (likely(ops->read)) + return ops->read(lo_fmt, rq); + else + return -EIO; +} + +int loop_file_fmt_read_aio(struct loop_file_fmt *lo_fmt, + struct request *rq) +{ + struct loop_file_fmt_ops *ops; + + if (unlikely(lo_fmt->file_fmt_state != file_fmt_initialized)) { + printk(KERN_ERR "loop_file_fmt: file format is " + "not initialized, can not read aio"); + return -EINVAL; + } + + ops = loop_file_fmt_drivers[lo_fmt->file_fmt_type]->ops; + if (likely(ops->read_aio)) + return ops->read_aio(lo_fmt, rq); + else + return -EIO; +} + +int loop_file_fmt_write(struct loop_file_fmt *lo_fmt, + struct request *rq) +{ + struct loop_file_fmt_ops *ops; + + if (unlikely(lo_fmt->file_fmt_state != file_fmt_initialized)) { + printk(KERN_ERR "loop_file_fmt: file format is " + "not initialized, can not write"); + return -EINVAL; + } + + ops = loop_file_fmt_drivers[lo_fmt->file_fmt_type]->ops; + if (likely(ops->write)) + return ops->write(lo_fmt, rq); + else + return -EIO; +} + +int loop_file_fmt_write_aio(struct loop_file_fmt *lo_fmt, + struct request *rq) +{ + struct loop_file_fmt_ops *ops; + + if (unlikely(lo_fmt->file_fmt_state != file_fmt_initialized)) { + printk(KERN_ERR "loop_file_fmt: file format is " + "not initialized, can not write aio"); + return -EINVAL; + } + + ops = loop_file_fmt_drivers[lo_fmt->file_fmt_type]->ops; + if (likely(ops->write_aio)) + return ops->write_aio(lo_fmt, rq); + else + return -EIO; +} + +int loop_file_fmt_discard(struct loop_file_fmt *lo_fmt, + struct request *rq) +{ + struct loop_file_fmt_ops *ops; + + if (unlikely(lo_fmt->file_fmt_state != file_fmt_initialized)) { + printk(KERN_ERR "loop_file_fmt: file format is " + "not initialized, can not discard"); + return -EINVAL; + } + + ops = loop_file_fmt_drivers[lo_fmt->file_fmt_type]->ops; + if (likely(ops->discard)) + return ops->discard(lo_fmt, rq); + else + return -EIO; +} + +int loop_file_fmt_flush(struct loop_file_fmt *lo_fmt) +{ + struct loop_file_fmt_ops *ops; + + if (unlikely(lo_fmt->file_fmt_state != file_fmt_initialized)) { + printk(KERN_ERR "loop_file_fmt: file format is " + "not initialized, can not flush"); + return -EINVAL; + } + + ops = loop_file_fmt_drivers[lo_fmt->file_fmt_type]->ops; + if (likely(ops->flush)) + return ops->flush(lo_fmt); + + return 0; +} + +loff_t loop_file_fmt_sector_size(struct loop_file_fmt *lo_fmt) +{ + struct loop_file_fmt_ops *ops; + + if (unlikely(lo_fmt->file_fmt_state != file_fmt_initialized)) { + printk(KERN_ERR "loop_file_fmt: file format is " + "not initialized, can not read sector size"); + return 0; + } + + ops = loop_file_fmt_drivers[lo_fmt->file_fmt_type]->ops; + if (likely(ops->sector_size)) + return ops->sector_size(lo_fmt); + else + return 0; +} + +int loop_file_fmt_change(struct loop_file_fmt *lo_fmt, + u32 file_fmt_type_new) +{ + if (file_fmt_type_new > MAX_LO_FILE_FMT) + return -EINVAL; + + /* Unload the old file format driver if the file format is + * initialized */ + if (lo_fmt->file_fmt_state == file_fmt_initialized) + loop_file_fmt_exit(lo_fmt); + + /* Load the new file format driver because the file format is + * uninitialized now */ + return loop_file_fmt_init(lo_fmt, file_fmt_type_new); +} + +ssize_t loop_file_fmt_print_type(u32 file_fmt_type, char *file_fmt_name) +{ + ssize_t len = 0; + + switch(file_fmt_type) { + case LO_FILE_FMT_RAW: + len = sprintf(file_fmt_name, "%s", "RAW"); + break; + case LO_FILE_FMT_QCOW: + len = sprintf(file_fmt_name, "%s", "QCOW"); + break; + case LO_FILE_FMT_VDI: + len = sprintf(file_fmt_name, "%s", "VDI"); + break; + case LO_FILE_FMT_VMDK: + len = sprintf(file_fmt_name, "%s", "VMDK"); + break; + default: + len = sprintf(file_fmt_name, "%s", "ERROR: Unsupported loop " + "file format!"); + break; + } + + return len; +} +EXPORT_SYMBOL(loop_file_fmt_print_type); diff --git a/drivers/block/loop/loop_file_fmt.h b/drivers/block/loop/loop_file_fmt.h new file mode 100644 index 000000000000..cd62dee60bf7 --- /dev/null +++ b/drivers/block/loop/loop_file_fmt.h @@ -0,0 +1,351 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * loop_file_fmt.h + * + * File format subsystem for the loop device module. + * + * Copyright (C) 2019 Manuel Bentele <development@manuel-bentele.de> + */ + +#ifndef _LINUX_LOOP_FILE_FMT_H +#define _LINUX_LOOP_FILE_FMT_H + +#include "loop_main.h" + +struct loop_file_fmt; + +/** + * struct loop_file_fmt_ops - File format subsystem operations + * + * Data structure representing the file format subsystem interface. + */ +struct loop_file_fmt_ops { + /** + * @init: Initialization callback function + */ + int (*init) (struct loop_file_fmt *lo_fmt); + + /** + * @exit: Release callback function + */ + void (*exit) (struct loop_file_fmt *lo_fmt); + + /** + * @read: Read IO callback function + */ + int (*read) (struct loop_file_fmt *lo_fmt, + struct request *rq); + + /** + * @write: Write IO callback function + */ + int (*write) (struct loop_file_fmt *lo_fmt, + struct request *rq); + + /** + * @read_aio: Asynchronous read IO callback function + */ + int (*read_aio) (struct loop_file_fmt *lo_fmt, + struct request *rq); + + /** + * @write_aio: Asynchronous write IO callback function + */ + int (*write_aio) (struct loop_file_fmt *lo_fmt, + struct request *rq); + + /** + * @discard: Discard IO callback function + */ + int (*discard) (struct loop_file_fmt *lo_fmt, + struct request *rq); + + /** + * @flush: Flush callback function + */ + int (*flush) (struct loop_file_fmt *lo_fmt); + + /** + * @sector_size: Get sector size callback function + */ + loff_t (*sector_size) (struct loop_file_fmt *lo_fmt); +}; + +/** + * struct loop_file_fmt_driver - File format subsystem driver + * + * Data structure to implement file format drivers for the file format + * subsystem. + */ +struct loop_file_fmt_driver { + /** + * @name: Name of the file format driver + */ + const char *name; + + /** + * @file_fmt_type: Loop file format type of the file format driver + */ + const u32 file_fmt_type; + + /** + * @ops: Driver's implemented file format operations + */ + struct loop_file_fmt_ops *ops; + + /** + * @ops: Owner of the file format driver + */ + struct module *owner; +}; + +/* + * states of the file format + * + * transitions: + * loop_file_fmt_init(...) + * ---> uninitialized ------------------------------> initialized + * loop_file_fmt_exit(...) + * initialized ------------------------------> uninitialized + * loop_file_fmt_read(...) + * initialized ------------------------------> initialized + * loop_file_fmt_read_aio(...) + * initialized ------------------------------> initialized + * loop_file_fmt_write(...) + * initialized ------------------------------> initialized + * loop_file_fmt_write_aio(...) + * initialized ------------------------------> initialized + * loop_file_fmt_discard(...) + * initialized ------------------------------> initialized + * loop_file_fmt_flush(...) + * initialized ------------------------------> initialized + * loop_file_fmt_sector_size(...) + * initialized ------------------------------> initialized + * + * loop_file_fmt_change(...) + * +-----------------------------------------------------------+ + * | exit(...) init(...) | + * | initialized -------> uninitialized -------> initialized | + * +-----------------------------------------------------------+ + */ +enum { + file_fmt_uninitialized = 0, + file_fmt_initialized +}; + +/** + * struct loop_file_fmt - Loop file format + * + * Data structure to use with the file format the loop file format subsystem. + */ +struct loop_file_fmt { + /** + * @file_fmt_type: Current type of the loop file format + */ + u32 file_fmt_type; + + /** + * @file_fmt_state: Current state of the loop file format + */ + int file_fmt_state; + + /** + * @lo: Link to a file format's loop device + */ + struct loop_device *lo; + + /** + * @private_data: Optional link to a file format's driver specific data + */ + void *private_data; +}; + + +/* subsystem functions for the driver implementation */ + +/** + * loop_file_fmt_register_driver - Register a loop file format driver + * @drv: File format driver + * + * Registers the specified loop file format driver @drv by the loop file format + * subsystem. + */ +extern int loop_file_fmt_register_driver(struct loop_file_fmt_driver *drv); + +/** + * loop_file_fmt_unregister_driver - Unregister a loop file format driver + * @drv: File format driver + * + * Unregisters the specified loop file format driver @drv from the loop file + * format subsystem. + */ +extern void loop_file_fmt_unregister_driver(struct loop_file_fmt_driver *drv); + + +/* subsystem functions for subsystem usage */ + +/** + * loop_file_fmt_alloc - Allocate a loop file format + * + * Dynamically allocates a loop file format and returns a pointer to the + * created loop file format. + */ +extern struct loop_file_fmt *loop_file_fmt_alloc(void); + +/** + * loop_file_fmt_free - Free an allocated loop file format + * @lo_fmt: Loop file format + * + * Frees the already allocated loop file format @lo_fmt. + */ +extern void loop_file_fmt_free(struct loop_file_fmt *lo_fmt); + +/** + * loop_file_fmt_set_lo - Set the loop file format's loop device + * @lo_fmt: Loop file format + * @lo: Loop device + * + * The link to the loop device @lo is set in the loop file format @lo_fmt. + */ +extern int loop_file_fmt_set_lo(struct loop_file_fmt *lo_fmt, + struct loop_device *lo); + +/** + * loop_file_fmt_get_lo - Get the loop file format's loop device + * @lo_fmt: Loop file format + * + * Returns a pointer to the loop device of the loop file format @lo_fmt. + */ +extern struct loop_device *loop_file_fmt_get_lo(struct loop_file_fmt *lo_fmt); + +/** + * loop_file_fmt_init - Initialize a loop file format + * @lo_fmt: Loop file format + * @file_fmt_type: Type of the file format + * + * Initializes the specified loop file format @lo_fmt and sets up the correct + * file format type @file_fmt_type. Depending on @file_fmt_type, the correct + * loop file format driver is loaded in the subsystems backend. If no loop file + * format driver for the specified file format is available an error is + * returned. + */ +extern int loop_file_fmt_init(struct loop_file_fmt *lo_fmt, + u32 file_fmt_type); + +/** + * loop_file_fmt_exit - Release a loop file format + * @lo_fmt: Loop file format + * + * Releases the specified loop file format @lo_fmt and all its resources. + */ +extern void loop_file_fmt_exit(struct loop_file_fmt *lo_fmt); + +/** + * loop_file_fmt_read - Read IO from a loop file format + * @lo_fmt: Loop file format + * @rq: IO Request + * + * Reads IO from the file format's loop device by sending the IO read request + * @rq to the loop file format subsystem. The subsystem calls the registered + * callback function of the suitable loop file format driver. + */ +extern int loop_file_fmt_read(struct loop_file_fmt *lo_fmt, + struct request *rq); + +/** + * loop_file_fmt_read_aio - Read IO from a loop file format asynchronously + * @lo_fmt: Loop file format + * @rq: IO Request + * + * Reads IO from the file format's loop device asynchronously by sending the + * IO read aio request @rq to the loop file format subsystem. The subsystem + * calls the registered callback function of the suitable loop file format + * driver. + */ +extern int loop_file_fmt_read_aio(struct loop_file_fmt *lo_fmt, + struct request *rq); + +/** + * loop_file_fmt_write - Write IO to a loop file format + * @lo_fmt: Loop file format + * @rq: IO Request + * + * Write IO to the file format's loop device by sending the IO write request + * @rq to the loop file format subsystem. The subsystem calls the registered + * callback function of the suitable loop file format driver. + */ +extern int loop_file_fmt_write(struct loop_file_fmt *lo_fmt, + struct request *rq); + +/** + * loop_file_fmt_write_aio - Write IO to a loop file format asynchronously + * @lo_fmt: Loop file format + * @rq: IO Request + * + * Write IO to the file format's loop device asynchronously by sending the + * IO write aio request @rq to the loop file format subsystem. The subsystem + * calls the registered callback function of the suitable loop file format + * driver. + */ +extern int loop_file_fmt_write_aio(struct loop_file_fmt *lo_fmt, + struct request *rq); + +/** + * loop_file_fmt_discard - Discard IO on a loop file format + * @lo_fmt: Loop file format + * @rq: IO Request + * + * Discard IO on the file format's loop device by sending the IO discard + * request @rq to the loop file format subsystem. The subsystem calls the + * registered callback function of the suitable loop file format driver. + */ +extern int loop_file_fmt_discard(struct loop_file_fmt *lo_fmt, + struct request *rq); + +/** + * loop_file_fmt_flush - Flush a loop file format + * @lo_fmt: Loop file format + * + * Flush the file format's loop device by calling the registered callback + * function of the suitable loop file format driver. + */ +extern int loop_file_fmt_flush(struct loop_file_fmt *lo_fmt); + +/** + * loop_file_fmt_sector_size - Get sector size of a loop file format + * @lo_fmt: Loop file format + * + * Returns the physical sector size of the loop file format's loop device. + * If the loop file format implements a sparse disk image format, then this + * function returns the virtual sector size. + */ +extern loff_t loop_file_fmt_sector_size(struct loop_file_fmt *lo_fmt); + +/** + * loop_file_fmt_change - Change the loop file format's type + * @lo_fmt: Loop file format + * @file_fmt_type_new: Loop file format type + * + * Changes the file format type of the already initialized loop file format + * @lo_fmt. Therefore, the function releases the old file format and frees all + * of its resources before the loop file format @lo_fmt is initialized and set + * up with the new file format @file_fmt_type_new. + */ +extern int loop_file_fmt_change(struct loop_file_fmt *lo_fmt, + u32 file_fmt_type_new); + + +/* helper functions of the subsystem */ + +/** + * loop_file_fmt_print_type - Convert file format type to string + * @file_fmt_type: Loop file format type + * @file_fmt_name: Loop 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 loop_file_fmt_print_type(u32 file_fmt_type, + char *file_fmt_name); + +#endif diff --git a/drivers/block/loop/loop_file_fmt_qcow_cache.c b/drivers/block/loop/loop_file_fmt_qcow_cache.c new file mode 100644 index 000000000000..7d3af7398f04 --- /dev/null +++ b/drivers/block/loop/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 loop 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 <kwolf@redhat.com> + * + * Copyright (C) 2019 Manuel Bentele <development@manuel-bentele.de> + */ + +#include <linux/kernel.h> +#include <linux/log2.h> +#include <linux/types.h> +#include <linux/limits.h> +#include <linux/fs.h> +#include <linux/vmalloc.h> + +#include "loop_file_fmt_qcow_main.h" +#include "loop_file_fmt_qcow_cache.h" + +static inline void *__loop_file_fmt_qcow_cache_get_table_addr( + struct loop_file_fmt_qcow_cache *c, int table) +{ + return (u8 *) c->table_array + (size_t) table * c->table_size; +} + +static inline int __loop_file_fmt_qcow_cache_get_table_idx( + struct loop_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 *__loop_file_fmt_qcow_cache_get_name( + struct loop_file_fmt *lo_fmt, struct loop_file_fmt_qcow_cache *c) +{ + struct loop_file_fmt_qcow_data *qcow_data = lo_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 loop_file_fmt_qcow_cache *loop_file_fmt_qcow_cache_create( + struct loop_file_fmt *lo_fmt, int num_tables, unsigned table_size) +{ +#ifdef CONFIG_DEBUG_DRIVER + struct loop_file_fmt_qcow_data *qcow_data = lo_fmt->private_data; +#endif + struct loop_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 loop_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 loop_file_fmt_qcow_cache_destroy(struct loop_file_fmt *lo_fmt) +{ + struct loop_file_fmt_qcow_data *qcow_data = lo_fmt->private_data; + struct loop_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 __loop_file_fmt_qcow_cache_entry_flush( + struct loop_file_fmt_qcow_cache *c, int i) +{ + if (!c->entries[i].dirty || !c->entries[i].offset) { + return 0; + } else { + printk(KERN_ERR "loop_file_fmt_qcow: Flush dirty cache tables " + "is not supported yet\n"); + return -ENOSYS; + } +} + +static int __loop_file_fmt_qcow_cache_do_get(struct loop_file_fmt *lo_fmt, + struct loop_file_fmt_qcow_cache *c, u64 offset, void **table, + bool read_from_disk) +{ + struct loop_device *lo = loop_file_fmt_get_lo(lo_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 "loop_file_fmt_qcow: Cannot get " + "entry from %s cache: offset %llx is unaligned\n", + __loop_file_fmt_qcow_cache_get_name(lo_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 loop_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 = __loop_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(lo->lo_backing_file, + __loop_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 = __loop_file_fmt_qcow_cache_get_table_addr(c, i); + + return 0; +} + +int loop_file_fmt_qcow_cache_get(struct loop_file_fmt *lo_fmt, u64 offset, + void **table) +{ + struct loop_file_fmt_qcow_data *qcow_data = lo_fmt->private_data; + struct loop_file_fmt_qcow_cache *c = qcow_data->l2_table_cache; + + return __loop_file_fmt_qcow_cache_do_get(lo_fmt, c, offset, table, + true); +} + +void loop_file_fmt_qcow_cache_put(struct loop_file_fmt *lo_fmt, void **table) +{ + struct loop_file_fmt_qcow_data *qcow_data = lo_fmt->private_data; + struct loop_file_fmt_qcow_cache *c = qcow_data->l2_table_cache; + int i = __loop_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/drivers/block/loop/loop_file_fmt_qcow_cache.h b/drivers/block/loop/loop_file_fmt_qcow_cache.h new file mode 100644 index 000000000000..1abf9b2b7c09 --- /dev/null +++ b/drivers/block/loop/loop_file_fmt_qcow_cache.h @@ -0,0 +1,51 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * loop_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 <kwolf@redhat.com> + * + * Copyright (C) 2019 Manuel Bentele <development@manuel-bentele.de> + */ + +#ifndef _LINUX_LOOP_FILE_FMT_QCOW_CACHE_H +#define _LINUX_LOOP_FILE_FMT_QCOW_CACHE_H + +#include "loop_file_fmt.h" + +struct loop_file_fmt_qcow_cache_table { + s64 offset; + u64 lru_counter; + int ref; + bool dirty; +}; + +struct loop_file_fmt_qcow_cache { + struct loop_file_fmt_qcow_cache_table *entries; + struct loop_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 loop_file_fmt_qcow_cache *loop_file_fmt_qcow_cache_create( + struct loop_file_fmt *lo_fmt, + int num_tables, + unsigned table_size); + +extern void loop_file_fmt_qcow_cache_destroy(struct loop_file_fmt *lo_fmt); + +extern int loop_file_fmt_qcow_cache_get(struct loop_file_fmt *lo_fmt, + u64 offset, + void **table); + +extern void loop_file_fmt_qcow_cache_put(struct loop_file_fmt *lo_fmt, + void **table); + +#endif diff --git a/drivers/block/loop/loop_file_fmt_qcow_cluster.c b/drivers/block/loop/loop_file_fmt_qcow_cluster.c new file mode 100644 index 000000000000..9c91a8b4aeb7 --- /dev/null +++ b/drivers/block/loop/loop_file_fmt_qcow_cluster.c @@ -0,0 +1,270 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * loop_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 <development@manuel-bentele.de> + */ + +#include <linux/kernel.h> +#include <linux/string.h> + +#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 __loop_file_fmt_qcow_cluster_l2_load(struct loop_file_fmt *lo_fmt, + u64 offset, u64 l2_offset, u64 **l2_slice) +{ + struct loop_file_fmt_qcow_data *qcow_data = lo_fmt->private_data; + + int start_of_slice = sizeof(u64) * ( + loop_file_fmt_qcow_offset_to_l2_index(qcow_data, offset) - + loop_file_fmt_qcow_offset_to_l2_slice_index(qcow_data, offset) + ); + + ASSERT(qcow_data->l2_table_cache != NULL); + return loop_file_fmt_qcow_cache_get(lo_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 __loop_file_fmt_qcow_cluster_count_contiguous( + struct loop_file_fmt *lo_fmt, int nb_clusters, int cluster_size, + u64 *l2_slice, u64 stop_flags) +{ + int i; + enum loop_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 = loop_file_fmt_qcow_get_cluster_type(lo_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 __loop_file_fmt_qcow_cluster_count_contiguous_unallocated( + struct loop_file_fmt *lo_fmt, int nb_clusters, u64 *l2_slice, + enum loop_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 loop_file_fmt_qcow_cluster_type type = + loop_file_fmt_qcow_get_cluster_type(lo_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 loop_file_fmt_qcow_cluster_get_offset(struct loop_file_fmt *lo_fmt, + u64 offset, unsigned int *bytes, u64 *cluster_offset) +{ + struct loop_file_fmt_qcow_data *qcow_data = lo_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 loop_file_fmt_qcow_cluster_type type; + int ret; + + offset_in_cluster = loop_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 - + loop_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 = loop_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 (loop_file_fmt_qcow_offset_into_cluster(qcow_data, l2_offset)) { + printk_ratelimited(KERN_ERR "loop_file_fmt_qcow: L2 table " + "offset %llx unaligned (L1 index: %llx)", l2_offset, + l1_index); + return -EIO; + } + + /* load the l2 slice in memory */ + ret = __loop_file_fmt_qcow_cluster_l2_load(lo_fmt, offset, l2_offset, + &l2_slice); + if (ret < 0) { + return ret; + } + + /* find the cluster offset for the given disk offset */ + l2_index = loop_file_fmt_qcow_offset_to_l2_slice_index(qcow_data, + offset); + *cluster_offset = be64_to_cpu(l2_slice[l2_index]); + + nb_clusters = loop_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 = loop_file_fmt_qcow_get_cluster_type(lo_fmt, *cluster_offset); + if (qcow_data->qcow_version < 3 && ( + type == QCOW_CLUSTER_ZERO_PLAIN || + type == QCOW_CLUSTER_ZERO_ALLOC)) { + printk_ratelimited(KERN_ERR "loop_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 (loop_file_fmt_qcow_has_data_file(lo_fmt)) { + printk_ratelimited(KERN_ERR "loop_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 = __loop_file_fmt_qcow_cluster_count_contiguous_unallocated( + lo_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 = __loop_file_fmt_qcow_cluster_count_contiguous(lo_fmt, + nb_clusters, qcow_data->cluster_size, + &l2_slice[l2_index], QCOW_OFLAG_ZERO); + *cluster_offset &= L2E_OFFSET_MASK; + if (loop_file_fmt_qcow_offset_into_cluster(qcow_data, + *cluster_offset)) { + printk_ratelimited(KERN_ERR "loop_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 (loop_file_fmt_qcow_has_data_file(lo_fmt) && + *cluster_offset != offset - offset_in_cluster) { + printk_ratelimited(KERN_ERR "loop_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(); + } + + loop_file_fmt_qcow_cache_put(lo_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: + loop_file_fmt_qcow_cache_put(lo_fmt, (void **) &l2_slice); + return ret; +} diff --git a/drivers/block/loop/loop_file_fmt_qcow_cluster.h b/drivers/block/loop/loop_file_fmt_qcow_cluster.h new file mode 100644 index 000000000000..d62e3318f6ce --- /dev/null +++ b/drivers/block/loop/loop_file_fmt_qcow_cluster.h @@ -0,0 +1,23 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * loop_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 <development@manuel-bentele.de> + */ + +#ifndef _LINUX_LOOP_FILE_FMT_QCOW_CLUSTER_H +#define _LINUX_LOOP_FILE_FMT_QCOW_CLUSTER_H + +#include "loop_file_fmt.h" + +extern int loop_file_fmt_qcow_cluster_get_offset(struct loop_file_fmt *lo_fmt, + u64 offset, + unsigned int *bytes, + u64 *cluster_offset); + +#endif diff --git a/drivers/block/loop/loop_file_fmt_qcow_main.c b/drivers/block/loop/loop_file_fmt_qcow_main.c new file mode 100644 index 000000000000..d3e456f80803 --- /dev/null +++ b/drivers/block/loop/loop_file_fmt_qcow_main.c @@ -0,0 +1,945 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * loop_file_fmt_qcow.c + * + * QCOW file format driver for the loop device module. + * + * Copyright (C) 2019 Manuel Bentele <development@manuel-bentele.de> + */ + +#include <linux/module.h> +#include <linux/kernel.h> +#include <linux/init.h> +#include <linux/fs.h> +#include <linux/types.h> +#include <linux/limits.h> +#include <linux/blkdev.h> +#include <linux/bio.h> +#include <linux/bvec.h> +#include <linux/mutex.h> +#include <linux/uio.h> +#include <linux/string.h> +#include <linux/vmalloc.h> +#include <linux/zlib.h> + +#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 loop_file_fmt *lo_fmt, + struct loop_file_fmt_qcow_header *header) +{ + struct loop_device *lo = loop_file_fmt_get_lo(lo_fmt); + ssize_t len; + loff_t offset; + int ret = 0; + + /* read QCOW header */ + offset = 0; + len = kernel_read(lo->lo_backing_file, header, sizeof(*header), + &offset); + if (len < 0) { + printk(KERN_ERR "loop_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 "loop_file_fmt_qcow: image is not in QCOW " + "format"); + return -EINVAL; + } + + if (header->version < 2 || header->version > 3) { + printk(KERN_ERR "loop_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 "loop_file_fmt_qcow: QCOW header too " + "short"); + return -EINVAL; + } + } + + return ret; +} + +static int __qcow_file_fmt_validate_table(struct loop_file_fmt *lo_fmt, + u64 offset, u64 entries, size_t entry_len, s64 max_size_bytes, + const char *table_name) +{ + struct loop_file_fmt_qcow_data *qcow_data = lo_fmt->private_data; + + if (entries > max_size_bytes / entry_len) { + printk(KERN_INFO "loop_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) || ( + loop_file_fmt_qcow_offset_into_cluster(qcow_data, offset) != 0) + ) { + printk(KERN_INFO "loop_file_fmt_qcow: %s offset invalid", + table_name); + return -EINVAL; + } + + return 0; +} + +static inline loff_t __qcow_file_fmt_rq_get_pos(struct loop_file_fmt *lo_fmt, + struct request *rq) +{ + struct loop_device *lo = loop_file_fmt_get_lo(lo_fmt); + return ((loff_t) blk_rq_pos(rq) << 9) + lo->lo_offset; +} + +static int __qcow_file_fmt_compression_init(struct loop_file_fmt *lo_fmt) +{ + struct loop_file_fmt_qcow_data *qcow_data = lo_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; + } + + return ret; + +out_free_strm: + kfree(qcow_data->strm); +out: + return ret; +} + +static void __qcow_file_fmt_compression_exit(struct loop_file_fmt *lo_fmt) +{ + struct loop_file_fmt_qcow_data *qcow_data = lo_fmt->private_data; + + if (qcow_data->strm->workspace) + vfree(qcow_data->strm->workspace); + + if (qcow_data->strm) + kfree(qcow_data->strm); +} + +#ifdef CONFIG_DEBUG_FS +static void __qcow_file_fmt_header_to_buf(struct loop_file_fmt* lo_fmt, + const struct loop_file_fmt_qcow_header *header) +{ + struct loop_file_fmt_qcow_data *qcow_data = lo_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 loop_file_fmt *lo_fmt = file->private_data; + struct loop_file_fmt_qcow_data *qcow_data = lo_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 loop_file_fmt *lo_fmt = file->private_data; + struct loop_file_fmt_qcow_data *qcow_data = lo_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 = loop_file_fmt_qcow_cluster_get_offset(lo_fmt, + offset, &cur_bytes, &cluster_offset); + if (ret < 0) + return -EINVAL; + + offset_in_cluster = loop_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 loop_file_fmt *lo_fmt = file->private_data; + struct loop_file_fmt_qcow_data *qcow_data = lo_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 loop_file_fmt *lo_fmt) +{ + struct loop_file_fmt_qcow_data *qcow_data = lo_fmt->private_data; + struct loop_device *lo = loop_file_fmt_get_lo(lo_fmt); + int ret = 0; + + qcow_data->dbgfs_dir = debugfs_create_dir("QCOW", lo->lo_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, lo_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, lo_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 loop_file_fmt *lo_fmt) +{ + struct loop_file_fmt_qcow_data *qcow_data = lo_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 loop_file_fmt *lo_fmt) +{ + struct loop_file_fmt_qcow_data *qcow_data; + struct loop_device *lo = loop_file_fmt_get_lo(lo_fmt); + struct loop_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; + + lo_fmt->private_data = qcow_data; + + /* read the QCOW file header */ + ret = __qcow_file_fmt_header_read(lo_fmt, &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(lo_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 "loop_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 "loop_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 "loop_file_fmt_qcow: invalid backing file " + "offset"); + ret = -EINVAL; + goto free_qcow_data; + } + + if (header.backing_file_offset) { + printk(KERN_ERR "loop_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 "loop_file_fmt_qcow: image contains " + "inconsistent refcounts"); + ret = -EACCES; + goto free_qcow_data; + } + + if (qcow_data->incompatible_features & QCOW_INCOMPAT_CORRUPT) { + printk(KERN_ERR "loop_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 "loop_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 "loop_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 "loop_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 "loop_file_fmt_qcow: image does not contain a " + "reference count table"); + ret = -EINVAL; + goto free_qcow_data; + } + + ret = __qcow_file_fmt_validate_table(lo_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(lo_fmt, header.snapshots_offset, + header.nb_snapshots, + sizeof(struct loop_file_fmt_qcow_snapshot_header), + sizeof(struct loop_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(lo_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 = loop_file_fmt_qcow_size_to_l1(qcow_data, + header.size); + if (l1_vm_state_index > INT_MAX) { + printk(KERN_ERR "loop_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 "loop_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 "loop_file_fmt_qcow: could not " + "allocate L1 table"); + ret = -ENOMEM; + goto free_qcow_data; + } + len = kernel_read(lo->lo_backing_file, qcow_data->l1_table, + qcow_data->l1_size * sizeof(u64), + &qcow_data->l1_table_offset); + if (len < 0) { + printk(KERN_ERR "loop_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 "loop_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 "loop_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 = loop_file_fmt_qcow_cache_create(lo_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(lo_fmt); + if (ret < 0) + goto free_l2_cache; + + /* initialize debugfs entries */ +#ifdef CONFIG_DEBUG_FS + ret = __qcow_file_fmt_dbgfs_init(lo_fmt); + if (ret < 0) + goto free_l2_cache; +#endif + + return ret; + +free_l2_cache: + loop_file_fmt_qcow_cache_destroy(lo_fmt); +free_l1_table: + vfree(qcow_data->l1_table); +free_qcow_data: + kfree(qcow_data); + lo_fmt->private_data = NULL; + return ret; +} + +static void qcow_file_fmt_exit(struct loop_file_fmt *lo_fmt) +{ + struct loop_file_fmt_qcow_data *qcow_data = lo_fmt->private_data; + +#ifdef CONFIG_DEBUG_FS + __qcow_file_fmt_dbgfs_exit(lo_fmt); +#endif + + __qcow_file_fmt_compression_exit(lo_fmt); + + if (qcow_data->l1_table) { + vfree(qcow_data->l1_table); + } + + if (qcow_data->l2_table_cache) { + loop_file_fmt_qcow_cache_destroy(lo_fmt); + } + + if (qcow_data) { + kfree(qcow_data); + lo_fmt->private_data = NULL; + } +} + +static ssize_t __qcow_file_fmt_buffer_decompress(struct loop_file_fmt *lo_fmt, + void *dest, + size_t dest_size, + const void *src, + size_t src_size) +{ + struct loop_file_fmt_qcow_data *qcow_data = lo_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; + } + + zlib_inflateEnd(qcow_data->strm); + + return ret; +} + +static int __qcow_file_fmt_read_compressed(struct loop_file_fmt *lo_fmt, + struct bio_vec *bvec, + u64 file_cluster_offset, + u64 offset, + u64 bytes, + u64 bytes_done) +{ + struct loop_file_fmt_qcow_data *qcow_data = lo_fmt->private_data; + struct loop_device *lo = loop_file_fmt_get_lo(lo_fmt); + int ret = 0, csize, nb_csectors; + u64 coffset; + u8 *in_buf, *out_buf; + ssize_t len; + void *data; + unsigned long irq_flags; + int offset_in_cluster = loop_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); + + in_buf = vmalloc(csize); + if (!in_buf) { + return -ENOMEM; + } + + out_buf = vmalloc(qcow_data->cluster_size); + if (!out_buf) { + ret = -ENOMEM; + goto out_free_in_buf; + } + + len = kernel_read(lo->lo_backing_file, in_buf, csize, &coffset); + if (len < 0) { + ret = len; + goto out_free_out_buf; + } + + if (__qcow_file_fmt_buffer_decompress(lo_fmt, out_buf, + qcow_data->cluster_size, in_buf, csize) < 0) { + ret = -EIO; + goto out_free_out_buf; + } + + ASSERT(bytes <= bvec->bv_len); + data = bvec_kmap_irq(bvec, &irq_flags) + bytes_done; + memcpy(data, out_buf + offset_in_cluster, bytes); + flush_dcache_page(bvec->bv_page); + bvec_kunmap_irq(data, &irq_flags); + +out_free_out_buf: + vfree(out_buf); +out_free_in_buf: + vfree(in_buf); + + return ret; +} + +static int __qcow_file_fmt_read_bvec(struct loop_file_fmt *lo_fmt, + struct bio_vec *bvec, + loff_t *ppos) +{ + struct loop_file_fmt_qcow_data *qcow_data = lo_fmt->private_data; + struct loop_device *lo = loop_file_fmt_get_lo(lo_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 = loop_file_fmt_qcow_cluster_get_offset(lo_fmt, *ppos, + &cur_bytes, &cluster_offset); + if (ret < 0) { + goto fail; + } + + offset_in_cluster = loop_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(lo_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(lo->lo_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 loop_file_fmt *lo_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(lo_fmt, rq); + + rq_for_each_segment(bvec, rq, iter) { + ret = __qcow_file_fmt_read_bvec(lo_fmt, &bvec, &pos); + if (ret) + return ret; + + cond_resched(); + } + + return ret; +} + +static loff_t qcow_file_fmt_sector_size(struct loop_file_fmt *lo_fmt) +{ + struct loop_file_fmt_qcow_data *qcow_data = lo_fmt->private_data; + struct loop_device *lo = loop_file_fmt_get_lo(lo_fmt); + loff_t loopsize; + + if (qcow_data->size > 0) + loopsize = qcow_data->size; + else + return 0; + + if (lo->lo_offset > 0) + loopsize -= lo->lo_offset; + + if (lo->lo_sizelimit > 0 && lo->lo_sizelimit < loopsize) + loopsize = lo->lo_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 loopsize >> 9; +} + +static struct loop_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, + .discard = NULL, + .flush = NULL, + .sector_size = qcow_file_fmt_sector_size +}; + +static struct loop_file_fmt_driver qcow_file_fmt_driver = { + .name = "QCOW", + .file_fmt_type = LO_FILE_FMT_QCOW, + .ops = &qcow_file_fmt_ops, + .owner = THIS_MODULE +}; + +static int __init loop_file_fmt_qcow_init(void) +{ + printk(KERN_INFO "loop_file_fmt_qcow: init loop device QCOW file " + "format driver"); + return loop_file_fmt_register_driver(&qcow_file_fmt_driver); +} + +static void __exit loop_file_fmt_qcow_exit(void) +{ + printk(KERN_INFO "loop_file_fmt_qcow: exit loop device QCOW file " + "format driver"); + loop_file_fmt_unregister_driver(&qcow_file_fmt_driver); +} + +module_init(loop_file_fmt_qcow_init); +module_exit(loop_file_fmt_qcow_exit); + +MODULE_LICENSE("GPL"); +MODULE_AUTHOR("Manuel Bentele <development@manuel-bentele.de>"); +MODULE_DESCRIPTION("Loop device QCOW file format driver"); +MODULE_SOFTDEP("pre: loop"); diff --git a/drivers/block/loop/loop_file_fmt_qcow_main.h b/drivers/block/loop/loop_file_fmt_qcow_main.h new file mode 100644 index 000000000000..9e4951fba079 --- /dev/null +++ b/drivers/block/loop/loop_file_fmt_qcow_main.h @@ -0,0 +1,417 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * loop_file_fmt_qcow.h + * + * QCOW file format driver for the loop 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 <development@manuel-bentele.de> + */ + +#ifndef _LINUX_LOOP_FILE_FMT_QCOW_H +#define _LINUX_LOOP_FILE_FMT_QCOW_H + +#include <linux/list.h> +#include <linux/mutex.h> +#include <linux/types.h> +#include <linux/zlib.h> + +#ifdef CONFIG_DEBUG_FS +#include <linux/debugfs.h> +#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 loop_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 loop_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 loop_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 loop_file_fmt_qcow_cache *l2_table_cache; + struct loop_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; + + /* 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 loop_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 loop_file_fmt_qcow_cluster_type { + QCOW_CLUSTER_UNALLOCATED, + QCOW_CLUSTER_ZERO_PLAIN, + QCOW_CLUSTER_ZERO_ALLOC, + QCOW_CLUSTER_NORMAL, + QCOW_CLUSTER_COMPRESSED, +}; + +enum loop_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 loop_file_fmt_qcow_has_data_file( + struct loop_file_fmt *lo_fmt) +{ + /* At the moment, there is no support for copy on write! */ + return false; +} + +static inline bool loop_file_fmt_qcow_data_file_is_raw( + struct loop_file_fmt *lo_fmt) +{ + struct loop_file_fmt_qcow_data *qcow_data = lo_fmt->private_data; + return !!(qcow_data->autoclear_features & + QCOW_AUTOCLEAR_DATA_FILE_RAW); +} + +static inline s64 loop_file_fmt_qcow_start_of_cluster( + struct loop_file_fmt_qcow_data *qcow_data, s64 offset) +{ + return offset & ~(qcow_data->cluster_size - 1); +} + +static inline s64 loop_file_fmt_qcow_offset_into_cluster( + struct loop_file_fmt_qcow_data *qcow_data, s64 offset) +{ + return offset & (qcow_data->cluster_size - 1); +} + +static inline s64 loop_file_fmt_qcow_size_to_clusters( + struct loop_file_fmt_qcow_data *qcow_data, u64 size) +{ + return (size + (qcow_data->cluster_size - 1)) >> + qcow_data->cluster_bits; +} + +static inline s64 loop_file_fmt_qcow_size_to_l1( + struct loop_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 loop_file_fmt_qcow_offset_to_l1_index( + struct loop_file_fmt_qcow_data *qcow_data, u64 offset) +{ + return offset >> (qcow_data->l2_bits + qcow_data->cluster_bits); +} + +static inline int loop_file_fmt_qcow_offset_to_l2_index( + struct loop_file_fmt_qcow_data *qcow_data, s64 offset) +{ + return (offset >> qcow_data->cluster_bits) & (qcow_data->l2_size - 1); +} + +static inline int loop_file_fmt_qcow_offset_to_l2_slice_index( + struct loop_file_fmt_qcow_data *qcow_data, s64 offset) +{ + return (offset >> qcow_data->cluster_bits) & + (qcow_data->l2_slice_size - 1); +} + +static inline s64 loop_file_fmt_qcow_vm_state_offset( + struct loop_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 loop_file_fmt_qcow_cluster_type +loop_file_fmt_qcow_get_cluster_type(struct loop_file_fmt *lo_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 (loop_file_fmt_qcow_has_data_file(lo_fmt) && + (l2_entry & QCOW_OFLAG_COPIED)) { + return QCOW_CLUSTER_NORMAL; + } else { + return QCOW_CLUSTER_UNALLOCATED; + } + } else { + return QCOW_CLUSTER_NORMAL; + } +} + +#endif diff --git a/drivers/block/loop/loop_file_fmt_raw.c b/drivers/block/loop/loop_file_fmt_raw.c new file mode 100644 index 000000000000..2399ac6474ad --- /dev/null +++ b/drivers/block/loop/loop_file_fmt_raw.c @@ -0,0 +1,449 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * loop_file_fmt_raw.c + * + * RAW file format driver for the loop device module. + * + * Copyright (C) 2019 Manuel Bentele <development@manuel-bentele.de> + */ + +#include <linux/module.h> +#include <linux/kernel.h> +#include <linux/init.h> +#include <linux/blkdev.h> +#include <linux/compiler.h> +#include <linux/blk-cgroup.h> +#include <linux/fs.h> +#include <linux/falloc.h> +#include <linux/printk.h> +#include <linux/sched.h> +#include <linux/types.h> +#include <linux/uio.h> + +#include "loop_file_fmt.h" + +static inline loff_t __raw_file_fmt_rq_get_pos(struct loop_file_fmt *lo_fmt, + struct request *rq) +{ + struct loop_device *lo = loop_file_fmt_get_lo(lo_fmt); + return ((loff_t) blk_rq_pos(rq) << 9) + lo->lo_offset; +} + +/* transfer function for DEPRECATED cryptoloop support */ +static inline int __raw_file_fmt_do_transfer(struct loop_file_fmt *lo_fmt, + int cmd, + struct page *rpage, + unsigned roffs, + struct page *lpage, + unsigned loffs, + int size, + sector_t rblock) +{ + struct loop_device *lo = loop_file_fmt_get_lo(lo_fmt); + int ret; + + ret = lo->transfer(lo, cmd, rpage, roffs, lpage, loffs, size, rblock); + if (likely(!ret)) + return 0; + + printk_ratelimited(KERN_ERR + "loop: 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 loop_file_fmt *lo_fmt, + struct request *rq) +{ + struct bio_vec bvec, b; + struct req_iterator iter; + struct iov_iter i; + struct page *page; + struct loop_device *lo; + ssize_t len; + int ret = 0; + loff_t pos; + + page = alloc_page(GFP_NOIO); + if (unlikely(!page)) + return -ENOMEM; + + lo = loop_file_fmt_get_lo(lo_fmt); + pos = __raw_file_fmt_rq_get_pos(lo_fmt, rq); + + 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(lo->lo_backing_file, &i, &pos, 0); + if (len < 0) { + ret = len; + goto out_free_page; + } + + ret = __raw_file_fmt_do_transfer(lo_fmt, 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 loop_file_fmt *lo_fmt, + struct request *rq) +{ + struct bio_vec bvec; + struct req_iterator iter; + struct iov_iter i; + struct loop_device *lo; + ssize_t len; + loff_t pos; + + lo = loop_file_fmt_get_lo(lo_fmt); + + if (lo->transfer) + return raw_file_fmt_read_transfer(lo_fmt, rq); + + pos = __raw_file_fmt_rq_get_pos(lo_fmt, rq); + + rq_for_each_segment(bvec, rq, iter) { + iov_iter_bvec(&i, READ, &bvec, 1, bvec.bv_len); + len = vfs_iter_read(lo->lo_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 loop_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; + blk_mq_complete_request(rq); +} + +static void __raw_file_fmt_rw_aio_complete(struct kiocb *iocb, long ret, long ret2) +{ + struct loop_cmd *cmd = container_of(iocb, struct loop_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 loop_file_fmt *lo_fmt, + struct request *rq, + bool rw) +{ + struct iov_iter iter; + struct req_iterator rq_iter; + struct bio_vec *bvec; + struct bio *bio = rq->bio; + struct file *file; + struct bio_vec tmp; + struct loop_device *lo; + struct loop_cmd *cmd; + unsigned int offset; + int nr_bvec = 0; + int ret; + loff_t pos; + + lo = loop_file_fmt_get_lo(lo_fmt); + file = lo->lo_backing_file; + cmd = blk_mq_rq_to_pdu(rq); + pos = __raw_file_fmt_rq_get_pos(lo_fmt, rq); + + 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 loop_file_fmt *lo_fmt, + struct request *rq) +{ + return __raw_file_fmt_rw_aio(lo_fmt, rq, 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 + "loop_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; +} + +static int raw_file_fmt_write_transfer(struct loop_file_fmt *lo_fmt, + struct request *rq) +{ + struct bio_vec bvec, b; + struct req_iterator iter; + struct page *page; + struct loop_device *lo; + int ret = 0; + loff_t pos; + + lo = loop_file_fmt_get_lo(lo_fmt); + pos = __raw_file_fmt_rq_get_pos(lo_fmt, rq); + + page = alloc_page(GFP_NOIO); + if (unlikely(!page)) + return -ENOMEM; + + rq_for_each_segment(bvec, rq, iter) { + ret = __raw_file_fmt_do_transfer(lo_fmt, 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(lo->lo_backing_file, &b, + &pos); + if (ret < 0) + break; + } + + __free_page(page); + return ret; +} + +static int raw_file_fmt_write(struct loop_file_fmt *lo_fmt, + struct request *rq) +{ + struct bio_vec bvec; + struct req_iterator iter; + struct loop_device *lo; + int ret = 0; + loff_t pos; + + lo = loop_file_fmt_get_lo(lo_fmt); + + if (lo->transfer) + return raw_file_fmt_write_transfer(lo_fmt, rq); + + pos = __raw_file_fmt_rq_get_pos(lo_fmt, rq); + + rq_for_each_segment(bvec, rq, iter) { + ret = __raw_file_fmt_write_bvec(lo->lo_backing_file, &bvec, + &pos); + if (ret < 0) + break; + cond_resched(); + } + + return ret; +} + +static int raw_file_fmt_write_aio(struct loop_file_fmt *lo_fmt, + struct request *rq) +{ + return __raw_file_fmt_rw_aio(lo_fmt, rq, WRITE); +} + +static int raw_file_fmt_discard(struct loop_file_fmt *lo_fmt, + struct request *rq) +{ + loff_t pos = __raw_file_fmt_rq_get_pos(lo_fmt, rq); + struct loop_device *lo = loop_file_fmt_get_lo(lo_fmt); + + /* + * 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. + */ + struct file *file = lo->lo_backing_file; + int mode = FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE; + int ret; + + if ((!file->f_op->fallocate) || lo->lo_encrypt_key_size) { + 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_flush(struct loop_file_fmt *lo_fmt) +{ + struct loop_device *lo = loop_file_fmt_get_lo(lo_fmt); + struct file *file = lo->lo_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 loop_file_fmt *lo_fmt) +{ + struct loop_device *lo = loop_file_fmt_get_lo(lo_fmt); + loff_t loopsize; + + /* Compute loopsize in bytes */ + loopsize = i_size_read(lo->lo_backing_file->f_mapping->host); + if (lo->lo_offset > 0) + loopsize -= lo->lo_offset; + /* offset is beyond i_size, weird but possible */ + if (loopsize < 0) + return 0; + + if (lo->lo_sizelimit > 0 && lo->lo_sizelimit < loopsize) + loopsize = lo->lo_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 loopsize >> 9; +} + +static struct loop_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, + .discard = raw_file_fmt_discard, + .flush = raw_file_fmt_flush, + .sector_size = raw_file_fmt_sector_size +}; + +static struct loop_file_fmt_driver raw_file_fmt_driver = { + .name = "RAW", + .file_fmt_type = LO_FILE_FMT_RAW, + .ops = &raw_file_fmt_ops, + .owner = THIS_MODULE +}; + +static int __init loop_file_fmt_raw_init(void) +{ + printk(KERN_INFO "loop_file_fmt_raw: init loop device RAW file format " + "driver"); + return loop_file_fmt_register_driver(&raw_file_fmt_driver); +} + +static void __exit loop_file_fmt_raw_exit(void) +{ + printk(KERN_INFO "loop_file_fmt_raw: exit loop device RAW file format " + "driver"); + loop_file_fmt_unregister_driver(&raw_file_fmt_driver); +} + +module_init(loop_file_fmt_raw_init); +module_exit(loop_file_fmt_raw_exit); + +MODULE_LICENSE("GPL"); +MODULE_AUTHOR("Manuel Bentele <development@manuel-bentele.de>"); +MODULE_DESCRIPTION("Loop device RAW file format driver"); +MODULE_SOFTDEP("pre: loop"); diff --git a/drivers/block/loop.c b/drivers/block/loop/loop_main.c index ab7ca5989097..b3d9577f45eb 100644 --- a/drivers/block/loop.c +++ b/drivers/block/loop/loop_main.c @@ -1,5 +1,5 @@ /* - * linux/drivers/block/loop.c + * loop_main.c * * Written by Theodore Ts'o, 3/29/93 * @@ -43,6 +43,9 @@ * operations write_begin is not available on the backing filesystem. * Anton Altaparmakov, 16 Feb 2005 * + * Support for using file formats. + * Manuel Bentele <development@manuel-bentele.de>, 2019 + * * Still To Fix: * - Advisory locking is ignored here. * - Should use an own CAP_* category instead of CAP_SYS_ADMIN @@ -79,7 +82,8 @@ #include <linux/ioprio.h> #include <linux/blk-cgroup.h> -#include "loop.h" +#include "loop_file_fmt.h" +#include "loop_main.h" #include <linux/uaccess.h> @@ -207,7 +211,7 @@ static void __loop_update_dio(struct loop_device *lo, bool dio) return; /* flush dirty pages before changing direct IO */ - vfs_fsync(file, 0); + loop_file_fmt_flush(lo->lo_fmt); /* * The flag of LO_FLAGS_DIRECT_IO is handled similarly with @@ -229,7 +233,7 @@ static void __loop_update_dio(struct loop_device *lo, bool dio) static int figure_loop_size(struct loop_device *lo, loff_t offset, loff_t sizelimit) { - loff_t size = get_size(offset, sizelimit, lo->lo_backing_file); + loff_t size = loop_file_fmt_sector_size(lo->lo_fmt); sector_t x = (sector_t)size; struct block_device *bdev = lo->lo_device; @@ -246,211 +250,6 @@ figure_loop_size(struct loop_device *lo, loff_t offset, loff_t sizelimit) return 0; } -static inline int -lo_do_transfer(struct loop_device *lo, int cmd, - struct page *rpage, unsigned roffs, - struct page *lpage, unsigned loffs, - int size, sector_t rblock) -{ - int ret; - - ret = lo->transfer(lo, cmd, rpage, roffs, lpage, loffs, size, rblock); - if (likely(!ret)) - return 0; - - printk_ratelimited(KERN_ERR - "loop: Transfer error at byte offset %llu, length %i.\n", - (unsigned long long)rblock << 9, size); - return ret; -} - -static int lo_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 - "loop: Write error at byte offset %llu, length %i.\n", - (unsigned long long)*ppos, bvec->bv_len); - if (bw >= 0) - bw = -EIO; - return bw; -} - -static int lo_write_simple(struct loop_device *lo, struct request *rq, - loff_t pos) -{ - struct bio_vec bvec; - struct req_iterator iter; - int ret = 0; - - rq_for_each_segment(bvec, rq, iter) { - ret = lo_write_bvec(lo->lo_backing_file, &bvec, &pos); - if (ret < 0) - break; - cond_resched(); - } - - return ret; -} - -/* - * 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 lo_write_transfer(struct loop_device *lo, 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 = lo_do_transfer(lo, 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 = lo_write_bvec(lo->lo_backing_file, &b, &pos); - if (ret < 0) - break; - } - - __free_page(page); - return ret; -} - -static int lo_read_simple(struct loop_device *lo, struct request *rq, - loff_t pos) -{ - struct bio_vec bvec; - struct req_iterator iter; - struct iov_iter i; - ssize_t len; - - rq_for_each_segment(bvec, rq, iter) { - iov_iter_bvec(&i, READ, &bvec, 1, bvec.bv_len); - len = vfs_iter_read(lo->lo_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 int lo_read_transfer(struct loop_device *lo, 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(lo->lo_backing_file, &i, &pos, 0); - if (len < 0) { - ret = len; - goto out_free_page; - } - - ret = lo_do_transfer(lo, 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 lo_discard(struct loop_device *lo, struct request *rq, loff_t pos) -{ - /* - * 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. - */ - struct file *file = lo->lo_backing_file; - int mode = FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE; - int ret; - - if ((!file->f_op->fallocate) || lo->lo_encrypt_key_size) { - 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 lo_req_flush(struct loop_device *lo, struct request *rq) -{ - struct file *file = lo->lo_backing_file; - int ret = vfs_fsync(file, 0); - if (unlikely(ret && ret != -EINVAL)) - ret = -EIO; - - return ret; -} - static void lo_complete_rq(struct request *rq) { struct loop_cmd *cmd = blk_mq_rq_to_pdu(rq); @@ -486,133 +285,26 @@ end_io: } } -static void lo_rw_aio_do_completion(struct loop_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; - blk_mq_complete_request(rq); -} - -static void lo_rw_aio_complete(struct kiocb *iocb, long ret, long ret2) -{ - struct loop_cmd *cmd = container_of(iocb, struct loop_cmd, iocb); - - if (cmd->css) - css_put(cmd->css); - cmd->ret = ret; - lo_rw_aio_do_completion(cmd); -} - -static int lo_rw_aio(struct loop_device *lo, struct loop_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 = lo->lo_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 = lo_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); - - lo_rw_aio_do_completion(cmd); - kthread_associate_blkcg(NULL); - - if (ret != -EIOCBQUEUED) - cmd->iocb.ki_complete(&cmd->iocb, ret, 0); - return 0; -} - static int do_req_filebacked(struct loop_device *lo, struct request *rq) { struct loop_cmd *cmd = blk_mq_rq_to_pdu(rq); - loff_t pos = ((loff_t) blk_rq_pos(rq) << 9) + lo->lo_offset; - /* - * lo_write_simple and lo_read_simple should have been covered - * by io submit style function like lo_rw_aio(), one blocker - * is that lo_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 lo_req_flush(lo, rq); + return loop_file_fmt_flush(lo->lo_fmt); case REQ_OP_DISCARD: case REQ_OP_WRITE_ZEROES: - return lo_discard(lo, rq, pos); + return loop_file_fmt_discard(lo->lo_fmt, rq); case REQ_OP_WRITE: - if (lo->transfer) - return lo_write_transfer(lo, rq, pos); - else if (cmd->use_aio) - return lo_rw_aio(lo, cmd, pos, WRITE); + if (cmd->use_aio) + return loop_file_fmt_write_aio(lo->lo_fmt, rq); else - return lo_write_simple(lo, rq, pos); + return loop_file_fmt_write(lo->lo_fmt, rq); case REQ_OP_READ: - if (lo->transfer) - return lo_read_transfer(lo, rq, pos); - else if (cmd->use_aio) - return lo_rw_aio(lo, cmd, pos, READ); + if (cmd->use_aio) + return loop_file_fmt_read_aio(lo->lo_fmt, rq); else - return lo_read_simple(lo, rq, pos); + return loop_file_fmt_read(lo->lo_fmt, rq); default: WARN_ON_ONCE(1); return -EIO; @@ -781,6 +473,16 @@ static ssize_t loop_attr_backing_file_show(struct loop_device *lo, char *buf) return ret; } +static ssize_t loop_attr_file_fmt_type_show(struct loop_device *lo, char *buf) +{ + ssize_t len = 0; + + len = loop_file_fmt_print_type(lo->lo_fmt->file_fmt_type, buf); + len += sprintf(buf + len, "\n"); + + return len; +} + static ssize_t loop_attr_offset_show(struct loop_device *lo, char *buf) { return sprintf(buf, "%llu\n", (unsigned long long)lo->lo_offset); @@ -813,6 +515,7 @@ static ssize_t loop_attr_dio_show(struct loop_device *lo, char *buf) } LOOP_ATTR_RO(backing_file); +LOOP_ATTR_RO(file_fmt_type); LOOP_ATTR_RO(offset); LOOP_ATTR_RO(sizelimit); LOOP_ATTR_RO(autoclear); @@ -821,6 +524,7 @@ LOOP_ATTR_RO(dio); static struct attribute *loop_attrs[] = { &loop_attr_backing_file.attr, + &loop_attr_file_fmt_type.attr, &loop_attr_offset.attr, &loop_attr_sizelimit.attr, &loop_attr_autoclear.attr, @@ -969,16 +673,6 @@ static int loop_set_fd(struct loop_device *lo, fmode_t mode, !file->f_op->write_iter) lo_flags |= LO_FLAGS_READ_ONLY; - error = -EFBIG; - size = get_loop_size(lo, file); - if ((loff_t)(sector_t)size != size) - goto out_unlock; - error = loop_prepare_queue(lo); - if (error) - goto out_unlock; - - error = 0; - set_device_ro(bdev, (lo_flags & LO_FLAGS_READ_ONLY) != 0); lo->use_dio = false; @@ -996,6 +690,20 @@ static int loop_set_fd(struct loop_device *lo, fmode_t mode, loop_update_rotational(lo); loop_update_dio(lo); + + error = loop_file_fmt_init(lo->lo_fmt, LO_FILE_FMT_RAW); + if (error) + goto out_unlock; + + size = loop_file_fmt_sector_size(lo->lo_fmt); + + error = -EFBIG; + if ((loff_t)(sector_t)size != size) + goto out_unlock; + error = loop_prepare_queue(lo); + if (error) + goto out_unlock; + set_capacity(lo->lo_disk, size); bd_set_size(bdev, size << 9); loop_sysfs_init(lo); @@ -1095,6 +803,8 @@ static int __loop_clr_fd(struct loop_device *lo, bool release) /* freeze request queue during the transition */ blk_mq_freeze_queue(lo->lo_queue); + loop_file_fmt_exit(lo->lo_fmt); + spin_lock_irq(&lo->lo_lock); lo->lo_backing_file = NULL; spin_unlock_irq(&lo->lo_lock); @@ -1289,6 +999,21 @@ loop_set_status(struct loop_device *lo, const struct loop_info64 *info) } } + if (lo->lo_fmt->file_fmt_type != info->lo_file_fmt_type) { + err = loop_file_fmt_change(lo->lo_fmt, info->lo_file_fmt_type); + if (err) + goto out_unfreeze; + + /* After change of the file format, recalculate the capacity of + * the loop device. figure_loop_size() automatically calls the + * sector_size function of the corresponding loop file format + * driver to determine the new capacity. */ + if (figure_loop_size(lo, info->lo_offset, info->lo_sizelimit)) { + err = -EFBIG; + goto out_unfreeze; + } + } + loop_config_discard(lo); memcpy(lo->lo_file_name, info->lo_file_name, LO_NAME_SIZE); @@ -1364,6 +1089,7 @@ loop_get_status(struct loop_device *lo, struct loop_info64 *info) memcpy(info->lo_encrypt_key, lo->lo_encrypt_key, lo->lo_encrypt_key_size); } + info->lo_file_fmt_type = lo->lo_fmt->file_fmt_type; /* Drop loop_ctl_mutex while we call into the filesystem. */ path = lo->lo_backing_file->f_path; @@ -1394,6 +1120,7 @@ loop_info64_from_old(const struct loop_info *info, struct loop_info64 *info64) info64->lo_flags = info->lo_flags; info64->lo_init[0] = info->lo_init[0]; info64->lo_init[1] = info->lo_init[1]; + info64->lo_file_fmt_type = info->lo_file_fmt_type; if (info->lo_encrypt_type == LO_CRYPT_CRYPTOAPI) memcpy(info64->lo_crypt_name, info->lo_name, LO_NAME_SIZE); else @@ -1415,6 +1142,7 @@ loop_info64_to_old(const struct loop_info64 *info64, struct loop_info *info) info->lo_flags = info64->lo_flags; info->lo_init[0] = info64->lo_init[0]; info->lo_init[1] = info64->lo_init[1]; + info->lo_file_fmt_type = info64->lo_file_fmt_type; if (info->lo_encrypt_type == LO_CRYPT_CRYPTOAPI) memcpy(info->lo_name, info64->lo_crypt_name, LO_NAME_SIZE); else @@ -1436,9 +1164,22 @@ loop_set_status_old(struct loop_device *lo, const struct loop_info __user *arg) { struct loop_info info; struct loop_info64 info64; + int err; - if (copy_from_user(&info, arg, sizeof (struct loop_info))) + /* backward compatibility: copy everything except the file format type + * field */ + err = copy_from_user(&info, arg, + sizeof(info) - sizeof(info.lo_file_fmt_type)); + if (err) return -EFAULT; + + if (info.lo_flags & LO_FLAGS_FILE_FMT) { + /* copy everything from the user space */ + err = copy_from_user(&info, arg, sizeof(info)); + if (err) + return -EFAULT; + } + loop_info64_from_old(&info, &info64); return loop_set_status(lo, &info64); } @@ -1447,9 +1188,22 @@ static int loop_set_status64(struct loop_device *lo, const struct loop_info64 __user *arg) { struct loop_info64 info64; + int err; - if (copy_from_user(&info64, arg, sizeof (struct loop_info64))) + /* backward compatibility: copy everything except the file format type + * field */ + err = copy_from_user(&info64, arg, + sizeof(info64) - sizeof(info64.lo_file_fmt_type)); + if (err) return -EFAULT; + + if (info64.lo_flags & LO_FLAGS_FILE_FMT) { + /* copy everything from the user space */ + err = copy_from_user(&info64, arg, sizeof(info64)); + if (err) + return -EFAULT; + } + return loop_set_status(lo, &info64); } @@ -1457,15 +1211,37 @@ static int loop_get_status_old(struct loop_device *lo, struct loop_info __user *arg) { struct loop_info info; struct loop_info64 info64; + int lo_flags; int err; if (!arg) return -EINVAL; + + /* backward compatibility: copy everything except the file format type + * field */ + err = copy_from_user(&info, arg, + sizeof(info) - sizeof(info.lo_file_fmt_type)); + if (err) + return -EFAULT; + + lo_flags = info.lo_flags; + err = loop_get_status(lo, &info64); if (!err) err = loop_info64_to_old(&info64, &info); - if (!err && copy_to_user(arg, &info, sizeof(info))) - err = -EFAULT; + + if (lo_flags & LO_FLAGS_FILE_FMT) { + /* copy entire structure to user space because file format + * support is available */ + err = copy_to_user(arg, &info, sizeof(info)); + } else { + /* copy normal structure to user space */ + err = copy_to_user(arg, &info, + sizeof(info) - sizeof(info.lo_file_fmt_type)); + } + + if (err) + return -EFAULT; return err; } @@ -1473,13 +1249,37 @@ loop_get_status_old(struct loop_device *lo, struct loop_info __user *arg) { static int loop_get_status64(struct loop_device *lo, struct loop_info64 __user *arg) { struct loop_info64 info64; + u32 lo_flags; int err; if (!arg) return -EINVAL; + + /* backward compatibility: copy everything except the file format type + * field */ + err = copy_from_user(&info64, arg, + sizeof(info64) - sizeof(info64.lo_file_fmt_type)); + if (err) + return -EFAULT; + + lo_flags = info64.lo_flags; + err = loop_get_status(lo, &info64); - if (!err && copy_to_user(arg, &info64, sizeof(info64))) - err = -EFAULT; + if (err) + return -EFAULT; + + if (lo_flags & LO_FLAGS_FILE_FMT) { + /* copy entire structure to user space because file format + * support is available */ + err = copy_to_user(arg, &info64, sizeof(info64)); + } else { + /* copy normal structure to user space */ + err = copy_to_user(arg, &info64, + sizeof(info64) - sizeof(info64.lo_file_fmt_type)); + } + + if (err) + return -EFAULT; return err; } @@ -1627,7 +1427,8 @@ struct compat_loop_info { unsigned char lo_encrypt_key[LO_KEY_SIZE]; /* ioctl w/o */ compat_ulong_t lo_init[2]; char reserved[4]; -}; + compat_int_t lo_file_fmt_type; +} __attribute__((packed)); /* * Transfer 32-bit compatibility structure in userspace to 64-bit loop info @@ -1638,10 +1439,22 @@ loop_info64_from_compat(const struct compat_loop_info __user *arg, struct loop_info64 *info64) { struct compat_loop_info info; + int err; - if (copy_from_user(&info, arg, sizeof(info))) + /* backward compatibility: copy everything except the file format type + * field */ + err = copy_from_user(&info, arg, + sizeof(info) - sizeof(info.lo_file_fmt_type)); + if (err) return -EFAULT; + if (info.lo_flags & LO_FLAGS_FILE_FMT) { + /* copy everything from the user space */ + err = copy_from_user(&info, arg, sizeof(info)); + if (err) + return -EFAULT; + } + memset(info64, 0, sizeof(*info64)); info64->lo_number = info.lo_number; info64->lo_device = info.lo_device; @@ -1654,6 +1467,7 @@ loop_info64_from_compat(const struct compat_loop_info __user *arg, info64->lo_flags = info.lo_flags; info64->lo_init[0] = info.lo_init[0]; info64->lo_init[1] = info.lo_init[1]; + info64->lo_file_fmt_type = info.lo_file_fmt_type; if (info.lo_encrypt_type == LO_CRYPT_CRYPTOAPI) memcpy(info64->lo_crypt_name, info.lo_name, LO_NAME_SIZE); else @@ -1671,6 +1485,17 @@ loop_info64_to_compat(const struct loop_info64 *info64, struct compat_loop_info __user *arg) { struct compat_loop_info info; + compat_int_t lo_flags; + int err; + + /* backward compatibility: copy everything except the file format type + * field */ + err = copy_from_user(&info, arg, + sizeof(info) - sizeof(info.lo_file_fmt_type)); + if (err) + return -EFAULT; + + lo_flags = info.lo_flags; memset(&info, 0, sizeof(info)); info.lo_number = info64->lo_number; @@ -1683,6 +1508,7 @@ loop_info64_to_compat(const struct loop_info64 *info64, info.lo_flags = info64->lo_flags; info.lo_init[0] = info64->lo_init[0]; info.lo_init[1] = info64->lo_init[1]; + info.lo_file_fmt_type = info64->lo_file_fmt_type; if (info.lo_encrypt_type == LO_CRYPT_CRYPTOAPI) memcpy(info.lo_name, info64->lo_crypt_name, LO_NAME_SIZE); else @@ -1695,10 +1521,21 @@ loop_info64_to_compat(const struct loop_info64 *info64, info.lo_inode != info64->lo_inode || info.lo_offset != info64->lo_offset || info.lo_init[0] != info64->lo_init[0] || - info.lo_init[1] != info64->lo_init[1]) + info.lo_init[1] != info64->lo_init[1] || + info.lo_file_fmt_type != info64->lo_file_fmt_type) return -EOVERFLOW; - if (copy_to_user(arg, &info, sizeof(info))) + if (lo_flags & LO_FLAGS_FILE_FMT) { + /* copy entire structure to user space because file format + * support is available */ + err = copy_to_user(arg, &info, sizeof(info)); + } else { + /* copy normal structure to user space */ + err = copy_to_user(arg, &info, + sizeof(info) - sizeof(info.lo_file_fmt_type)); + } + + if (err) return -EFAULT; return 0; } @@ -1957,6 +1794,8 @@ static const struct blk_mq_ops loop_mq_ops = { .complete = lo_complete_rq, }; +static struct dentry *loop_dbgfs_dir; + static int loop_add(struct loop_device **l, int i) { struct loop_device *lo; @@ -2013,9 +1852,16 @@ static int loop_add(struct loop_device **l, int i) blk_queue_flag_set(QUEUE_FLAG_NOMERGES, lo->lo_queue); err = -ENOMEM; + lo->lo_fmt = loop_file_fmt_alloc(); + if (!lo->lo_fmt) + goto out_free_queue; + + loop_file_fmt_set_lo(lo->lo_fmt, lo); + + err = -ENOMEM; disk = lo->lo_disk = alloc_disk(1 << part_shift); if (!disk) - goto out_free_queue; + goto out_free_file_fmt; /* * Disable partition scanning by default. The in-kernel partition @@ -2049,8 +1895,25 @@ static int loop_add(struct loop_device **l, int i) sprintf(disk->disk_name, "loop%d", i); add_disk(disk); *l = lo; + + /* 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 + lo->lo_dbgfs_dir = debugfs_create_dir(disk->disk_name, loop_dbgfs_dir); + + if (IS_ERR_OR_NULL(lo->lo_dbgfs_dir)) { + err = -ENODEV; + lo->lo_dbgfs_dir = NULL; + goto out_free_file_fmt; + } +#endif + return lo->lo_number; +out_free_file_fmt: + loop_file_fmt_free(lo->lo_fmt); out_free_queue: blk_cleanup_queue(lo->lo_queue); out_cleanup_tags: @@ -2065,6 +1928,8 @@ out: static void loop_remove(struct loop_device *lo) { + loop_file_fmt_free(lo->lo_fmt); + debugfs_remove(lo->lo_dbgfs_dir); del_gendisk(lo->lo_disk); blk_cleanup_queue(lo->lo_queue); blk_mq_free_tag_set(&lo->tag_set); @@ -2252,6 +2117,14 @@ static int __init loop_init(void) goto misc_out; } +#ifdef CONFIG_DEBUG_FS + loop_dbgfs_dir = debugfs_create_dir("loop", NULL); + if (IS_ERR_OR_NULL(loop_dbgfs_dir)) { + err = -ENODEV; + goto misc_out; + } +#endif + blk_register_region(MKDEV(LOOP_MAJOR, 0), range, THIS_MODULE, loop_probe, NULL, NULL); @@ -2290,6 +2163,10 @@ static void __exit loop_exit(void) blk_unregister_region(MKDEV(LOOP_MAJOR, 0), range); unregister_blkdev(LOOP_MAJOR, "loop"); +#ifdef CONFIG_DEBUG_FS + debugfs_remove(loop_dbgfs_dir); +#endif + misc_deregister(&loop_misc); } diff --git a/drivers/block/loop.h b/drivers/block/loop/loop_main.h index af75a5ee4094..33f6578d54c7 100644 --- a/drivers/block/loop.h +++ b/drivers/block/loop/loop_main.h @@ -1,5 +1,5 @@ /* - * loop.h + * loop_main.h * * Written by Theodore Ts'o, 3/29/93. * @@ -17,6 +17,12 @@ #include <linux/kthread.h> #include <uapi/linux/loop.h> +#ifdef CONFIG_DEBUG_FS +#include <linux/debugfs.h> +#endif + +#include "loop_file_fmt.h" + /* Possible states of device */ enum { Lo_unbound, @@ -46,6 +52,8 @@ struct loop_device { int (*ioctl)(struct loop_device *, int cmd, unsigned long arg); + struct loop_file_fmt *lo_fmt; + struct file * lo_backing_file; struct block_device *lo_device; void *key_data; @@ -62,6 +70,10 @@ struct loop_device { struct request_queue *lo_queue; struct blk_mq_tag_set tag_set; struct gendisk *lo_disk; + +#ifdef CONFIG_DEBUG_FS + struct dentry *lo_dbgfs_dir; +#endif }; struct loop_cmd { diff --git a/include/uapi/linux/loop.h b/include/uapi/linux/loop.h index 080a8df134ef..07a9db82d2bd 100644 --- a/include/uapi/linux/loop.h +++ b/include/uapi/linux/loop.h @@ -23,6 +23,7 @@ enum { LO_FLAGS_AUTOCLEAR = 4, LO_FLAGS_PARTSCAN = 8, LO_FLAGS_DIRECT_IO = 16, + LO_FLAGS_FILE_FMT = 32 /* indicates file format support */ }; #include <asm/posix_types.h> /* for __kernel_old_dev_t */ @@ -42,6 +43,7 @@ struct loop_info { unsigned char lo_encrypt_key[LO_KEY_SIZE]; /* ioctl w/o */ unsigned long lo_init[2]; char reserved[4]; + int lo_file_fmt_type; }; struct loop_info64 { @@ -58,7 +60,8 @@ struct loop_info64 { __u8 lo_crypt_name[LO_NAME_SIZE]; __u8 lo_encrypt_key[LO_KEY_SIZE]; /* ioctl w/o */ __u64 lo_init[2]; -}; + __u32 lo_file_fmt_type; +} __attribute__((packed)); /* * Loop filter types @@ -77,6 +80,15 @@ struct loop_info64 { #define MAX_LO_CRYPT 20 /* + * Loop file format types + */ +#define LO_FILE_FMT_RAW 0 +#define LO_FILE_FMT_QCOW 1 +#define LO_FILE_FMT_VDI 2 +#define LO_FILE_FMT_VMDK 3 +#define MAX_LO_FILE_FMT LO_FILE_FMT_VMDK + 1 + +/* * IOCTL commands --- we will commandeer 0x4C ('L') */ |