pstore/blk: Use the normal block device I/O path

.. kernel-doc:: include/linux/pstore_zone.h

   :internal:

.. kernel-doc:: fs/pstore/blk.c

   :internal:

.. kernel-doc:: include/linux/pstore_blk.h

   :internal:

#include <linux/kernel.h>

#include <linux/module.h>

#include "../../block/blk.h"

#include <linux/blkdev.h>

#include <linux/string.h>

#include <linux/of.h>

#include <linux/of_address.h>

#include <linux/platform_device.h>

#include <linux/pstore_blk.h>

#include <linux/fs.h>

#include <linux/file.h>

#include <linux/init_syscalls.h>

#include <linux/mount.h>

#include <linux/uio.h>

static long kmsg_size = CONFIG_PSTORE_BLK_KMSG_SIZE;

module_param(kmsg_size, long, 0400);

 *

 * Usually, this will be a partition of a block device.

 *

 * blkdev accepts the following variants:

 * 1) <hex_major><hex_minor> device number in hexadecimal representation,

 *    with no leading 0x, for example b302.

 * 2) /dev/<disk_name> represents the device number of disk

 * 3) /dev/<disk_name><decimal> represents the device number

 * blkdev accepts the following variants, when built as a module:

 * 1) /dev/<disk_name> represents the device number of disk

 * 2) /dev/<disk_name><decimal> represents the device number

 *    of partition - device number of disk plus the partition number

 * 4) /dev/<disk_name>p<decimal> - same as the above, that form is

 * 3) /dev/<disk_name>p<decimal> - same as the above, that form is

 *    used when disk name of partitioned disk ends on a digit.

 * 5) PARTUUID=00112233-4455-6677-8899-AABBCCDDEEFF representing the

 *

 * blkdev accepts the following variants when built into the kernel:

 * 1) <hex_major><hex_minor> device number in hexadecimal representation,

 *    with no leading 0x, for example b302.

 * 2) PARTUUID=00112233-4455-6677-8899-AABBCCDDEEFF representing the

 *    unique id of a partition if the partition table provides it.

 *    The UUID may be either an EFI/GPT UUID, or refer to an MSDOS

 *    partition using the format SSSSSSSS-PP, where SSSSSSSS is a zero-

 *    filled hex representation of the 32-bit "NT disk signature", and PP

 *    is a zero-filled hex representation of the 1-based partition number.

 * 6) PARTUUID=<UUID>/PARTNROFF=<int> to select a partition in relation to

 * 3) PARTUUID=<UUID>/PARTNROFF=<int> to select a partition in relation to

 *    a partition with a known unique id.

 * 7) <major>:<minor> major and minor number of the device separated by

 * 4) <major>:<minor> major and minor number of the device separated by

 *    a colon.

 */

static char blkdev[80] = CONFIG_PSTORE_BLK_BLKDEV;

 * during the register/unregister functions.

 */

static DEFINE_MUTEX(pstore_blk_lock);

static struct block_device *psblk_bdev;

static struct file *psblk_file;

static struct pstore_zone_info *pstore_zone_info;

struct bdev_info {

	dev_t devt;

	sector_t nr_sects;

	sector_t start_sect;

};

#define check_size(name, alignsize) ({				\

	long _##name_ = (name);					\

	_##name_ = _##name_ <= 0 ? 0 : (_##name_ * 1024);	\

}

EXPORT_SYMBOL_GPL(unregister_pstore_device);

/**

 * psblk_get_bdev() - open block device

 *

 * @holder:	Exclusive holder identifier

 * @info:	Information about bdev to fill in

 *

 * Return: pointer to block device on success and others on error.

 *

 * On success, the returned block_device has reference count of one.

 */

static struct block_device *psblk_get_bdev(void *holder,

					   struct bdev_info *info)

{

	struct block_device *bdev = ERR_PTR(-ENODEV);

	fmode_t mode = FMODE_READ | FMODE_WRITE;

	sector_t nr_sects;

	lockdep_assert_held(&pstore_blk_lock);

	if (pstore_zone_info)

		return ERR_PTR(-EBUSY);

	if (!blkdev[0])

		return ERR_PTR(-ENODEV);

	if (holder)

		mode |= FMODE_EXCL;

	bdev = blkdev_get_by_path(blkdev, mode, holder);

