fs/pstore/blk.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Implements pstore backend driver that write to block (or non-block) storage
   4  * devices, using the pstore/zone API.
   5  */
   6
   7 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
   8
   9 #include <linux/kernel.h>
  10 #include <linux/module.h>
  11 #include "../../block/blk.h"
  12 #include <linux/blkdev.h>
  13 #include <linux/string.h>
  14 #include <linux/of.h>
  15 #include <linux/of_address.h>
  16 #include <linux/platform_device.h>
  17 #include <linux/pstore_blk.h>
  18 #include <linux/mount.h>
  19 #include <linux/uio.h>
  20
  21 static long kmsg_size = CONFIG_PSTORE_BLK_KMSG_SIZE;
  22 module_param(kmsg_size, long, 0400);
  23 MODULE_PARM_DESC(kmsg_size, "kmsg dump record size in kbytes");
  24
  25 static int max_reason = CONFIG_PSTORE_BLK_MAX_REASON;
  26 module_param(max_reason, int, 0400);
  27 MODULE_PARM_DESC(max_reason,
  28                  "maximum reason for kmsg dump (default 2: Oops and Panic)");
  29
  30 #if IS_ENABLED(CONFIG_PSTORE_PMSG)
  31 static long pmsg_size = CONFIG_PSTORE_BLK_PMSG_SIZE;
  32 #else
  33 static long pmsg_size = -1;
  34 #endif
  35 module_param(pmsg_size, long, 0400);
  36 MODULE_PARM_DESC(pmsg_size, "pmsg size in kbytes");
  37
  38 #if IS_ENABLED(CONFIG_PSTORE_CONSOLE)
  39 static long console_size = CONFIG_PSTORE_BLK_CONSOLE_SIZE;
  40 #else
  41 static long console_size = -1;
  42 #endif
  43 module_param(console_size, long, 0400);
  44 MODULE_PARM_DESC(console_size, "console size in kbytes");
  45
  46 #if IS_ENABLED(CONFIG_PSTORE_FTRACE)
  47 static long ftrace_size = CONFIG_PSTORE_BLK_FTRACE_SIZE;
  48 #else
  49 static long ftrace_size = -1;
  50 #endif
  51 module_param(ftrace_size, long, 0400);
  52 MODULE_PARM_DESC(ftrace_size, "ftrace size in kbytes");
  53
  54 /*
  55  * blkdev - the block device to use for pstore storage
  56  *
  57  * Usually, this will be a partition of a block device.
  58  *
  59  * blkdev accepts the following variants:
  60  * 1) <hex_major><hex_minor> device number in hexadecimal representation,
  61  *    with no leading 0x, for example b302.
  62  * 2) /dev/<disk_name> represents the device number of disk
  63  * 3) /dev/<disk_name><decimal> represents the device number
  64  *    of partition - device number of disk plus the partition number
  65  * 4) /dev/<disk_name>p<decimal> - same as the above, that form is
  66  *    used when disk name of partitioned disk ends on a digit.
  67  * 5) PARTUUID=00112233-4455-6677-8899-AABBCCDDEEFF representing the
  68  *    unique id of a partition if the partition table provides it.
  69  *    The UUID may be either an EFI/GPT UUID, or refer to an MSDOS
  70  *    partition using the format SSSSSSSS-PP, where SSSSSSSS is a zero-
  71  *    filled hex representation of the 32-bit "NT disk signature", and PP
  72  *    is a zero-filled hex representation of the 1-based partition number.
  73  * 6) PARTUUID=<UUID>/PARTNROFF=<int> to select a partition in relation to
  74  *    a partition with a known unique id.
  75  * 7) <major>:<minor> major and minor number of the device separated by
  76  *    a colon.
  77  */
  78 static char blkdev[80] = CONFIG_PSTORE_BLK_BLKDEV;
  79 module_param_string(blkdev, blkdev, 80, 0400);
  80 MODULE_PARM_DESC(blkdev, "block device for pstore storage");
  81
  82 /*
  83  * All globals must only be accessed under the pstore_blk_lock
  84  * during the register/unregister functions.
  85  */
  86 static DEFINE_MUTEX(pstore_blk_lock);
  87 static struct block_device *psblk_bdev;
  88 static struct pstore_zone_info *pstore_zone_info;
  89 static pstore_blk_panic_write_op blkdev_panic_write;
  90
  91 struct bdev_info {
  92         dev_t devt;
  93         sector_t nr_sects;
  94         sector_t start_sect;
  95 };
  96
  97 /**
  98  * struct pstore_device_info - back-end pstore/blk driver structure.
  99  *
 100  * @total_size: The total size in bytes pstore/blk can use. It must be greater
 101  *              than 4096 and be multiple of 4096.
 102  * @flags:      Refer to macro starting with PSTORE_FLAGS defined in
 103  *              linux/pstore.h. It means what front-ends this device support.
 104  *              Zero means all backends for compatible.
 105  * @read:       The general read operation. Both of the function parameters
 106  *              @size and @offset are relative value to bock device (not the
 107  *              whole disk).
 108  *              On success, the number of bytes should be returned, others
 109  *              means error.
 110  * @write:      The same as @read, but the following error number:
 111  *              -EBUSY means try to write again later.
 112  *              -ENOMSG means to try next zone.
 113  * @panic_write:The write operation only used for panic case. It's optional
 114  *              if you do not care panic log. The parameters are relative
 115  *              value to storage.
 116  *              On success, the number of bytes should be returned, others
 117  *              excluding -ENOMSG mean error. -ENOMSG means to try next zone.
 118  */
 119 struct pstore_device_info {
 120         unsigned long total_size;
 121         unsigned int flags;
 122         pstore_zone_read_op read;
 123         pstore_zone_write_op write;
 124         pstore_zone_write_op panic_write;
 125 };
 126
 127 static int psblk_register_do(struct pstore_device_info *dev)
 128 {
 129         int ret;
 130
 131         if (!dev || !dev->total_size || !dev->read || !dev->write)
 132                 return -EINVAL;
 133
 134         mutex_lock(&pstore_blk_lock);
 135
 136         /* someone already registered before */
 137         if (pstore_zone_info) {
 138                 mutex_unlock(&pstore_blk_lock);
 139                 return -EBUSY;
 140         }
 141         pstore_zone_info = kzalloc(sizeof(struct pstore_zone_info), GFP_KERNEL);
 142         if (!pstore_zone_info) {
 143                 mutex_unlock(&pstore_blk_lock);
 144                 return -ENOMEM;
 145         }
 146
 147         /* zero means not limit on which backends to attempt to store. */
 148         if (!dev->flags)
 149                 dev->flags = UINT_MAX;
 150
 151 #define verify_size(name, alignsize, enabled) {                         \
 152                 long _##name_ = (enabled) ? (name) : 0;                 \
 153                 _##name_ = _##name_ <= 0 ? 0 : (_##name_ * 1024);       \
 154                 if (_##name_ & ((alignsize) - 1)) {                     \
 155                         pr_info(#name " must align to %d\n",            \
 156                                         (alignsize));                   \
 157                         _##name_ = ALIGN(name, (alignsize));            \
 158                 }                                                       \
 159                 name = _##name_ / 1024;                                 \
 160                 pstore_zone_info->name = _##name_;                      \
 161         }
 162
 163         verify_size(kmsg_size, 4096, dev->flags & PSTORE_FLAGS_DMESG);
 164         verify_size(pmsg_size, 4096, dev->flags & PSTORE_FLAGS_PMSG);
 165         verify_size(console_size, 4096, dev->flags & PSTORE_FLAGS_CONSOLE);
 166         verify_size(ftrace_size, 4096, dev->flags & PSTORE_FLAGS_FTRACE);
 167 #undef verify_size
 168
 169         pstore_zone_info->total_size = dev->total_size;
 170         pstore_zone_info->max_reason = max_reason;
 171         pstore_zone_info->read = dev->read;
 172         pstore_zone_info->write = dev->write;
 173         pstore_zone_info->panic_write = dev->panic_write;
 174         pstore_zone_info->name = KBUILD_MODNAME;
 175         pstore_zone_info->owner = THIS_MODULE;
 176
 177         ret = register_pstore_zone(pstore_zone_info);
 178         if (ret) {
 179                 kfree(pstore_zone_info);
 180                 pstore_zone_info = NULL;
 181         }
 182         mutex_unlock(&pstore_blk_lock);
 183         return ret;
 184 }
 185
 186 static void psblk_unregister_do(struct pstore_device_info *dev)
 187 {
 188         mutex_lock(&pstore_blk_lock);
 189         if (pstore_zone_info && pstore_zone_info->read == dev->read) {
 190                 unregister_pstore_zone(pstore_zone_info);
 191                 kfree(pstore_zone_info);
 192                 pstore_zone_info = NULL;
 193         }
 194         mutex_unlock(&pstore_blk_lock);
 195 }
 196
 197 /**
 198  * psblk_get_bdev() - open block device
 199  *
 200  * @holder:     Exclusive holder identifier
 201  * @info:       Information about bdev to fill in
 202  *
 203  * Return: pointer to block device on success and others on error.
 204  *
 205  * On success, the returned block_device has reference count of one.
 206  */
 207 static struct block_device *psblk_get_bdev(void *holder,
 208                                            struct bdev_info *info)
 209 {
 210         struct block_device *bdev = ERR_PTR(-ENODEV);
 211         fmode_t mode = FMODE_READ | FMODE_WRITE;
 212         sector_t nr_sects;
 213
 214         lockdep_assert_held(&pstore_blk_lock);
 215
 216         if (pstore_zone_info)
 217                 return ERR_PTR(-EBUSY);
 218
 219         if (!blkdev[0])
 220                 return ERR_PTR(-ENODEV);
 221
 222         if (holder)
 223                 mode |= FMODE_EXCL;
 224         bdev = blkdev_get_by_path(blkdev, mode, holder);
 225         if (IS_ERR(bdev)) {
 226                 dev_t devt;
 227
 228                 devt = name_to_dev_t(blkdev);
 229                 if (devt == 0)
 230                         return ERR_PTR(-ENODEV);
 231                 bdev = blkdev_get_by_dev(devt, mode, holder);
 232                 if (IS_ERR(bdev))
 233                         return bdev;
 234         }
 235
 236         nr_sects = part_nr_sects_read(bdev->bd_part);
 237         if (!nr_sects) {
 238                 pr_err("not enough space for '%s'\n", blkdev);
 239                 blkdev_put(bdev, mode);
 240                 return ERR_PTR(-ENOSPC);
 241         }
 242
 243         if (info) {
 244                 info->devt = bdev->bd_dev;
 245                 info->nr_sects = nr_sects;
 246                 info->start_sect = get_start_sect(bdev);
 247         }
 248
 249         return bdev;
 250 }
 251
 252 static void psblk_put_bdev(struct block_device *bdev, void *holder)
 253 {
 254         fmode_t mode = FMODE_READ | FMODE_WRITE;
 255
 256         lockdep_assert_held(&pstore_blk_lock);
 257
 258         if (!bdev)
 259                 return;
 260
 261         if (holder)
 262                 mode |= FMODE_EXCL;
 263         blkdev_put(bdev, mode);
 264 }
 265
 266 static ssize_t psblk_generic_blk_read(char *buf, size_t bytes, loff_t pos)
 267 {
 268         struct block_device *bdev = psblk_bdev;
 269         struct file file;
 270         struct kiocb kiocb;
 271         struct iov_iter iter;
 272         struct kvec iov = {.iov_base = buf, .iov_len = bytes};
 273
 274         if (!bdev)
 275                 return -ENODEV;
 276
 277         memset(&file, 0, sizeof(struct file));
 278         file.f_mapping = bdev->bd_inode->i_mapping;
 279         file.f_flags = O_DSYNC | __O_SYNC | O_NOATIME;
 280         file.f_inode = bdev->bd_inode;
 281         file_ra_state_init(&file.f_ra, file.f_mapping);
 282
 283         init_sync_kiocb(&kiocb, &file);
 284         kiocb.ki_pos = pos;
 285         iov_iter_kvec(&iter, READ, &iov, 1, bytes);
 286
 287         return generic_file_read_iter(&kiocb, &iter);
 288 }
 289
 290 static ssize_t psblk_generic_blk_write(const char *buf, size_t bytes,
 291                 loff_t pos)
 292 {
 293         struct block_device *bdev = psblk_bdev;
 294         struct iov_iter iter;
 295         struct kiocb kiocb;
 296         struct file file;
 297         ssize_t ret;
 298         struct kvec iov = {.iov_base = (void *)buf, .iov_len = bytes};
 299
 300         if (!bdev)
 301                 return -ENODEV;
 302
 303         /* Console/Ftrace backend may handle buffer until flush dirty zones */
 304         if (in_interrupt() || irqs_disabled())
 305                 return -EBUSY;
 306
 307         memset(&file, 0, sizeof(struct file));
 308         file.f_mapping = bdev->bd_inode->i_mapping;
 309         file.f_flags = O_DSYNC | __O_SYNC | O_NOATIME;
 310         file.f_inode = bdev->bd_inode;
 311
 312         init_sync_kiocb(&kiocb, &file);
 313         kiocb.ki_pos = pos;
 314         iov_iter_kvec(&iter, WRITE, &iov, 1, bytes);
 315
 316         inode_lock(bdev->bd_inode);
 317         ret = generic_write_checks(&kiocb, &iter);
 318         if (ret > 0)
 319                 ret = generic_perform_write(&file, &iter, pos);
 320         inode_unlock(bdev->bd_inode);
 321
 322         if (likely(ret > 0)) {
 323                 const struct file_operations f_op = {.fsync = blkdev_fsync};
 324
 325                 file.f_op = &f_op;
 326                 kiocb.ki_pos += ret;
 327                 ret = generic_write_sync(&kiocb, ret);
 328         }
 329         return ret;
 330 }
 331
 332 static ssize_t psblk_blk_panic_write(const char *buf, size_t size,
 333                 loff_t off)
 334 {
 335         int ret;
 336
 337         if (!blkdev_panic_write)
 338                 return -EOPNOTSUPP;
 339
 340         /* size and off must align to SECTOR_SIZE for block device */
 341         ret = blkdev_panic_write(buf, off >> SECTOR_SHIFT,
 342                         size >> SECTOR_SHIFT);
 343         /* try next zone */
 344         if (ret == -ENOMSG)
 345                 return ret;
 346         return ret ? -EIO : size;
 347 }
 348
 349 static int __register_pstore_blk(struct pstore_blk_info *info)
 350 {
 351         char bdev_name[BDEVNAME_SIZE];
 352         struct block_device *bdev;
 353         struct pstore_device_info dev;
 354         struct bdev_info binfo;
 355         void *holder = blkdev;
 356         int ret = -ENODEV;
 357
 358         lockdep_assert_held(&pstore_blk_lock);
 359
 360         /* hold bdev exclusively */
 361         memset(&binfo, 0, sizeof(binfo));
 362         bdev = psblk_get_bdev(holder, &binfo);
 363         if (IS_ERR(bdev)) {
 364                 pr_err("failed to open '%s'!\n", blkdev);
 365                 return PTR_ERR(bdev);
 366         }
 367
 368         /* only allow driver matching the @blkdev */
 369         if (!binfo.devt || MAJOR(binfo.devt) != info->major) {
 370                 pr_debug("invalid major %u (expect %u)\n",
 371                                 info->major, MAJOR(binfo.devt));
 372                 ret = -ENODEV;
 373                 goto err_put_bdev;
 374         }
 375
 376         /* psblk_bdev must be assigned before register to pstore/blk */
 377         psblk_bdev = bdev;
 378         blkdev_panic_write = info->panic_write;
 379
 380         /* Copy back block device details. */
 381         info->devt = binfo.devt;
 382         info->nr_sects = binfo.nr_sects;
 383         info->start_sect = binfo.start_sect;
 384
 385         memset(&dev, 0, sizeof(dev));
 386         dev.total_size = info->nr_sects << SECTOR_SHIFT;
 387         dev.flags = info->flags;
 388         dev.read = psblk_generic_blk_read;
 389         dev.write = psblk_generic_blk_write;
 390         dev.panic_write = info->panic_write ? psblk_blk_panic_write : NULL;
 391
 392         ret = psblk_register_do(&dev);
 393         if (ret)
 394                 goto err_put_bdev;
 395
 396         bdevname(bdev, bdev_name);
 397         pr_info("attached %s%s\n", bdev_name,
 398                 info->panic_write ? "" : " (no dedicated panic_write!)");
 399         return 0;
 400
 401 err_put_bdev:
 402         psblk_bdev = NULL;
 403         blkdev_panic_write = NULL;
 404         psblk_put_bdev(bdev, holder);
 405         return ret;
 406 }
 407
 408 /**
 409  * register_pstore_blk() - register block device to pstore/blk
 410  *
 411  * @info: details on the desired block device interface
 412  *
 413  * Return:
 414  * * 0          - OK
 415  * * Others     - something error.
 416  */
 417 int register_pstore_blk(struct pstore_blk_info *info)
 418 {
 419         int ret;
 420
 421         mutex_lock(&pstore_blk_lock);
 422         ret = __register_pstore_blk(info);
 423         mutex_unlock(&pstore_blk_lock);
 424
 425         return ret;
 426 }
 427 EXPORT_SYMBOL_GPL(register_pstore_blk);
 428
 429 static void __unregister_pstore_blk(unsigned int major)
 430 {
 431         struct pstore_device_info dev = { .read = psblk_generic_blk_read };
 432         void *holder = blkdev;
 433
 434         lockdep_assert_held(&pstore_blk_lock);
 435         if (psblk_bdev && MAJOR(psblk_bdev->bd_dev) == major) {
 436                 psblk_unregister_do(&dev);
 437                 psblk_put_bdev(psblk_bdev, holder);
 438                 blkdev_panic_write = NULL;
 439                 psblk_bdev = NULL;
 440         }
 441 }
 442
 443 /**
 444  * unregister_pstore_blk() - unregister block device from pstore/blk
 445  *
 446  * @major: the major device number of device
 447  */
 448 void unregister_pstore_blk(unsigned int major)
 449 {
 450         mutex_lock(&pstore_blk_lock);
 451         __unregister_pstore_blk(major);
 452         mutex_unlock(&pstore_blk_lock);
 453 }
 454 EXPORT_SYMBOL_GPL(unregister_pstore_blk);
 455
 456 static void __exit pstore_blk_exit(void)
 457 {
 458         mutex_lock(&pstore_blk_lock);
 459         if (psblk_bdev)
 460                 __unregister_pstore_blk(MAJOR(psblk_bdev->bd_dev));
 461         mutex_unlock(&pstore_blk_lock);
 462 }
 463 module_exit(pstore_blk_exit);
 464
 465 MODULE_LICENSE("GPL");
 466 MODULE_AUTHOR("WeiXiong Liao <liaoweixiong@allwinnertech.com>");
 467 MODULE_AUTHOR("Kees Cook <keescook@chromium.org>");
 468 MODULE_DESCRIPTION("pstore backend for block devices");