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 <linux/blkdev.h>
12 #include <linux/string.h>
13 #include <linux/of.h>
14 #include <linux/of_address.h>
15 #include <linux/platform_device.h>
16 #include <linux/pstore_blk.h>
17 #include <linux/fs.h>
18 #include <linux/file.h>
19 #include <linux/init_syscalls.h>
20 #include <linux/mount.h>
21
22 static long kmsg_size = CONFIG_PSTORE_BLK_KMSG_SIZE;
23 module_param(kmsg_size, long, 0400);
24 MODULE_PARM_DESC(kmsg_size, "kmsg dump record size in kbytes");
25
26 static int max_reason = CONFIG_PSTORE_BLK_MAX_REASON;
27 module_param(max_reason, int, 0400);
28 MODULE_PARM_DESC(max_reason,
29 "maximum reason for kmsg dump (default 2: Oops and Panic)");
30
31 #if IS_ENABLED(CONFIG_PSTORE_PMSG)
32 static long pmsg_size = CONFIG_PSTORE_BLK_PMSG_SIZE;
33 #else
34 static long pmsg_size = -1;
35 #endif
36 module_param(pmsg_size, long, 0400);
37 MODULE_PARM_DESC(pmsg_size, "pmsg size in kbytes");
38
39 #if IS_ENABLED(CONFIG_PSTORE_CONSOLE)
40 static long console_size = CONFIG_PSTORE_BLK_CONSOLE_SIZE;
41 #else
42 static long console_size = -1;
43 #endif
44 module_param(console_size, long, 0400);
45 MODULE_PARM_DESC(console_size, "console size in kbytes");
46
47 #if IS_ENABLED(CONFIG_PSTORE_FTRACE)
48 static long ftrace_size = CONFIG_PSTORE_BLK_FTRACE_SIZE;
49 #else
50 static long ftrace_size = -1;
51 #endif
52 module_param(ftrace_size, long, 0400);
53 MODULE_PARM_DESC(ftrace_size, "ftrace size in kbytes");
54
55 static bool best_effort;
56 module_param(best_effort, bool, 0400);
57 MODULE_PARM_DESC(best_effort, "use best effort to write (i.e. do not require storage driver pstore support, default: off)");
58
59 /*
60 * blkdev - the block device to use for pstore storage
61 * See Documentation/admin-guide/pstore-blk.rst for details.
62 */
63 static char blkdev[80] = CONFIG_PSTORE_BLK_BLKDEV;
64 module_param_string(blkdev, blkdev, 80, 0400);
65 MODULE_PARM_DESC(blkdev, "block device for pstore storage");
66
67 /*
68 * All globals must only be accessed under the pstore_blk_lock
69 * during the register/unregister functions.
70 */
71 static DEFINE_MUTEX(pstore_blk_lock);
72 static struct file *psblk_file;
73 static struct pstore_device_info *pstore_device_info;
74
75 #define check_size(name, alignsize) ({ \
76 long _##name_ = (name); \
77 _##name_ = _##name_ <= 0 ? 0 : (_##name_ * 1024); \
78 if (_##name_ & ((alignsize) - 1)) { \
79 pr_info(#name " must align to %d\n", \
80 (alignsize)); \
81 _##name_ = ALIGN(name, (alignsize)); \
82 } \
83 _##name_; \
84 })
85
86 #define verify_size(name, alignsize, enabled) { \
87 long _##name_; \
88 if (enabled) \
89 _##name_ = check_size(name, alignsize); \
90 else \
91 _##name_ = 0; \
92 /* Synchronize module parameters with resuls. */ \
93 name = _##name_ / 1024; \
94 dev->zone.name = _##name_; \
95 }
96
__register_pstore_device(struct pstore_device_info * dev)97 static int __register_pstore_device(struct pstore_device_info *dev)
98 {
99 int ret;
100
101 lockdep_assert_held(&pstore_blk_lock);
102
103 if (!dev) {
104 pr_err("NULL device info\n");
105 return -EINVAL;
106 }
107 if (!dev->zone.total_size) {
108 pr_err("zero sized device\n");
109 return -EINVAL;
110 }
111 if (!dev->zone.read) {
112 pr_err("no read handler for device\n");
113 return -EINVAL;
114 }
115 if (!dev->zone.write) {
116 pr_err("no write handler for device\n");
117 return -EINVAL;
118 }
119
120 /* someone already registered before */
121 if (pstore_device_info)
122 return -EBUSY;
123
124 /* zero means not limit on which backends to attempt to store. */
125 if (!dev->flags)
126 dev->flags = UINT_MAX;
127
128 /* Copy in module parameters. */
129 verify_size(kmsg_size, 4096, dev->flags & PSTORE_FLAGS_DMESG);
130 verify_size(pmsg_size, 4096, dev->flags & PSTORE_FLAGS_PMSG);
131 verify_size(console_size, 4096, dev->flags & PSTORE_FLAGS_CONSOLE);
132 verify_size(ftrace_size, 4096, dev->flags & PSTORE_FLAGS_FTRACE);
133 dev->zone.max_reason = max_reason;
134
135 /* Initialize required zone ownership details. */
136 dev->zone.name = KBUILD_MODNAME;
137 dev->zone.owner = THIS_MODULE;
138
139 ret = register_pstore_zone(&dev->zone);
140 if (ret == 0)
141 pstore_device_info = dev;
142
143 return ret;
144 }
145 /**
146 * register_pstore_device() - register non-block device to pstore/blk
147 *
148 * @dev: non-block device information
149 *
150 * Return:
151 * * 0 - OK
152 * * Others - something error.
153 */
register_pstore_device(struct pstore_device_info * dev)154 int register_pstore_device(struct pstore_device_info *dev)
155 {
156 int ret;
157
158 mutex_lock(&pstore_blk_lock);
159 ret = __register_pstore_device(dev);
160 mutex_unlock(&pstore_blk_lock);
161
162 return ret;
163 }
164 EXPORT_SYMBOL_GPL(register_pstore_device);
165
__unregister_pstore_device(struct pstore_device_info * dev)166 static void __unregister_pstore_device(struct pstore_device_info *dev)
167 {
168 lockdep_assert_held(&pstore_blk_lock);
169 if (pstore_device_info && pstore_device_info == dev) {
170 unregister_pstore_zone(&dev->zone);
171 pstore_device_info = NULL;
172 }
173 }
174
175 /**
176 * unregister_pstore_device() - unregister non-block device from pstore/blk
177 *
178 * @dev: non-block device information
179 */
unregister_pstore_device(struct pstore_device_info * dev)180 void unregister_pstore_device(struct pstore_device_info *dev)
181 {
182 mutex_lock(&pstore_blk_lock);
183 __unregister_pstore_device(dev);
184 mutex_unlock(&pstore_blk_lock);
185 }
186 EXPORT_SYMBOL_GPL(unregister_pstore_device);
187
psblk_generic_blk_read(char * buf,size_t bytes,loff_t pos)188 static ssize_t psblk_generic_blk_read(char *buf, size_t bytes, loff_t pos)
189 {
190 return kernel_read(psblk_file, buf, bytes, &pos);
191 }
192
psblk_generic_blk_write(const char * buf,size_t bytes,loff_t pos)193 static ssize_t psblk_generic_blk_write(const char *buf, size_t bytes,
194 loff_t pos)
195 {
196 /* Console/Ftrace backend may handle buffer until flush dirty zones */
197 if (in_interrupt() || irqs_disabled())
198 return -EBUSY;
199 return kernel_write(psblk_file, buf, bytes, &pos);
200 }
201
202 /*
203 * This takes its configuration only from the module parameters now.
204 */
__register_pstore_blk(struct pstore_device_info * dev,const char * devpath)205 static int __register_pstore_blk(struct pstore_device_info *dev,
206 const char *devpath)
207 {
208 struct inode *inode;
209 int ret = -ENODEV;
210
211 lockdep_assert_held(&pstore_blk_lock);
212
213 psblk_file = filp_open(devpath, O_RDWR | O_DSYNC | O_NOATIME | O_EXCL, 0);
214 if (IS_ERR(psblk_file)) {
215 ret = PTR_ERR(psblk_file);
216 pr_err("failed to open '%s': %d!\n", devpath, ret);
217 goto err;
218 }
219
220 inode = file_inode(psblk_file);
221 if (!S_ISBLK(inode->i_mode)) {
222 pr_err("'%s' is not block device!\n", devpath);
223 goto err_fput;
224 }
225
226 inode = I_BDEV(psblk_file->f_mapping->host)->bd_inode;
227 dev->zone.total_size = i_size_read(inode);
228
229 ret = __register_pstore_device(dev);
230 if (ret)
231 goto err_fput;
232
233 return 0;
234
235 err_fput:
236 fput(psblk_file);
237 err:
238 psblk_file = NULL;
239
240 return ret;
241 }
242
243 /* get information of pstore/blk */
pstore_blk_get_config(struct pstore_blk_config * info)244 int pstore_blk_get_config(struct pstore_blk_config *info)
245 {
246 strncpy(info->device, blkdev, 80);
247 info->max_reason = max_reason;
248 info->kmsg_size = check_size(kmsg_size, 4096);
249 info->pmsg_size = check_size(pmsg_size, 4096);
250 info->ftrace_size = check_size(ftrace_size, 4096);
251 info->console_size = check_size(console_size, 4096);
252
253 return 0;
254 }
255 EXPORT_SYMBOL_GPL(pstore_blk_get_config);
256
257
258 #ifndef MODULE
259 static const char devname[] = "/dev/pstore-blk";
early_boot_devpath(const char * initial_devname)260 static __init const char *early_boot_devpath(const char *initial_devname)
261 {
262 /*
263 * During early boot the real root file system hasn't been
264 * mounted yet, and no device nodes are present yet. Use the
265 * same scheme to find the device that we use for mounting
266 * the root file system.
267 */
268 dev_t dev = name_to_dev_t(initial_devname);
269
270 if (!dev) {
271 pr_err("failed to resolve '%s'!\n", initial_devname);
272 return initial_devname;
273 }
274
275 init_unlink(devname);
276 init_mknod(devname, S_IFBLK | 0600, new_encode_dev(dev));
277
278 return devname;
279 }
280 #else
early_boot_devpath(const char * initial_devname)281 static inline const char *early_boot_devpath(const char *initial_devname)
282 {
283 return initial_devname;
284 }
285 #endif
286
__best_effort_init(void)287 static int __init __best_effort_init(void)
288 {
289 struct pstore_device_info *best_effort_dev;
290 int ret;
291
292 /* No best-effort mode requested. */
293 if (!best_effort)
294 return 0;
295
296 /* Reject an empty blkdev. */
297 if (!blkdev[0]) {
298 pr_err("blkdev empty with best_effort=Y\n");
299 return -EINVAL;
300 }
301
302 best_effort_dev = kzalloc(sizeof(*best_effort_dev), GFP_KERNEL);
303 if (!best_effort_dev)
304 return -ENOMEM;
305
306 best_effort_dev->zone.read = psblk_generic_blk_read;
307 best_effort_dev->zone.write = psblk_generic_blk_write;
308
309 ret = __register_pstore_blk(best_effort_dev,
310 early_boot_devpath(blkdev));
311 if (ret)
312 kfree(best_effort_dev);
313 else
314 pr_info("attached %s (%zu) (no dedicated panic_write!)\n",
315 blkdev, best_effort_dev->zone.total_size);
316
317 return ret;
318 }
319
__best_effort_exit(void)320 static void __exit __best_effort_exit(void)
321 {
322 /*
323 * Currently, the only user of psblk_file is best_effort, so
324 * we can assume that pstore_device_info is associated with it.
325 * Once there are "real" blk devices, there will need to be a
326 * dedicated pstore_blk_info, etc.
327 */
328 if (psblk_file) {
329 struct pstore_device_info *dev = pstore_device_info;
330
331 __unregister_pstore_device(dev);
332 kfree(dev);
333 fput(psblk_file);
334 psblk_file = NULL;
335 }
336 }
337
pstore_blk_init(void)338 static int __init pstore_blk_init(void)
339 {
340 int ret;
341
342 mutex_lock(&pstore_blk_lock);
343 ret = __best_effort_init();
344 mutex_unlock(&pstore_blk_lock);
345
346 return ret;
347 }
348 late_initcall(pstore_blk_init);
349
pstore_blk_exit(void)350 static void __exit pstore_blk_exit(void)
351 {
352 mutex_lock(&pstore_blk_lock);
353 __best_effort_exit();
354 /* If we've been asked to unload, unregister any remaining device. */
355 __unregister_pstore_device(pstore_device_info);
356 mutex_unlock(&pstore_blk_lock);
357 }
358 module_exit(pstore_blk_exit);
359
360 MODULE_LICENSE("GPL");
361 MODULE_AUTHOR("WeiXiong Liao <liaoweixiong@allwinnertech.com>");
362 MODULE_AUTHOR("Kees Cook <keescook@chromium.org>");
363 MODULE_DESCRIPTION("pstore backend for block devices");
364
