~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/pstore/blk.c

Version: ~ [ linux-5.8 ] ~ [ linux-5.7.12 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.55 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.136 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.191 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.232 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.232 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 static bool best_effort;
 55 module_param(best_effort, bool, 0400);
 56 MODULE_PARM_DESC(best_effort, "use best effort to write (i.e. do not require storage driver pstore support, default: off)");
 57 
 58 /*
 59  * blkdev - the block device to use for pstore storage
 60  *
 61  * Usually, this will be a partition of a block device.
 62  *
 63  * blkdev accepts the following variants:
 64  * 1) <hex_major><hex_minor> device number in hexadecimal representation,
 65  *    with no leading 0x, for example b302.
 66  * 2) /dev/<disk_name> represents the device number of disk
 67  * 3) /dev/<disk_name><decimal> represents the device number
 68  *    of partition - device number of disk plus the partition number
 69  * 4) /dev/<disk_name>p<decimal> - same as the above, that form is
 70  *    used when disk name of partitioned disk ends on a digit.
 71  * 5) PARTUUID=00112233-4455-6677-8899-AABBCCDDEEFF representing the
 72  *    unique id of a partition if the partition table provides it.
 73  *    The UUID may be either an EFI/GPT UUID, or refer to an MSDOS
 74  *    partition using the format SSSSSSSS-PP, where SSSSSSSS is a zero-
 75  *    filled hex representation of the 32-bit "NT disk signature", and PP
 76  *    is a zero-filled hex representation of the 1-based partition number.
 77  * 6) PARTUUID=<UUID>/PARTNROFF=<int> to select a partition in relation to
 78  *    a partition with a known unique id.
 79  * 7) <major>:<minor> major and minor number of the device separated by
 80  *    a colon.
 81  */
 82 static char blkdev[80] = CONFIG_PSTORE_BLK_BLKDEV;
 83 module_param_string(blkdev, blkdev, 80, 0400);
 84 MODULE_PARM_DESC(blkdev, "block device for pstore storage");
 85 
 86 /*
 87  * All globals must only be accessed under the pstore_blk_lock
 88  * during the register/unregister functions.
 89  */
 90 static DEFINE_MUTEX(pstore_blk_lock);
 91 static struct block_device *psblk_bdev;
 92 static struct pstore_zone_info *pstore_zone_info;
 93 static pstore_blk_panic_write_op blkdev_panic_write;
 94 
 95 struct bdev_info {
 96         dev_t devt;
 97         sector_t nr_sects;
 98         sector_t start_sect;
 99 };
100 
101 #define check_size(name, alignsize) ({                          \
102         long _##name_ = (name);                                 \
103         _##name_ = _##name_ <= 0 ? 0 : (_##name_ * 1024);       \
104         if (_##name_ & ((alignsize) - 1)) {                     \
105                 pr_info(#name " must align to %d\n",            \
106                                 (alignsize));                   \
107                 _##name_ = ALIGN(name, (alignsize));            \
108         }                                                       \
109         _##name_;                                               \
110 })
111 
112 static int __register_pstore_device(struct pstore_device_info *dev)
113 {
114         int ret;
115 
116         lockdep_assert_held(&pstore_blk_lock);
117 
118         if (!dev || !dev->total_size || !dev->read || !dev->write)
119                 return -EINVAL;
120 
121         /* someone already registered before */
122         if (pstore_zone_info)
123                 return -EBUSY;
124 
125         pstore_zone_info = kzalloc(sizeof(struct pstore_zone_info), GFP_KERNEL);
126         if (!pstore_zone_info)
127                 return -ENOMEM;
128 
129         /* zero means not limit on which backends to attempt to store. */
130         if (!dev->flags)
131                 dev->flags = UINT_MAX;
132 
133 #define verify_size(name, alignsize, enabled) {                         \
134                 long _##name_;                                          \
135                 if (enabled)                                            \
136                         _##name_ = check_size(name, alignsize);         \
137                 else                                                    \
138                         _##name_ = 0;                                   \
139                 name = _##name_ / 1024;                                 \
140                 pstore_zone_info->name = _##name_;                      \
141         }
142 
143         verify_size(kmsg_size, 4096, dev->flags & PSTORE_FLAGS_DMESG);
144         verify_size(pmsg_size, 4096, dev->flags & PSTORE_FLAGS_PMSG);
145         verify_size(console_size, 4096, dev->flags & PSTORE_FLAGS_CONSOLE);
146         verify_size(ftrace_size, 4096, dev->flags & PSTORE_FLAGS_FTRACE);
147 #undef verify_size
148 
149         pstore_zone_info->total_size = dev->total_size;
150         pstore_zone_info->max_reason = max_reason;
151         pstore_zone_info->read = dev->read;
152         pstore_zone_info->write = dev->write;
153         pstore_zone_info->erase = dev->erase;
154         pstore_zone_info->panic_write = dev->panic_write;
155         pstore_zone_info->name = KBUILD_MODNAME;
156         pstore_zone_info->owner = THIS_MODULE;
157 
158         ret = register_pstore_zone(pstore_zone_info);
159         if (ret) {
160                 kfree(pstore_zone_info);
161                 pstore_zone_info = NULL;
162         }
163         return ret;
164 }
165 /**
166  * register_pstore_device() - register non-block device to pstore/blk
167  *
168  * @dev: non-block device information
169  *
170  * Return:
171  * * 0          - OK
172  * * Others     - something error.
173  */
174 int register_pstore_device(struct pstore_device_info *dev)
175 {
176         int ret;
177 
178         mutex_lock(&pstore_blk_lock);
179         ret = __register_pstore_device(dev);
180         mutex_unlock(&pstore_blk_lock);
181 
182         return ret;
183 }
184 EXPORT_SYMBOL_GPL(register_pstore_device);
185 
186 static void __unregister_pstore_device(struct pstore_device_info *dev)
187 {
188         lockdep_assert_held(&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 }
195 
196 /**
197  * unregister_pstore_device() - unregister non-block device from pstore/blk
198  *
199  * @dev: non-block device information
200  */
201 void unregister_pstore_device(struct pstore_device_info *dev)
202 {
203         mutex_lock(&pstore_blk_lock);
204         __unregister_pstore_device(dev);
205         mutex_unlock(&pstore_blk_lock);
206 }
207 EXPORT_SYMBOL_GPL(unregister_pstore_device);
208 
209 /**
210  * psblk_get_bdev() - open block device
211  *
212  * @holder:     Exclusive holder identifier
213  * @info:       Information about bdev to fill in
214  *
215  * Return: pointer to block device on success and others on error.
216  *
217  * On success, the returned block_device has reference count of one.
218  */
219 static struct block_device *psblk_get_bdev(void *holder,
220                                            struct bdev_info *info)
221 {
222         struct block_device *bdev = ERR_PTR(-ENODEV);
223         fmode_t mode = FMODE_READ | FMODE_WRITE;
224         sector_t nr_sects;
225 
226         lockdep_assert_held(&pstore_blk_lock);
227 
228         if (pstore_zone_info)
229                 return ERR_PTR(-EBUSY);
230 
231         if (!blkdev[0])
232                 return ERR_PTR(-ENODEV);
233 
234         if (holder)
235                 mode |= FMODE_EXCL;
236         bdev = blkdev_get_by_path(blkdev, mode, holder);
237         if (IS_ERR(bdev)) {
238                 dev_t devt;
239 
240                 devt = name_to_dev_t(blkdev);
241                 if (devt == 0)
242                         return ERR_PTR(-ENODEV);
243                 bdev = blkdev_get_by_dev(devt, mode, holder);
244                 if (IS_ERR(bdev))
245                         return bdev;
246         }
247 
248         nr_sects = part_nr_sects_read(bdev->bd_part);
249         if (!nr_sects) {
250                 pr_err("not enough space for '%s'\n", blkdev);
251                 blkdev_put(bdev, mode);
252                 return ERR_PTR(-ENOSPC);
253         }
254 
255         if (info) {
256                 info->devt = bdev->bd_dev;
257                 info->nr_sects = nr_sects;
258                 info->start_sect = get_start_sect(bdev);
259         }
260 
261         return bdev;
262 }
263 
264 static void psblk_put_bdev(struct block_device *bdev, void *holder)
265 {
266         fmode_t mode = FMODE_READ | FMODE_WRITE;
267 
268         lockdep_assert_held(&pstore_blk_lock);
269 
270         if (!bdev)
271                 return;
272 
273         if (holder)
274                 mode |= FMODE_EXCL;
275         blkdev_put(bdev, mode);
276 }
277 
278 static ssize_t psblk_generic_blk_read(char *buf, size_t bytes, loff_t pos)
279 {
280         struct block_device *bdev = psblk_bdev;
281         struct file file;
282         struct kiocb kiocb;
283         struct iov_iter iter;
284         struct kvec iov = {.iov_base = buf, .iov_len = bytes};
285 
286         if (!bdev)
287                 return -ENODEV;
288 
289         memset(&file, 0, sizeof(struct file));
290         file.f_mapping = bdev->bd_inode->i_mapping;
291         file.f_flags = O_DSYNC | __O_SYNC | O_NOATIME;
292         file.f_inode = bdev->bd_inode;
293         file_ra_state_init(&file.f_ra, file.f_mapping);
294 
295         init_sync_kiocb(&kiocb, &file);
296         kiocb.ki_pos = pos;
297         iov_iter_kvec(&iter, READ, &iov, 1, bytes);
298 
299         return generic_file_read_iter(&kiocb, &iter);
300 }
301 
302 static ssize_t psblk_generic_blk_write(const char *buf, size_t bytes,
303                 loff_t pos)
304 {
305         struct block_device *bdev = psblk_bdev;
306         struct iov_iter iter;
307         struct kiocb kiocb;
308         struct file file;
309         ssize_t ret;
310         struct kvec iov = {.iov_base = (void *)buf, .iov_len = bytes};
311 
312         if (!bdev)
313                 return -ENODEV;
314 
315         /* Console/Ftrace backend may handle buffer until flush dirty zones */
316         if (in_interrupt() || irqs_disabled())
317                 return -EBUSY;
318 
319         memset(&file, 0, sizeof(struct file));
320         file.f_mapping = bdev->bd_inode->i_mapping;
321         file.f_flags = O_DSYNC | __O_SYNC | O_NOATIME;
322         file.f_inode = bdev->bd_inode;
323 
324         init_sync_kiocb(&kiocb, &file);
325         kiocb.ki_pos = pos;
326         iov_iter_kvec(&iter, WRITE, &iov, 1, bytes);
327 
328         inode_lock(bdev->bd_inode);
329         ret = generic_write_checks(&kiocb, &iter);
330         if (ret > 0)
331                 ret = generic_perform_write(&file, &iter, pos);
332         inode_unlock(bdev->bd_inode);
333 
334         if (likely(ret > 0)) {
335                 const struct file_operations f_op = {.fsync = blkdev_fsync};
336 
337                 file.f_op = &f_op;
338                 kiocb.ki_pos += ret;
339                 ret = generic_write_sync(&kiocb, ret);
340         }
341         return ret;
342 }
343 
344 static ssize_t psblk_blk_panic_write(const char *buf, size_t size,
345                 loff_t off)
346 {
347         int ret;
348 
349         if (!blkdev_panic_write)
350                 return -EOPNOTSUPP;
351 
352         /* size and off must align to SECTOR_SIZE for block device */
353         ret = blkdev_panic_write(buf, off >> SECTOR_SHIFT,
354                         size >> SECTOR_SHIFT);
355         /* try next zone */
356         if (ret == -ENOMSG)
357                 return ret;
358         return ret ? -EIO : size;
359 }
360 
361 static int __register_pstore_blk(struct pstore_blk_info *info)
362 {
363         char bdev_name[BDEVNAME_SIZE];
364         struct block_device *bdev;
365         struct pstore_device_info dev;
366         struct bdev_info binfo;
367         void *holder = blkdev;
368         int ret = -ENODEV;
369 
370         lockdep_assert_held(&pstore_blk_lock);
371 
372         /* hold bdev exclusively */
373         memset(&binfo, 0, sizeof(binfo));
374         bdev = psblk_get_bdev(holder, &binfo);
375         if (IS_ERR(bdev)) {
376                 pr_err("failed to open '%s'!\n", blkdev);
377                 return PTR_ERR(bdev);
378         }
379 
380         /* only allow driver matching the @blkdev */
381         if (!binfo.devt || (!best_effort &&
382                             MAJOR(binfo.devt) != info->major)) {
383                 pr_debug("invalid major %u (expect %u)\n",
384                                 info->major, MAJOR(binfo.devt));
385                 ret = -ENODEV;
386                 goto err_put_bdev;
387         }
388 
389         /* psblk_bdev must be assigned before register to pstore/blk */
390         psblk_bdev = bdev;
391         blkdev_panic_write = info->panic_write;
392 
393         /* Copy back block device details. */
394         info->devt = binfo.devt;
395         info->nr_sects = binfo.nr_sects;
396         info->start_sect = binfo.start_sect;
397 
398         memset(&dev, 0, sizeof(dev));
399         dev.total_size = info->nr_sects << SECTOR_SHIFT;
400         dev.flags = info->flags;
401         dev.read = psblk_generic_blk_read;
402         dev.write = psblk_generic_blk_write;
403         dev.erase = NULL;
404         dev.panic_write = info->panic_write ? psblk_blk_panic_write : NULL;
405 
406         ret = __register_pstore_device(&dev);
407         if (ret)
408                 goto err_put_bdev;
409 
410         bdevname(bdev, bdev_name);
411         pr_info("attached %s%s\n", bdev_name,
412                 info->panic_write ? "" : " (no dedicated panic_write!)");
413         return 0;
414 
415 err_put_bdev:
416         psblk_bdev = NULL;
417         blkdev_panic_write = NULL;
418         psblk_put_bdev(bdev, holder);
419         return ret;
420 }
421 
422 /**
423  * register_pstore_blk() - register block device to pstore/blk
424  *
425  * @info: details on the desired block device interface
426  *
427  * Return:
428  * * 0          - OK
429  * * Others     - something error.
430  */
431 int register_pstore_blk(struct pstore_blk_info *info)
432 {
433         int ret;
434 
435         mutex_lock(&pstore_blk_lock);
436         ret = __register_pstore_blk(info);
437         mutex_unlock(&pstore_blk_lock);
438 
439         return ret;
440 }
441 EXPORT_SYMBOL_GPL(register_pstore_blk);
442 
443 static void __unregister_pstore_blk(unsigned int major)
444 {
445         struct pstore_device_info dev = { .read = psblk_generic_blk_read };
446         void *holder = blkdev;
447 
448         lockdep_assert_held(&pstore_blk_lock);
449         if (psblk_bdev && MAJOR(psblk_bdev->bd_dev) == major) {
450                 __unregister_pstore_device(&dev);
451                 psblk_put_bdev(psblk_bdev, holder);
452                 blkdev_panic_write = NULL;
453                 psblk_bdev = NULL;
454         }
455 }
456 
457 /**
458  * unregister_pstore_blk() - unregister block device from pstore/blk
459  *
460  * @major: the major device number of device
461  */
462 void unregister_pstore_blk(unsigned int major)
463 {
464         mutex_lock(&pstore_blk_lock);
465         __unregister_pstore_blk(major);
466         mutex_unlock(&pstore_blk_lock);
467 }
468 EXPORT_SYMBOL_GPL(unregister_pstore_blk);
469 
470 /* get information of pstore/blk */
471 int pstore_blk_get_config(struct pstore_blk_config *info)
472 {
473         strncpy(info->device, blkdev, 80);
474         info->max_reason = max_reason;
475         info->kmsg_size = check_size(kmsg_size, 4096);
476         info->pmsg_size = check_size(pmsg_size, 4096);
477         info->ftrace_size = check_size(ftrace_size, 4096);
478         info->console_size = check_size(console_size, 4096);
479 
480         return 0;
481 }
482 EXPORT_SYMBOL_GPL(pstore_blk_get_config);
483 
484 static int __init pstore_blk_init(void)
485 {
486         struct pstore_blk_info info = { };
487         int ret = 0;
488 
489         mutex_lock(&pstore_blk_lock);
490         if (!pstore_zone_info && best_effort && blkdev[0])
491                 ret = __register_pstore_blk(&info);
492         mutex_unlock(&pstore_blk_lock);
493 
494         return ret;
495 }
496 late_initcall(pstore_blk_init);
497 
498 static void __exit pstore_blk_exit(void)
499 {
500         mutex_lock(&pstore_blk_lock);
501         if (psblk_bdev)
502                 __unregister_pstore_blk(MAJOR(psblk_bdev->bd_dev));
503         else {
504                 struct pstore_device_info dev = { };
505 
506                 if (pstore_zone_info)
507                         dev.read = pstore_zone_info->read;
508                 __unregister_pstore_device(&dev);
509         }
510         mutex_unlock(&pstore_blk_lock);
511 }
512 module_exit(pstore_blk_exit);
513 
514 MODULE_LICENSE("GPL");
515 MODULE_AUTHOR("WeiXiong Liao <liaoweixiong@allwinnertech.com>");
516 MODULE_AUTHOR("Kees Cook <keescook@chromium.org>");
517 MODULE_DESCRIPTION("pstore backend for block devices");
518 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp