Merge tag 'pstore-v5.14-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/kees/linux (07bdc074) · Commits · EulixOS / Software / Kernel

Documentation/admin-guide/pstore-blk.rst

+7 −7

Original line number	Diff line number	Diff line
		@@ -45,15 +45,18 @@ blkdev
		The block device to use. Most of the time, it is a partition of block device.
		It's required for pstore/blk. It is also used for MTD device.

		It accepts the following variants for block device:
		When pstore/blk is built as a module, "blkdev" accepts the following variants:

		1. <hex_major><hex_minor> device number in hexadecimal represents itself; no
		leading 0x, for example b302.
		#. /dev/<disk_name> represents the device number of disk
		1. /dev/<disk_name> represents the device number of disk
		#. /dev/<disk_name><decimal> represents the device number of partition - device
		number of disk plus the partition number
		#. /dev/<disk_name>p<decimal> - same as the above; this form is used when disk
		name of partitioned disk ends with a digit.

		When pstore/blk is built into the kernel, "blkdev" accepts the following variants:

		#. <hex_major><hex_minor> device number in hexadecimal representation,
		with no leading 0x, for example b302.
		#. PARTUUID=00112233-4455-6677-8899-AABBCCDDEEFF represents 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,
		@@ -227,8 +230,5 @@ For developer reference, here are all the important structures and APIs:
		.. kernel-doc:: include/linux/pstore_zone.h
		:internal:

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

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

drivers/mtd/mtdpstore.c

+5 −5

