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

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

Version: ~ [ linux-5.11-rc3 ] ~ [ linux-5.10.7 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.89 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.167 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.215 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.251 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.251 ] ~ [ 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-only
  2 /*
  3  * RAM Oops/Panic logger
  4  *
  5  * Copyright (C) 2010 Marco Stornelli <marco.stornelli@gmail.com>
  6  * Copyright (C) 2011 Kees Cook <keescook@chromium.org>
  7  */
  8 
  9 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 10 
 11 #include <linux/kernel.h>
 12 #include <linux/err.h>
 13 #include <linux/module.h>
 14 #include <linux/version.h>
 15 #include <linux/pstore.h>
 16 #include <linux/io.h>
 17 #include <linux/ioport.h>
 18 #include <linux/platform_device.h>
 19 #include <linux/slab.h>
 20 #include <linux/compiler.h>
 21 #include <linux/pstore_ram.h>
 22 #include <linux/of.h>
 23 #include <linux/of_address.h>
 24 #include "internal.h"
 25 
 26 #define RAMOOPS_KERNMSG_HDR "===="
 27 #define MIN_MEM_SIZE 4096UL
 28 
 29 static ulong record_size = MIN_MEM_SIZE;
 30 module_param(record_size, ulong, 0400);
 31 MODULE_PARM_DESC(record_size,
 32                 "size of each dump done on oops/panic");
 33 
 34 static ulong ramoops_console_size = MIN_MEM_SIZE;
 35 module_param_named(console_size, ramoops_console_size, ulong, 0400);
 36 MODULE_PARM_DESC(console_size, "size of kernel console log");
 37 
 38 static ulong ramoops_ftrace_size = MIN_MEM_SIZE;
 39 module_param_named(ftrace_size, ramoops_ftrace_size, ulong, 0400);
 40 MODULE_PARM_DESC(ftrace_size, "size of ftrace log");
 41 
 42 static ulong ramoops_pmsg_size = MIN_MEM_SIZE;
 43 module_param_named(pmsg_size, ramoops_pmsg_size, ulong, 0400);
 44 MODULE_PARM_DESC(pmsg_size, "size of user space message log");
 45 
 46 static unsigned long long mem_address;
 47 module_param_hw(mem_address, ullong, other, 0400);
 48 MODULE_PARM_DESC(mem_address,
 49                 "start of reserved RAM used to store oops/panic logs");
 50 
 51 static ulong mem_size;
 52 module_param(mem_size, ulong, 0400);
 53 MODULE_PARM_DESC(mem_size,
 54                 "size of reserved RAM used to store oops/panic logs");
 55 
 56 static unsigned int mem_type;
 57 module_param(mem_type, uint, 0400);
 58 MODULE_PARM_DESC(mem_type,
 59                 "set to 1 to try to use unbuffered memory (default 0)");
 60 
 61 static int ramoops_max_reason = -1;
 62 module_param_named(max_reason, ramoops_max_reason, int, 0400);
 63 MODULE_PARM_DESC(max_reason,
 64                  "maximum reason for kmsg dump (default 2: Oops and Panic) ");
 65 
 66 static int ramoops_ecc;
 67 module_param_named(ecc, ramoops_ecc, int, 0400);
 68 MODULE_PARM_DESC(ramoops_ecc,
 69                 "if non-zero, the option enables ECC support and specifies "
 70                 "ECC buffer size in bytes (1 is a special value, means 16 "
 71                 "bytes ECC)");
 72 
 73 static int ramoops_dump_oops = -1;
 74 module_param_named(dump_oops, ramoops_dump_oops, int, 0400);
 75 MODULE_PARM_DESC(dump_oops,
 76                  "(deprecated: use max_reason instead) set to 1 to dump oopses & panics, 0 to only dump panics");
 77 
 78 struct ramoops_context {
 79         struct persistent_ram_zone **dprzs;     /* Oops dump zones */
 80         struct persistent_ram_zone *cprz;       /* Console zone */
 81         struct persistent_ram_zone **fprzs;     /* Ftrace zones */
 82         struct persistent_ram_zone *mprz;       /* PMSG zone */
 83         phys_addr_t phys_addr;
 84         unsigned long size;
 85         unsigned int memtype;
 86         size_t record_size;
 87         size_t console_size;
 88         size_t ftrace_size;
 89         size_t pmsg_size;
 90         u32 flags;
 91         struct persistent_ram_ecc_info ecc_info;
 92         unsigned int max_dump_cnt;
 93         unsigned int dump_write_cnt;
 94         /* _read_cnt need clear on ramoops_pstore_open */
 95         unsigned int dump_read_cnt;
 96         unsigned int console_read_cnt;
 97         unsigned int max_ftrace_cnt;
 98         unsigned int ftrace_read_cnt;
 99         unsigned int pmsg_read_cnt;
100         struct pstore_info pstore;
101 };
102 
103 static struct platform_device *dummy;
104 
105 static int ramoops_pstore_open(struct pstore_info *psi)
106 {
107         struct ramoops_context *cxt = psi->data;
108 
109         cxt->dump_read_cnt = 0;
110         cxt->console_read_cnt = 0;
111         cxt->ftrace_read_cnt = 0;
112         cxt->pmsg_read_cnt = 0;
113         return 0;
114 }
115 
116 static struct persistent_ram_zone *
117 ramoops_get_next_prz(struct persistent_ram_zone *przs[], int id,
118                      struct pstore_record *record)
119 {
120         struct persistent_ram_zone *prz;
121 
122         /* Give up if we never existed or have hit the end. */
123         if (!przs)
124                 return NULL;
125 
126         prz = przs[id];
127         if (!prz)
128                 return NULL;
129 
130         /* Update old/shadowed buffer. */
131         if (prz->type == PSTORE_TYPE_DMESG)
132                 persistent_ram_save_old(prz);
133 
134         if (!persistent_ram_old_size(prz))
135                 return NULL;
136 
137         record->type = prz->type;
138         record->id = id;
139 
140         return prz;
141 }
142 
143 static int ramoops_read_kmsg_hdr(char *buffer, struct timespec64 *time,
144                                   bool *compressed)
145 {
146         char data_type;
147         int header_length = 0;
148 
149         if (sscanf(buffer, RAMOOPS_KERNMSG_HDR "%lld.%lu-%c\n%n",
150                    (time64_t *)&time->tv_sec, &time->tv_nsec, &data_type,
151                    &header_length) == 3) {
152                 time->tv_nsec *= 1000;
153                 if (data_type == 'C')
154                         *compressed = true;
155                 else
156                         *compressed = false;
157         } else if (sscanf(buffer, RAMOOPS_KERNMSG_HDR "%lld.%lu\n%n",
158                           (time64_t *)&time->tv_sec, &time->tv_nsec,
159                           &header_length) == 2) {
160                 time->tv_nsec *= 1000;
161                 *compressed = false;
162         } else {
163                 time->tv_sec = 0;
164                 time->tv_nsec = 0;
165                 *compressed = false;
166         }
167         return header_length;
168 }
169 
170 static bool prz_ok(struct persistent_ram_zone *prz)
171 {
172         return !!prz && !!(persistent_ram_old_size(prz) +
173                            persistent_ram_ecc_string(prz, NULL, 0));
174 }
175 
176 static ssize_t ramoops_pstore_read(struct pstore_record *record)
177 {
178         ssize_t size = 0;
179         struct ramoops_context *cxt = record->psi->data;
180         struct persistent_ram_zone *prz = NULL;
181         int header_length = 0;
182         bool free_prz = false;
183 
184         /*
185          * Ramoops headers provide time stamps for PSTORE_TYPE_DMESG, but
186          * PSTORE_TYPE_CONSOLE and PSTORE_TYPE_FTRACE don't currently have
187          * valid time stamps, so it is initialized to zero.
188          */
189         record->time.tv_sec = 0;
190         record->time.tv_nsec = 0;
191         record->compressed = false;
192 
193         /* Find the next valid persistent_ram_zone for DMESG */
194         while (cxt->dump_read_cnt < cxt->max_dump_cnt && !prz) {
195                 prz = ramoops_get_next_prz(cxt->dprzs, cxt->dump_read_cnt++,
196                                            record);
197                 if (!prz_ok(prz))
198                         continue;
199                 header_length = ramoops_read_kmsg_hdr(persistent_ram_old(prz),
200                                                       &record->time,
201                                                       &record->compressed);
202                 /* Clear and skip this DMESG record if it has no valid header */
203                 if (!header_length) {
204                         persistent_ram_free_old(prz);
205                         persistent_ram_zap(prz);
206                         prz = NULL;
207                 }
208         }
209 
210         if (!prz_ok(prz) && !cxt->console_read_cnt++)
211                 prz = ramoops_get_next_prz(&cxt->cprz, 0 /* single */, record);
212 
213         if (!prz_ok(prz) && !cxt->pmsg_read_cnt++)
214                 prz = ramoops_get_next_prz(&cxt->mprz, 0 /* single */, record);
215 
216         /* ftrace is last since it may want to dynamically allocate memory. */
217         if (!prz_ok(prz)) {
218                 if (!(cxt->flags & RAMOOPS_FLAG_FTRACE_PER_CPU) &&
219                     !cxt->ftrace_read_cnt++) {
220                         prz = ramoops_get_next_prz(cxt->fprzs, 0 /* single */,
221                                                    record);
222                 } else {
223                         /*
224                          * Build a new dummy record which combines all the
225                          * per-cpu records including metadata and ecc info.
226                          */
227                         struct persistent_ram_zone *tmp_prz, *prz_next;
228 
229                         tmp_prz = kzalloc(sizeof(struct persistent_ram_zone),
230                                           GFP_KERNEL);
231                         if (!tmp_prz)
232                                 return -ENOMEM;
233                         prz = tmp_prz;
234                         free_prz = true;
235 
236                         while (cxt->ftrace_read_cnt < cxt->max_ftrace_cnt) {
237                                 prz_next = ramoops_get_next_prz(cxt->fprzs,
238                                                 cxt->ftrace_read_cnt++, record);
239 
240                                 if (!prz_ok(prz_next))
241                                         continue;
242 
243                                 tmp_prz->ecc_info = prz_next->ecc_info;
244                                 tmp_prz->corrected_bytes +=
245                                                 prz_next->corrected_bytes;
246                                 tmp_prz->bad_blocks += prz_next->bad_blocks;
247 
248                                 size = pstore_ftrace_combine_log(
249                                                 &tmp_prz->old_log,
250                                                 &tmp_prz->old_log_size,
251                                                 prz_next->old_log,
252                                                 prz_next->old_log_size);
253                                 if (size)
254                                         goto out;
255                         }
256                         record->id = 0;
257                 }
258         }
259 
260         if (!prz_ok(prz)) {
261                 size = 0;
262                 goto out;
263         }
264 
265         size = persistent_ram_old_size(prz) - header_length;
266 
267         /* ECC correction notice */
268         record->ecc_notice_size = persistent_ram_ecc_string(prz, NULL, 0);
269 
270         record->buf = kmalloc(size + record->ecc_notice_size + 1, GFP_KERNEL);
271         if (record->buf == NULL) {
272                 size = -ENOMEM;
273                 goto out;
274         }
275 
276         memcpy(record->buf, (char *)persistent_ram_old(prz) + header_length,
277                size);
278 
279         persistent_ram_ecc_string(prz, record->buf + size,
280                                   record->ecc_notice_size + 1);
281 
282 out:
283         if (free_prz) {
284                 kfree(prz->old_log);
285                 kfree(prz);
286         }
287 
288         return size;
289 }
290 
291 static size_t ramoops_write_kmsg_hdr(struct persistent_ram_zone *prz,
292                                      struct pstore_record *record)
293 {
294         char hdr[36]; /* "===="(4), %lld(20), "."(1), %06lu(6), "-%c\n"(3) */
295         size_t len;
296 
297         len = scnprintf(hdr, sizeof(hdr),
298                 RAMOOPS_KERNMSG_HDR "%lld.%06lu-%c\n",
299                 (time64_t)record->time.tv_sec,
300                 record->time.tv_nsec / 1000,
301                 record->compressed ? 'C' : 'D');
302         persistent_ram_write(prz, hdr, len);
303 
304         return len;
305 }
306 
307 static int notrace ramoops_pstore_write(struct pstore_record *record)
308 {
309         struct ramoops_context *cxt = record->psi->data;
310         struct persistent_ram_zone *prz;
311         size_t size, hlen;
312 
313         if (record->type == PSTORE_TYPE_CONSOLE) {
314                 if (!cxt->cprz)
315                         return -ENOMEM;
316                 persistent_ram_write(cxt->cprz, record->buf, record->size);
317                 return 0;
318         } else if (record->type == PSTORE_TYPE_FTRACE) {
319                 int zonenum;
320 
321                 if (!cxt->fprzs)
322                         return -ENOMEM;
323                 /*
324                  * Choose zone by if we're using per-cpu buffers.
325                  */
326                 if (cxt->flags & RAMOOPS_FLAG_FTRACE_PER_CPU)
327                         zonenum = smp_processor_id();
328                 else
329                         zonenum = 0;
330 
331                 persistent_ram_write(cxt->fprzs[zonenum], record->buf,
332                                      record->size);
333                 return 0;
334         } else if (record->type == PSTORE_TYPE_PMSG) {
335                 pr_warn_ratelimited("PMSG shouldn't call %s\n", __func__);
336                 return -EINVAL;
337         }
338 
339         if (record->type != PSTORE_TYPE_DMESG)
340                 return -EINVAL;
341 
342         /*
343          * We could filter on record->reason here if we wanted to (which
344          * would duplicate what happened before the "max_reason" setting
345          * was added), but that would defeat the purpose of a system
346          * changing printk.always_kmsg_dump, so instead log everything that
347          * the kmsg dumper sends us, since it should be doing the filtering
348          * based on the combination of printk.always_kmsg_dump and our
349          * requested "max_reason".
350          */
351 
352         /*
353          * Explicitly only take the first part of any new crash.
354          * If our buffer is larger than kmsg_bytes, this can never happen,
355          * and if our buffer is smaller than kmsg_bytes, we don't want the
356          * report split across multiple records.
357          */
358         if (record->part != 1)
359                 return -ENOSPC;
360 
361         if (!cxt->dprzs)
362                 return -ENOSPC;
363 
364         prz = cxt->dprzs[cxt->dump_write_cnt];
365 
366         /*
367          * Since this is a new crash dump, we need to reset the buffer in
368          * case it still has an old dump present. Without this, the new dump
369          * will get appended, which would seriously confuse anything trying
370          * to check dump file contents. Specifically, ramoops_read_kmsg_hdr()
371          * expects to find a dump header in the beginning of buffer data, so
372          * we must to reset the buffer values, in order to ensure that the
373          * header will be written to the beginning of the buffer.
374          */
375         persistent_ram_zap(prz);
376 
377         /* Build header and append record contents. */
378         hlen = ramoops_write_kmsg_hdr(prz, record);
379         if (!hlen)
380                 return -ENOMEM;
381 
382         size = record->size;
383         if (size + hlen > prz->buffer_size)
384                 size = prz->buffer_size - hlen;
385         persistent_ram_write(prz, record->buf, size);
386 
387         cxt->dump_write_cnt = (cxt->dump_write_cnt + 1) % cxt->max_dump_cnt;
388 
389         return 0;
390 }
391 
392 static int notrace ramoops_pstore_write_user(struct pstore_record *record,
393                                              const char __user *buf)
394 {
395         if (record->type == PSTORE_TYPE_PMSG) {
396                 struct ramoops_context *cxt = record->psi->data;
397 
398                 if (!cxt->mprz)
399                         return -ENOMEM;
400                 return persistent_ram_write_user(cxt->mprz, buf, record->size);
401         }
402 
403         return -EINVAL;
404 }
405 
406 static int ramoops_pstore_erase(struct pstore_record *record)
407 {
408         struct ramoops_context *cxt = record->psi->data;
409         struct persistent_ram_zone *prz;
410 
411         switch (record->type) {
412         case PSTORE_TYPE_DMESG:
413                 if (record->id >= cxt->max_dump_cnt)
414                         return -EINVAL;
415                 prz = cxt->dprzs[record->id];
416                 break;
417         case PSTORE_TYPE_CONSOLE:
418                 prz = cxt->cprz;
419                 break;
420         case PSTORE_TYPE_FTRACE:
421                 if (record->id >= cxt->max_ftrace_cnt)
422                         return -EINVAL;
423                 prz = cxt->fprzs[record->id];
424                 break;
425         case PSTORE_TYPE_PMSG:
426                 prz = cxt->mprz;
427                 break;
428         default:
429                 return -EINVAL;
430         }
431 
432         persistent_ram_free_old(prz);
433         persistent_ram_zap(prz);
434 
435         return 0;
436 }
437 
438 static struct ramoops_context oops_cxt = {
439         .pstore = {
440                 .owner  = THIS_MODULE,
441                 .name   = "ramoops",
442                 .open   = ramoops_pstore_open,
443                 .read   = ramoops_pstore_read,
444                 .write  = ramoops_pstore_write,
445                 .write_user     = ramoops_pstore_write_user,
446                 .erase  = ramoops_pstore_erase,
447         },
448 };
449 
450 static void ramoops_free_przs(struct ramoops_context *cxt)
451 {
452         int i;
453 
454         /* Free dump PRZs */
455         if (cxt->dprzs) {
456                 for (i = 0; i < cxt->max_dump_cnt; i++)
457                         persistent_ram_free(cxt->dprzs[i]);
458 
459                 kfree(cxt->dprzs);
460                 cxt->max_dump_cnt = 0;
461         }
462 
463         /* Free ftrace PRZs */
464         if (cxt->fprzs) {
465                 for (i = 0; i < cxt->max_ftrace_cnt; i++)
466                         persistent_ram_free(cxt->fprzs[i]);
467                 kfree(cxt->fprzs);
468                 cxt->max_ftrace_cnt = 0;
469         }
470 }
471 
472 static int ramoops_init_przs(const char *name,
473                              struct device *dev, struct ramoops_context *cxt,
474                              struct persistent_ram_zone ***przs,
475                              phys_addr_t *paddr, size_t mem_sz,
476                              ssize_t record_size,
477                              unsigned int *cnt, u32 sig, u32 flags)
478 {
479         int err = -ENOMEM;
480         int i;
481         size_t zone_sz;
482         struct persistent_ram_zone **prz_ar;
483 
484         /* Allocate nothing for 0 mem_sz or 0 record_size. */
485         if (mem_sz == 0 || record_size == 0) {
486                 *cnt = 0;
487                 return 0;
488         }
489 
490         /*
491          * If we have a negative record size, calculate it based on
492          * mem_sz / *cnt. If we have a positive record size, calculate
493          * cnt from mem_sz / record_size.
494          */
495         if (record_size < 0) {
496                 if (*cnt == 0)
497                         return 0;
498                 record_size = mem_sz / *cnt;
499                 if (record_size == 0) {
500                         dev_err(dev, "%s record size == 0 (%zu / %u)\n",
501                                 name, mem_sz, *cnt);
502                         goto fail;
503                 }
504         } else {
505                 *cnt = mem_sz / record_size;
506                 if (*cnt == 0) {
507                         dev_err(dev, "%s record count == 0 (%zu / %zu)\n",
508                                 name, mem_sz, record_size);
509                         goto fail;
510                 }
511         }
512 
513         if (*paddr + mem_sz - cxt->phys_addr > cxt->size) {
514                 dev_err(dev, "no room for %s mem region (0x%zx@0x%llx) in (0x%lx@0x%llx)\n",
515                         name,
516                         mem_sz, (unsigned long long)*paddr,
517                         cxt->size, (unsigned long long)cxt->phys_addr);
518                 goto fail;
519         }
520 
521         zone_sz = mem_sz / *cnt;
522         if (!zone_sz) {
523                 dev_err(dev, "%s zone size == 0\n", name);
524                 goto fail;
525         }
526 
527         prz_ar = kcalloc(*cnt, sizeof(**przs), GFP_KERNEL);
528         if (!prz_ar)
529                 goto fail;
530 
531         for (i = 0; i < *cnt; i++) {
532                 char *label;
533 
534                 if (*cnt == 1)
535                         label = kasprintf(GFP_KERNEL, "ramoops:%s", name);
536                 else
537                         label = kasprintf(GFP_KERNEL, "ramoops:%s(%d/%d)",
538                                           name, i, *cnt - 1);
539                 prz_ar[i] = persistent_ram_new(*paddr, zone_sz, sig,
540                                                &cxt->ecc_info,
541                                                cxt->memtype, flags, label);
542                 kfree(label);
543                 if (IS_ERR(prz_ar[i])) {
544                         err = PTR_ERR(prz_ar[i]);
545                         dev_err(dev, "failed to request %s mem region (0x%zx@0x%llx): %d\n",
546                                 name, record_size,
547                                 (unsigned long long)*paddr, err);
548 
549                         while (i > 0) {
550                                 i--;
551                                 persistent_ram_free(prz_ar[i]);
552                         }
553                         kfree(prz_ar);
554                         goto fail;
555                 }
556                 *paddr += zone_sz;
557                 prz_ar[i]->type = pstore_name_to_type(name);
558         }
559 
560         *przs = prz_ar;
561         return 0;
562 
563 fail:
564         *cnt = 0;
565         return err;
566 }
567 
568 static int ramoops_init_prz(const char *name,
569                             struct device *dev, struct ramoops_context *cxt,
570                             struct persistent_ram_zone **prz,
571                             phys_addr_t *paddr, size_t sz, u32 sig)
572 {
573         char *label;
574 
575         if (!sz)
576                 return 0;
577 
578         if (*paddr + sz - cxt->phys_addr > cxt->size) {
579                 dev_err(dev, "no room for %s mem region (0x%zx@0x%llx) in (0x%lx@0x%llx)\n",
580                         name, sz, (unsigned long long)*paddr,
581                         cxt->size, (unsigned long long)cxt->phys_addr);
582                 return -ENOMEM;
583         }
584 
585         label = kasprintf(GFP_KERNEL, "ramoops:%s", name);
586         *prz = persistent_ram_new(*paddr, sz, sig, &cxt->ecc_info,
587                                   cxt->memtype, PRZ_FLAG_ZAP_OLD, label);
588         kfree(label);
589         if (IS_ERR(*prz)) {
590                 int err = PTR_ERR(*prz);
591 
592                 dev_err(dev, "failed to request %s mem region (0x%zx@0x%llx): %d\n",
593                         name, sz, (unsigned long long)*paddr, err);
594                 return err;
595         }
596 
597         *paddr += sz;
598         (*prz)->type = pstore_name_to_type(name);
599 
600         return 0;
601 }
602 
603 /* Read a u32 from a dt property and make sure it's safe for an int. */
604 static int ramoops_parse_dt_u32(struct platform_device *pdev,
605                                 const char *propname,
606                                 u32 default_value, u32 *value)
607 {
608         u32 val32 = 0;
609         int ret;
610 
611         ret = of_property_read_u32(pdev->dev.of_node, propname, &val32);
612         if (ret == -EINVAL) {
613                 /* field is missing, use default value. */
614                 val32 = default_value;
615         } else if (ret < 0) {
616                 dev_err(&pdev->dev, "failed to parse property %s: %d\n",
617                         propname, ret);
618                 return ret;
619         }
620 
621         /* Sanity check our results. */
622         if (val32 > INT_MAX) {
623                 dev_err(&pdev->dev, "%s %u > INT_MAX\n", propname, val32);
624                 return -EOVERFLOW;
625         }
626 
627         *value = val32;
628         return 0;
629 }
630 
631 static int ramoops_parse_dt(struct platform_device *pdev,
632                             struct ramoops_platform_data *pdata)
633 {
634         struct device_node *of_node = pdev->dev.of_node;
635         struct device_node *parent_node;
636         struct resource *res;
637         u32 value;
638         int ret;
639 
640         dev_dbg(&pdev->dev, "using Device Tree\n");
641 
642         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
643         if (!res) {
644                 dev_err(&pdev->dev,
645                         "failed to locate DT /reserved-memory resource\n");
646                 return -EINVAL;
647         }
648 
649         pdata->mem_size = resource_size(res);
650         pdata->mem_address = res->start;
651         pdata->mem_type = of_property_read_bool(of_node, "unbuffered");
652         /*
653          * Setting "no-dump-oops" is deprecated and will be ignored if
654          * "max_reason" is also specified.
655          */
656         if (of_property_read_bool(of_node, "no-dump-oops"))
657                 pdata->max_reason = KMSG_DUMP_PANIC;
658         else
659                 pdata->max_reason = KMSG_DUMP_OOPS;
660 
661 #define parse_u32(name, field, default_value) {                         \
662                 ret = ramoops_parse_dt_u32(pdev, name, default_value,   \
663                                             &value);                    \
664                 if (ret < 0)                                            \
665                         return ret;                                     \
666                 field = value;                                          \
667         }
668 
669         parse_u32("record-size", pdata->record_size, 0);
670         parse_u32("console-size", pdata->console_size, 0);
671         parse_u32("ftrace-size", pdata->ftrace_size, 0);
672         parse_u32("pmsg-size", pdata->pmsg_size, 0);
673         parse_u32("ecc-size", pdata->ecc_info.ecc_size, 0);
674         parse_u32("flags", pdata->flags, 0);
675         parse_u32("max-reason", pdata->max_reason, pdata->max_reason);
676 
677 #undef parse_u32
678 
679         /*
680          * Some old Chromebooks relied on the kernel setting the
681          * console_size and pmsg_size to the record size since that's
682          * what the downstream kernel did.  These same Chromebooks had
683          * "ramoops" straight under the root node which isn't
684          * according to the current upstream bindings (though it was
685          * arguably acceptable under a prior version of the bindings).
686          * Let's make those old Chromebooks work by detecting that
687          * we're not a child of "reserved-memory" and mimicking the
688          * expected behavior.
689          */
690         parent_node = of_get_parent(of_node);
691         if (!of_node_name_eq(parent_node, "reserved-memory") &&
692             !pdata->console_size && !pdata->ftrace_size &&
693             !pdata->pmsg_size && !pdata->ecc_info.ecc_size) {
694                 pdata->console_size = pdata->record_size;
695                 pdata->pmsg_size = pdata->record_size;
696         }
697         of_node_put(parent_node);
698 
699         return 0;
700 }
701 
702 static int ramoops_probe(struct platform_device *pdev)
703 {
704         struct device *dev = &pdev->dev;
705         struct ramoops_platform_data *pdata = dev->platform_data;
706         struct ramoops_platform_data pdata_local;
707         struct ramoops_context *cxt = &oops_cxt;
708         size_t dump_mem_sz;
709         phys_addr_t paddr;
710         int err = -EINVAL;
711 
712         /*
713          * Only a single ramoops area allowed at a time, so fail extra
714          * probes.
715          */
716         if (cxt->max_dump_cnt) {
717                 pr_err("already initialized\n");
718                 goto fail_out;
719         }
720 
721         if (dev_of_node(dev) && !pdata) {
722                 pdata = &pdata_local;
723                 memset(pdata, 0, sizeof(*pdata));
724 
725                 err = ramoops_parse_dt(pdev, pdata);
726                 if (err < 0)
727                         goto fail_out;
728         }
729 
730         /* Make sure we didn't get bogus platform data pointer. */
731         if (!pdata) {
732                 pr_err("NULL platform data\n");
733                 goto fail_out;
734         }
735 
736         if (!pdata->mem_size || (!pdata->record_size && !pdata->console_size &&
737                         !pdata->ftrace_size && !pdata->pmsg_size)) {
738                 pr_err("The memory size and the record/console size must be "
739                         "non-zero\n");
740                 goto fail_out;
741         }
742 
743         if (pdata->record_size && !is_power_of_2(pdata->record_size))
744                 pdata->record_size = rounddown_pow_of_two(pdata->record_size);
745         if (pdata->console_size && !is_power_of_2(pdata->console_size))
746                 pdata->console_size = rounddown_pow_of_two(pdata->console_size);
747         if (pdata->ftrace_size && !is_power_of_2(pdata->ftrace_size))
748                 pdata->ftrace_size = rounddown_pow_of_two(pdata->ftrace_size);
749         if (pdata->pmsg_size && !is_power_of_2(pdata->pmsg_size))
750                 pdata->pmsg_size = rounddown_pow_of_two(pdata->pmsg_size);
751 
752         cxt->size = pdata->mem_size;
753         cxt->phys_addr = pdata->mem_address;
754         cxt->memtype = pdata->mem_type;
755         cxt->record_size = pdata->record_size;
756         cxt->console_size = pdata->console_size;
757         cxt->ftrace_size = pdata->ftrace_size;
758         cxt->pmsg_size = pdata->pmsg_size;
759         cxt->flags = pdata->flags;
760         cxt->ecc_info = pdata->ecc_info;
761 
762         paddr = cxt->phys_addr;
763 
764         dump_mem_sz = cxt->size - cxt->console_size - cxt->ftrace_size
765                         - cxt->pmsg_size;
766         err = ramoops_init_przs("dmesg", dev, cxt, &cxt->dprzs, &paddr,
767                                 dump_mem_sz, cxt->record_size,
768                                 &cxt->max_dump_cnt, 0, 0);
769         if (err)
770                 goto fail_out;
771 
772         err = ramoops_init_prz("console", dev, cxt, &cxt->cprz, &paddr,
773                                cxt->console_size, 0);
774         if (err)
775                 goto fail_init_cprz;
776 
777         cxt->max_ftrace_cnt = (cxt->flags & RAMOOPS_FLAG_FTRACE_PER_CPU)
778                                 ? nr_cpu_ids
779                                 : 1;
780         err = ramoops_init_przs("ftrace", dev, cxt, &cxt->fprzs, &paddr,
781                                 cxt->ftrace_size, -1,
782                                 &cxt->max_ftrace_cnt, LINUX_VERSION_CODE,
783                                 (cxt->flags & RAMOOPS_FLAG_FTRACE_PER_CPU)
784                                         ? PRZ_FLAG_NO_LOCK : 0);
785         if (err)
786                 goto fail_init_fprz;
787 
788         err = ramoops_init_prz("pmsg", dev, cxt, &cxt->mprz, &paddr,
789                                 cxt->pmsg_size, 0);
790         if (err)
791                 goto fail_init_mprz;
792 
793         cxt->pstore.data = cxt;
794         /*
795          * Prepare frontend flags based on which areas are initialized.
796          * For ramoops_init_przs() cases, the "max count" variable tells
797          * if there are regions present. For ramoops_init_prz() cases,
798          * the single region size is how to check.
799          */
800         cxt->pstore.flags = 0;
801         if (cxt->max_dump_cnt) {
802                 cxt->pstore.flags |= PSTORE_FLAGS_DMESG;
803                 cxt->pstore.max_reason = pdata->max_reason;
804         }
805         if (cxt->console_size)
806                 cxt->pstore.flags |= PSTORE_FLAGS_CONSOLE;
807         if (cxt->max_ftrace_cnt)
808                 cxt->pstore.flags |= PSTORE_FLAGS_FTRACE;
809         if (cxt->pmsg_size)
810                 cxt->pstore.flags |= PSTORE_FLAGS_PMSG;
811 
812         /*
813          * Since bufsize is only used for dmesg crash dumps, it
814          * must match the size of the dprz record (after PRZ header
815          * and ECC bytes have been accounted for).
816          */
817         if (cxt->pstore.flags & PSTORE_FLAGS_DMESG) {
818                 cxt->pstore.bufsize = cxt->dprzs[0]->buffer_size;
819                 cxt->pstore.buf = kzalloc(cxt->pstore.bufsize, GFP_KERNEL);
820                 if (!cxt->pstore.buf) {
821                         pr_err("cannot allocate pstore crash dump buffer\n");
822                         err = -ENOMEM;
823                         goto fail_clear;
824                 }
825         }
826 
827         err = pstore_register(&cxt->pstore);
828         if (err) {
829                 pr_err("registering with pstore failed\n");
830                 goto fail_buf;
831         }
832 
833         /*
834          * Update the module parameter variables as well so they are visible
835          * through /sys/module/ramoops/parameters/
836          */
837         mem_size = pdata->mem_size;
838         mem_address = pdata->mem_address;
839         record_size = pdata->record_size;
840         ramoops_max_reason = pdata->max_reason;
841         ramoops_console_size = pdata->console_size;
842         ramoops_pmsg_size = pdata->pmsg_size;
843         ramoops_ftrace_size = pdata->ftrace_size;
844 
845         pr_info("using 0x%lx@0x%llx, ecc: %d\n",
846                 cxt->size, (unsigned long long)cxt->phys_addr,
847                 cxt->ecc_info.ecc_size);
848 
849         return 0;
850 
851 fail_buf:
852         kfree(cxt->pstore.buf);
853 fail_clear:
854         cxt->pstore.bufsize = 0;
855         persistent_ram_free(cxt->mprz);
856 fail_init_mprz:
857 fail_init_fprz:
858         persistent_ram_free(cxt->cprz);
859 fail_init_cprz:
860         ramoops_free_przs(cxt);
861 fail_out:
862         return err;
863 }
864 
865 static int ramoops_remove(struct platform_device *pdev)
866 {
867         struct ramoops_context *cxt = &oops_cxt;
868 
869         pstore_unregister(&cxt->pstore);
870 
871         kfree(cxt->pstore.buf);
872         cxt->pstore.bufsize = 0;
873 
874         persistent_ram_free(cxt->mprz);
875         persistent_ram_free(cxt->cprz);
876         ramoops_free_przs(cxt);
877 
878         return 0;
879 }
880 
881 static const struct of_device_id dt_match[] = {
882         { .compatible = "ramoops" },
883         {}
884 };
885 
886 static struct platform_driver ramoops_driver = {
887         .probe          = ramoops_probe,
888         .remove         = ramoops_remove,
889         .driver         = {
890                 .name           = "ramoops",
891                 .of_match_table = dt_match,
892         },
893 };
894 
895 static inline void ramoops_unregister_dummy(void)
896 {
897         platform_device_unregister(dummy);
898         dummy = NULL;
899 }
900 
901 static void __init ramoops_register_dummy(void)
902 {
903         struct ramoops_platform_data pdata;
904 
905         /*
906          * Prepare a dummy platform data structure to carry the module
907          * parameters. If mem_size isn't set, then there are no module
908          * parameters, and we can skip this.
909          */
910         if (!mem_size)
911                 return;
912 
913         pr_info("using module parameters\n");
914 
915         memset(&pdata, 0, sizeof(pdata));
916         pdata.mem_size = mem_size;
917         pdata.mem_address = mem_address;
918         pdata.mem_type = mem_type;
919         pdata.record_size = record_size;
920         pdata.console_size = ramoops_console_size;
921         pdata.ftrace_size = ramoops_ftrace_size;
922         pdata.pmsg_size = ramoops_pmsg_size;
923         /* If "max_reason" is set, its value has priority over "dump_oops". */
924         if (ramoops_max_reason >= 0)
925                 pdata.max_reason = ramoops_max_reason;
926         /* Otherwise, if "dump_oops" is set, parse it into "max_reason". */
927         else if (ramoops_dump_oops != -1)
928                 pdata.max_reason = ramoops_dump_oops ? KMSG_DUMP_OOPS
929                                                      : KMSG_DUMP_PANIC;
930         /* And if neither are explicitly set, use the default. */
931         else
932                 pdata.max_reason = KMSG_DUMP_OOPS;
933         pdata.flags = RAMOOPS_FLAG_FTRACE_PER_CPU;
934 
935         /*
936          * For backwards compatibility ramoops.ecc=1 means 16 bytes ECC
937          * (using 1 byte for ECC isn't much of use anyway).
938          */
939         pdata.ecc_info.ecc_size = ramoops_ecc == 1 ? 16 : ramoops_ecc;
940 
941         dummy = platform_device_register_data(NULL, "ramoops", -1,
942                         &pdata, sizeof(pdata));
943         if (IS_ERR(dummy)) {
944                 pr_info("could not create platform device: %ld\n",
945                         PTR_ERR(dummy));
946                 dummy = NULL;
947         }
948 }
949 
950 static int __init ramoops_init(void)
951 {
952         int ret;
953 
954         ramoops_register_dummy();
955         ret = platform_driver_register(&ramoops_driver);
956         if (ret != 0)
957                 ramoops_unregister_dummy();
958 
959         return ret;
960 }
961 postcore_initcall(ramoops_init);
962 
963 static void __exit ramoops_exit(void)
964 {
965         platform_driver_unregister(&ramoops_driver);
966         ramoops_unregister_dummy();
967 }
968 module_exit(ramoops_exit);
969 
970 MODULE_LICENSE("GPL");
971 MODULE_AUTHOR("Marco Stornelli <marco.stornelli@gmail.com>");
972 MODULE_DESCRIPTION("RAM Oops/Panic logger/driver");
973 

~ [ 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