	if (IS_ERR(bdev)) {

		dev_t devt;

		devt = name_to_dev_t(blkdev);

		if (devt == 0)

			return ERR_PTR(-ENODEV);

		bdev = blkdev_get_by_dev(devt, mode, holder);

		if (IS_ERR(bdev))

			return bdev;

	}

	nr_sects = bdev_nr_sectors(bdev);

	if (!nr_sects) {

		pr_err("not enough space for '%s'\n", blkdev);

		blkdev_put(bdev, mode);

		return ERR_PTR(-ENOSPC);

	}

	if (info) {

		info->devt = bdev->bd_dev;

		info->nr_sects = nr_sects;

		info->start_sect = get_start_sect(bdev);

	}

	return bdev;

}

static void psblk_put_bdev(struct block_device *bdev, void *holder)

{

	fmode_t mode = FMODE_READ | FMODE_WRITE;

	lockdep_assert_held(&pstore_blk_lock);

	if (!bdev)

		return;

	if (holder)

		mode |= FMODE_EXCL;

	blkdev_put(bdev, mode);

}

static ssize_t psblk_generic_blk_read(char *buf, size_t bytes, loff_t pos)

{

	struct block_device *bdev = psblk_bdev;

	struct file file;

	struct kiocb kiocb;

	struct iov_iter iter;

	struct kvec iov = {.iov_base = buf, .iov_len = bytes};

	if (!bdev)

		return -ENODEV;

	memset(&file, 0, sizeof(struct file));

	file.f_mapping = bdev->bd_inode->i_mapping;

	file.f_flags = O_DSYNC | __O_SYNC | O_NOATIME;

	file.f_inode = bdev->bd_inode;

	file_ra_state_init(&file.f_ra, file.f_mapping);

	init_sync_kiocb(&kiocb, &file);

	kiocb.ki_pos = pos;

	iov_iter_kvec(&iter, READ, &iov, 1, bytes);

	return generic_file_read_iter(&kiocb, &iter);

	return kernel_read(psblk_file, buf, bytes, &pos);

}

static ssize_t psblk_generic_blk_write(const char *buf, size_t bytes,

		loff_t pos)

{

	struct block_device *bdev = psblk_bdev;

	struct iov_iter iter;

	struct kiocb kiocb;

	struct file file;

	ssize_t ret;

	struct kvec iov = {.iov_base = (void *)buf, .iov_len = bytes};

	if (!bdev)

		return -ENODEV;

	/* Console/Ftrace backend may handle buffer until flush dirty zones */

	if (in_interrupt() || irqs_disabled())

		return -EBUSY;

	memset(&file, 0, sizeof(struct file));

	file.f_mapping = bdev->bd_inode->i_mapping;

	file.f_flags = O_DSYNC | __O_SYNC | O_NOATIME;

	file.f_inode = bdev->bd_inode;

	init_sync_kiocb(&kiocb, &file);

	kiocb.ki_pos = pos;

	iov_iter_kvec(&iter, WRITE, &iov, 1, bytes);

	inode_lock(bdev->bd_inode);

	ret = generic_write_checks(&kiocb, &iter);

	if (ret > 0)

		ret = generic_perform_write(&file, &iter, pos);

	inode_unlock(bdev->bd_inode);

	if (likely(ret > 0)) {

		const struct file_operations f_op = {.fsync = blkdev_fsync};

		file.f_op = &f_op;

		kiocb.ki_pos += ret;

		ret = generic_write_sync(&kiocb, ret);

	}

	return ret;

	return kernel_write(psblk_file, buf, bytes, &pos);

}

/*

 * This takes its configuration only from the module parameters now.

 * See psblk_get_bdev() and blkdev.

 */

static int __register_pstore_blk(void)

static int __register_pstore_blk(const char *devpath)