Original line number	Diff line number	Diff line
		@@ -423,13 +423,13 @@ static void mtdpstore_notify_add(struct mtd_info *mtd)
		longcnt = BITS_TO_LONGS(div_u64(mtd->size, mtd->erasesize));
		cxt->badmap = kcalloc(longcnt, sizeof(long), GFP_KERNEL);

		cxt->dev.total_size = mtd->size;
		/* just support dmesg right now */
		cxt->dev.flags = PSTORE_FLAGS_DMESG;
		cxt->dev.read = mtdpstore_read;
		cxt->dev.write = mtdpstore_write;
		cxt->dev.erase = mtdpstore_erase;
		cxt->dev.panic_write = mtdpstore_panic_write;
		cxt->dev.zone.read = mtdpstore_read;
		cxt->dev.zone.write = mtdpstore_write;
		cxt->dev.zone.erase = mtdpstore_erase;
		cxt->dev.zone.panic_write = mtdpstore_panic_write;
		cxt->dev.zone.total_size = mtd->size;

		ret = register_pstore_device(&cxt->dev);
		if (ret) {

fs/pstore/blk.c

+156 −247

Original line number	Diff line number	Diff line
		@@ -8,15 +8,16 @@

		#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);
		@@ -57,27 +58,7 @@ MODULE_PARM_DESC(best_effort, "use best effort to write (i.e. do not require sto

		/*
		* blkdev - the block device to use for pstore storage
		*
		* 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
		* of partition - device number of disk plus the partition number
		* 4) /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
		* 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
		* a partition with a known unique id.
		* 7) <major>:<minor> major and minor number of the device separated by
		* a colon.
		* See Documentation/admin-guide/pstore-blk.rst for details.
		*/
		static char blkdev[80] = CONFIG_PSTORE_BLK_BLKDEV;
		module_param_string(blkdev, blkdev, 80, 0400);
		@@ -88,14 +69,8 @@ MODULE_PARM_DESC(blkdev, "block device for pstore storage");
		* during the register/unregister functions.
		*/
		static DEFINE_MUTEX(pstore_blk_lock);
		static struct block_device *psblk_bdev;
		static struct pstore_zone_info *pstore_zone_info;

		struct bdev_info {
		dev_t devt;
		sector_t nr_sects;
		sector_t start_sect;
		};
		static struct file *psblk_file;
		static struct pstore_device_info *pstore_device_info;

		#define check_size(name, alignsize) ({ \
		long _##name_ = (name); \
		@@ -108,57 +83,63 @@ struct bdev_info {
		_##name_; \
		})

		#define verify_size(name, alignsize, enabled) { \
		long _##name_; \
		if (enabled) \
		_##name_ = check_size(name, alignsize); \
		else \
		_##name_ = 0; \
		/* Synchronize module parameters with resuls. */ \
		name = _##name_ / 1024; \
		dev->zone.name = _##name_; \
		}

		static int __register_pstore_device(struct pstore_device_info *dev)
		{
		int ret;

		lockdep_assert_held(&pstore_blk_lock);

		if (!dev \|\| !dev->total_size \|\| !dev->read \|\| !dev->write)
		if (!dev) {
		pr_err("NULL device info\n");
		return -EINVAL;
		}
		if (!dev->zone.total_size) {
		pr_err("zero sized device\n");
		return -EINVAL;
		}
		if (!dev->zone.read) {
		pr_err("no read handler for device\n");
		return -EINVAL;
		}
		if (!dev->zone.write) {
		pr_err("no write handler for device\n");
		return -EINVAL;
		}

		/* someone already registered before */
		if (pstore_zone_info)
		if (pstore_device_info)
		return -EBUSY;

		pstore_zone_info = kzalloc(sizeof(struct pstore_zone_info), GFP_KERNEL);
		if (!pstore_zone_info)
		return -ENOMEM;

		/* zero means not limit on which backends to attempt to store. */
		if (!dev->flags)
		dev->flags = UINT_MAX;

		#define verify_size(name, alignsize, enabled) { \
		long _##name_; \
		if (enabled) \
		_##name_ = check_size(name, alignsize); \
		else \
		_##name_ = 0; \
		name = _##name_ / 1024; \
		pstore_zone_info->name = _##name_; \
		}

		/* Copy in module parameters. */
		verify_size(kmsg_size, 4096, dev->flags & PSTORE_FLAGS_DMESG);
		verify_size(pmsg_size, 4096, dev->flags & PSTORE_FLAGS_PMSG);
		verify_size(console_size, 4096, dev->flags & PSTORE_FLAGS_CONSOLE);
		verify_size(ftrace_size, 4096, dev->flags & PSTORE_FLAGS_FTRACE);
		#undef verify_size

		pstore_zone_info->total_size = dev->total_size;
		pstore_zone_info->max_reason = max_reason;
		pstore_zone_info->read = dev->read;
		pstore_zone_info->write = dev->write;
		pstore_zone_info->erase = dev->erase;
		pstore_zone_info->panic_write = dev->panic_write;
		pstore_zone_info->name = KBUILD_MODNAME;
		pstore_zone_info->owner = THIS_MODULE;

		ret = register_pstore_zone(pstore_zone_info);
		if (ret) {
		kfree(pstore_zone_info);
		pstore_zone_info = NULL;
		}
		dev->zone.max_reason = max_reason;

		/* Initialize required zone ownership details. */
		dev->zone.name = KBUILD_MODNAME;
		dev->zone.owner = THIS_MODULE;

		ret = register_pstore_zone(&dev->zone);
		if (ret == 0)
		pstore_device_info = dev;

		return ret;
		}
		/**
		@@ -185,10 +166,9 @@ EXPORT_SYMBOL_GPL(register_pstore_device);
		static void __unregister_pstore_device(struct pstore_device_info *dev)
		{
		lockdep_assert_held(&pstore_blk_lock);
		if (pstore_zone_info && pstore_zone_info->read == dev->read) {
		unregister_pstore_zone(pstore_zone_info);
		kfree(pstore_zone_info);
		pstore_zone_info = NULL;
		if (pstore_device_info && pstore_device_info == dev) {
		unregister_pstore_zone(&dev->zone);
		pstore_device_info = NULL;
		}
		}

		@@ -205,204 +185,59 @@ void unregister_pstore_device(struct pstore_device_info *dev)
		}
		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(struct pstore_device_info *dev,
		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 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;
		inode = I_BDEV(psblk_file->f_mapping->host)->bd_inode;
		dev->zone.total_size = i_size_read(inode);

		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;

		ret = __register_pstore_device(&dev);
		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);
		return ret;
		}

		static void __unregister_pstore_blk(unsigned int major)
		{
		struct pstore_device_info dev = { .read = psblk_generic_blk_read };
		void *holder = blkdev;
		err_fput:
		fput(psblk_file);
		err:
		psblk_file = NULL;

		lockdep_assert_held(&pstore_blk_lock);
		if (psblk_bdev && MAJOR(psblk_bdev->bd_dev) == major) {
		__unregister_pstore_device(&dev);
		psblk_put_bdev(psblk_bdev, holder);
		psblk_bdev = NULL;
		}
		return ret;
		}

		/* get information of pstore/blk */
		@@ -419,13 +254,93 @@ int pstore_blk_get_config(struct pstore_blk_config *info)
		}
		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 __best_effort_init(void)
		{
		struct pstore_device_info *best_effort_dev;
		int ret;

		/* No best-effort mode requested. */
		if (!best_effort)
		return 0;

		/* Reject an empty blkdev. */
		if (!blkdev[0]) {
		pr_err("blkdev empty with best_effort=Y\n");
		return -EINVAL;
		}

		best_effort_dev = kzalloc(sizeof(*best_effort_dev), GFP_KERNEL);
		if (!best_effort_dev)
		return -ENOMEM;

		best_effort_dev->zone.read = psblk_generic_blk_read;
		best_effort_dev->zone.write = psblk_generic_blk_write;

		ret = __register_pstore_blk(best_effort_dev,
		early_boot_devpath(blkdev));
		if (ret)
		kfree(best_effort_dev);
		else
		pr_info("attached %s (%zu) (no dedicated panic_write!)\n",
		blkdev, best_effort_dev->zone.total_size);

		return ret;
		}

		static void __exit __best_effort_exit(void)
		{
		/*
		* Currently, the only user of psblk_file is best_effort, so
		* we can assume that pstore_device_info is associated with it.
		* Once there are "real" blk devices, there will need to be a
		* dedicated pstore_blk_info, etc.
		*/
		if (psblk_file) {
		struct pstore_device_info *dev = pstore_device_info;

		__unregister_pstore_device(dev);
		kfree(dev);
		fput(psblk_file);
		psblk_file = NULL;
		}
		}

		static int __init pstore_blk_init(void)
		{
		int ret = 0;
		int ret;

		mutex_lock(&pstore_blk_lock);
		if (!pstore_zone_info && best_effort && blkdev[0])
		ret = __register_pstore_blk();
		ret = __best_effort_init();
		mutex_unlock(&pstore_blk_lock);

		return ret;
		@@ -435,15 +350,9 @@ late_initcall(pstore_blk_init);
		static void __exit pstore_blk_exit(void)
		{
		mutex_lock(&pstore_blk_lock);
		if (psblk_bdev)
		__unregister_pstore_blk(MAJOR(psblk_bdev->bd_dev));
		else {
		struct pstore_device_info dev = { };

		if (pstore_zone_info)
		dev.read = pstore_zone_info->read;
		__unregister_pstore_device(&dev);
		}
		__best_effort_exit();
		/* If we've been asked to unload, unregister any remaining device. */
		__unregister_pstore_device(pstore_device_info);
		mutex_unlock(&pstore_blk_lock);
		}
		module_exit(pstore_blk_exit);

include/linux/pstore_blk.h

+3 −24

Original line number	Diff line number	Diff line
		@@ -10,36 +10,15 @@
		/**
		* struct pstore_device_info - back-end pstore/blk driver structure.
		*
		* @total_size: The total size in bytes pstore/blk can use. It must be greater
		* than 4096 and be multiple of 4096.
		* @flags: Refer to macro starting with PSTORE_FLAGS defined in
		* linux/pstore.h. It means what front-ends this device support.
		* Zero means all backends for compatible.
		* @read: The general read operation. Both of the function parameters
		* @size and @offset are relative value to bock device (not the
		* whole disk).
		* On success, the number of bytes should be returned, others
		* means error.
		* @write: The same as @read, but the following error number:
		* -EBUSY means try to write again later.
		* -ENOMSG means to try next zone.
		* @erase: The general erase operation for device with special removing
		* job. Both of the function parameters @size and @offset are
		* relative value to storage.
		* Return 0 on success and others on failure.
		* @panic_write:The write operation only used for panic case. It's optional
		* if you do not care panic log. The parameters are relative
		* value to storage.
		* On success, the number of bytes should be returned, others
		* excluding -ENOMSG mean error. -ENOMSG means to try next zone.
		* @zone: The struct pstore_zone_info details.
		*
		*/
		struct pstore_device_info {
		unsigned long total_size;
		unsigned int flags;
		pstore_zone_read_op read;
		pstore_zone_write_op write;
		pstore_zone_erase_op erase;
		pstore_zone_write_op panic_write;
		struct pstore_zone_info zone;
		};

		int register_pstore_device(struct pstore_device_info *dev);