{

	char bdev_name[BDEVNAME_SIZE];

	struct block_device *bdev;

	struct pstore_device_info dev;

	struct bdev_info binfo;

	void *holder = blkdev;

	struct pstore_device_info dev = {

		.read = psblk_generic_blk_read,

		.write = psblk_generic_blk_write,

	};

	struct inode *inode;

	int ret = -ENODEV;

	lockdep_assert_held(&pstore_blk_lock);

	/* hold bdev exclusively */

	memset(&binfo, 0, sizeof(binfo));

	bdev = psblk_get_bdev(holder, &binfo);

	if (IS_ERR(bdev)) {

		pr_err("failed to open '%s'!\n", blkdev);

		return PTR_ERR(bdev);

	psblk_file = filp_open(devpath, O_RDWR | O_DSYNC | O_NOATIME | O_EXCL, 0);

	if (IS_ERR(psblk_file)) {

		ret = PTR_ERR(psblk_file);

		pr_err("failed to open '%s': %d!\n", devpath, ret);

		goto err;

	}

	/* only allow driver matching the @blkdev */

	if (!binfo.devt) {

		pr_debug("no major\n");

		ret = -ENODEV;

		goto err_put_bdev;

	inode = file_inode(psblk_file);

	if (!S_ISBLK(inode->i_mode)) {

		pr_err("'%s' is not block device!\n", devpath);

		goto err_fput;

	}

	/* psblk_bdev must be assigned before register to pstore/blk */

	psblk_bdev = bdev;

	memset(&dev, 0, sizeof(dev));

	dev.total_size = binfo.nr_sects << SECTOR_SHIFT;

	dev.read = psblk_generic_blk_read;

	dev.write = psblk_generic_blk_write;

	inode = I_BDEV(psblk_file->f_mapping->host)->bd_inode;

	dev.total_size = i_size_read(inode);

	ret = __register_pstore_device(&dev);

	if (ret)

		goto err_put_bdev;

		goto err_fput;

	bdevname(bdev, bdev_name);

	pr_info("attached %s (no dedicated panic_write!)\n", bdev_name);

	return 0;

err_put_bdev:

	psblk_bdev = NULL;

	psblk_put_bdev(bdev, holder);

err_fput:

	fput(psblk_file);

err:

	psblk_file = NULL;

	return ret;

}

static void __unregister_pstore_blk(unsigned int major)

static void __unregister_pstore_blk(struct file *device)

{

	struct pstore_device_info dev = { .read = psblk_generic_blk_read };

	void *holder = blkdev;

	lockdep_assert_held(&pstore_blk_lock);

	if (psblk_bdev && MAJOR(psblk_bdev->bd_dev) == major) {

	if (psblk_file && psblk_file == device) {

		__unregister_pstore_device(&dev);

		psblk_put_bdev(psblk_bdev, holder);

		psblk_bdev = NULL;

		fput(psblk_file);

		psblk_file = NULL;

	}

}

}

EXPORT_SYMBOL_GPL(pstore_blk_get_config);

#ifndef MODULE

static const char devname[] = "/dev/pstore-blk";

static __init const char *early_boot_devpath(const char *initial_devname)

{

	/*

	 * During early boot the real root file system hasn't been

	 * mounted yet, and no device nodes are present yet. Use the

	 * same scheme to find the device that we use for mounting

	 * the root file system.

	 */

	dev_t dev = name_to_dev_t(initial_devname);

	if (!dev) {

		pr_err("failed to resolve '%s'!\n", initial_devname);

		return initial_devname;

	}

	init_unlink(devname);

	init_mknod(devname, S_IFBLK | 0600, new_encode_dev(dev));

	return devname;

}

#else

static inline const char *early_boot_devpath(const char *initial_devname)

{

	return initial_devname;

}

#endif

static int __init pstore_blk_init(void)

{

	int ret = 0;

	mutex_lock(&pstore_blk_lock);

	if (!pstore_zone_info && best_effort && blkdev[0])

		ret = __register_pstore_blk();

	if (!pstore_zone_info && best_effort && blkdev[0]) {

		ret = __register_pstore_blk(early_boot_devpath(blkdev));

		if (ret == 0 && pstore_zone_info)

			pr_info("attached %s:%s (%zu) (no dedicated panic_write!)\n",

				pstore_zone_info->name, blkdev,

				pstore_zone_info->total_size);

	}

	mutex_unlock(&pstore_blk_lock);

	return ret;

static void __exit pstore_blk_exit(void)

{

	mutex_lock(&pstore_blk_lock);

	if (psblk_bdev)

		__unregister_pstore_blk(MAJOR(psblk_bdev->bd_dev));

	if (psblk_file)

		__unregister_pstore_blk(psblk_file);

	else {

		struct pstore_device_info dev = { };