1 /* 2 * Persistent Storage - platform driver interface parts. 3 * 4 * Copyright (C) 2007-2008 Google, Inc. 5 * Copyright (C) 2010 Intel Corporation <tony.luck@intel.com> 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License version 2 as 9 * published by the Free Software Foundation. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 19 */ 20 21 #define pr_fmt(fmt) "pstore: " fmt 22 23 #include <linux/atomic.h> 24 #include <linux/types.h> 25 #include <linux/errno.h> 26 #include <linux/init.h> 27 #include <linux/kmsg_dump.h> 28 #include <linux/console.h> 29 #include <linux/module.h> 30 #include <linux/pstore.h> 31 #include <linux/zlib.h> 32 #include <linux/string.h> 33 #include <linux/timer.h> 34 #include <linux/slab.h> 35 #include <linux/uaccess.h> 36 #include <linux/hardirq.h> 37 #include <linux/jiffies.h> 38 #include <linux/workqueue.h> 39 40 #include "internal.h" 41 42 /* 43 * We defer making "oops" entries appear in pstore - see 44 * whether the system is actually still running well enough 45 * to let someone see the entry 46 */ 47 static int pstore_update_ms = -1; 48 module_param_named(update_ms, pstore_update_ms, int, 0600); 49 MODULE_PARM_DESC(update_ms, "milliseconds before pstore updates its content " 50 "(default is -1, which means runtime updates are disabled; " 51 "enabling this option is not safe, it may lead to further " 52 "corruption on Oopses)"); 53 54 static int pstore_new_entry; 55 56 static void pstore_timefunc(unsigned long); 57 static DEFINE_TIMER(pstore_timer, pstore_timefunc, 0, 0); 58 59 static void pstore_dowork(struct work_struct *); 60 static DECLARE_WORK(pstore_work, pstore_dowork); 61 62 /* 63 * pstore_lock just protects "psinfo" during 64 * calls to pstore_register() 65 */ 66 static DEFINE_SPINLOCK(pstore_lock); 67 struct pstore_info *psinfo; 68 69 static char *backend; 70 71 /* Compression parameters */ 72 #define COMPR_LEVEL 6 73 #define WINDOW_BITS 12 74 #define MEM_LEVEL 4 75 static struct z_stream_s stream; 76 77 static char *big_oops_buf; 78 static size_t big_oops_buf_sz; 79 80 /* How much of the console log to snapshot */ 81 static unsigned long kmsg_bytes = 10240; 82 83 void pstore_set_kmsg_bytes(int bytes) 84 { 85 kmsg_bytes = bytes; 86 } 87 88 /* Tag each group of saved records with a sequence number */ 89 static int oopscount; 90 91 static const char *get_reason_str(enum kmsg_dump_reason reason) 92 { 93 switch (reason) { 94 case KMSG_DUMP_PANIC: 95 return "Panic"; 96 case KMSG_DUMP_OOPS: 97 return "Oops"; 98 case KMSG_DUMP_EMERG: 99 return "Emergency"; 100 case KMSG_DUMP_RESTART: 101 return "Restart"; 102 case KMSG_DUMP_HALT: 103 return "Halt"; 104 case KMSG_DUMP_POWEROFF: 105 return "Poweroff"; 106 default: 107 return "Unknown"; 108 } 109 } 110 111 bool pstore_cannot_block_path(enum kmsg_dump_reason reason) 112 { 113 /* 114 * In case of NMI path, pstore shouldn't be blocked 115 * regardless of reason. 116 */ 117 if (in_nmi()) 118 return true; 119 120 switch (reason) { 121 /* In panic case, other cpus are stopped by smp_send_stop(). */ 122 case KMSG_DUMP_PANIC: 123 /* Emergency restart shouldn't be blocked by spin lock. */ 124 case KMSG_DUMP_EMERG: 125 return true; 126 default: 127 return false; 128 } 129 } 130 EXPORT_SYMBOL_GPL(pstore_cannot_block_path); 131 132 /* Derived from logfs_compress() */ 133 static int pstore_compress(const void *in, void *out, size_t inlen, 134 size_t outlen) 135 { 136 int err, ret; 137 138 ret = -EIO; 139 err = zlib_deflateInit2(&stream, COMPR_LEVEL, Z_DEFLATED, WINDOW_BITS, 140 MEM_LEVEL, Z_DEFAULT_STRATEGY); 141 if (err != Z_OK) 142 goto error; 143 144 stream.next_in = in; 145 stream.avail_in = inlen; 146 stream.total_in = 0; 147 stream.next_out = out; 148 stream.avail_out = outlen; 149 stream.total_out = 0; 150 151 err = zlib_deflate(&stream, Z_FINISH); 152 if (err != Z_STREAM_END) 153 goto error; 154 155 err = zlib_deflateEnd(&stream); 156 if (err != Z_OK) 157 goto error; 158 159 if (stream.total_out >= stream.total_in) 160 goto error; 161 162 ret = stream.total_out; 163 error: 164 return ret; 165 } 166 167 /* Derived from logfs_uncompress */ 168 static int pstore_decompress(void *in, void *out, size_t inlen, size_t outlen) 169 { 170 int err, ret; 171 172 ret = -EIO; 173 err = zlib_inflateInit2(&stream, WINDOW_BITS); 174 if (err != Z_OK) 175 goto error; 176 177 stream.next_in = in; 178 stream.avail_in = inlen; 179 stream.total_in = 0; 180 stream.next_out = out; 181 stream.avail_out = outlen; 182 stream.total_out = 0; 183 184 err = zlib_inflate(&stream, Z_FINISH); 185 if (err != Z_STREAM_END) 186 goto error; 187 188 err = zlib_inflateEnd(&stream); 189 if (err != Z_OK) 190 goto error; 191 192 ret = stream.total_out; 193 error: 194 return ret; 195 } 196 197 static void allocate_buf_for_compression(void) 198 { 199 size_t size; 200 size_t cmpr; 201 202 switch (psinfo->bufsize) { 203 /* buffer range for efivars */ 204 case 1000 ... 2000: 205 cmpr = 56; 206 break; 207 case 2001 ... 3000: 208 cmpr = 54; 209 break; 210 case 3001 ... 3999: 211 cmpr = 52; 212 break; 213 /* buffer range for nvram, erst */ 214 case 4000 ... 10000: 215 cmpr = 45; 216 break; 217 default: 218 cmpr = 60; 219 break; 220 } 221 222 big_oops_buf_sz = (psinfo->bufsize * 100) / cmpr; 223 big_oops_buf = kmalloc(big_oops_buf_sz, GFP_KERNEL); 224 if (big_oops_buf) { 225 size = max(zlib_deflate_workspacesize(WINDOW_BITS, MEM_LEVEL), 226 zlib_inflate_workspacesize()); 227 stream.workspace = kmalloc(size, GFP_KERNEL); 228 if (!stream.workspace) { 229 pr_err("No memory for compression workspace; skipping compression\n"); 230 kfree(big_oops_buf); 231 big_oops_buf = NULL; 232 } 233 } else { 234 pr_err("No memory for uncompressed data; skipping compression\n"); 235 stream.workspace = NULL; 236 } 237 238 } 239 240 static void free_buf_for_compression(void) 241 { 242 kfree(stream.workspace); 243 stream.workspace = NULL; 244 kfree(big_oops_buf); 245 big_oops_buf = NULL; 246 } 247 248 /* 249 * Called when compression fails, since the printk buffer 250 * would be fetched for compression calling it again when 251 * compression fails would have moved the iterator of 252 * printk buffer which results in fetching old contents. 253 * Copy the recent messages from big_oops_buf to psinfo->buf 254 */ 255 static size_t copy_kmsg_to_buffer(int hsize, size_t len) 256 { 257 size_t total_len; 258 size_t diff; 259 260 total_len = hsize + len; 261 262 if (total_len > psinfo->bufsize) { 263 diff = total_len - psinfo->bufsize + hsize; 264 memcpy(psinfo->buf, big_oops_buf, hsize); 265 memcpy(psinfo->buf + hsize, big_oops_buf + diff, 266 psinfo->bufsize - hsize); 267 total_len = psinfo->bufsize; 268 } else 269 memcpy(psinfo->buf, big_oops_buf, total_len); 270 271 return total_len; 272 } 273 274 /* 275 * callback from kmsg_dump. (s2,l2) has the most recently 276 * written bytes, older bytes are in (s1,l1). Save as much 277 * as we can from the end of the buffer. 278 */ 279 static void pstore_dump(struct kmsg_dumper *dumper, 280 enum kmsg_dump_reason reason) 281 { 282 unsigned long total = 0; 283 const char *why; 284 u64 id; 285 unsigned int part = 1; 286 unsigned long flags = 0; 287 int is_locked; 288 int ret; 289 290 why = get_reason_str(reason); 291 292 if (pstore_cannot_block_path(reason)) { 293 is_locked = spin_trylock_irqsave(&psinfo->buf_lock, flags); 294 if (!is_locked) { 295 pr_err("pstore dump routine blocked in %s path, may corrupt error record\n" 296 , in_nmi() ? "NMI" : why); 297 } 298 } else { 299 spin_lock_irqsave(&psinfo->buf_lock, flags); 300 is_locked = 1; 301 } 302 oopscount++; 303 while (total < kmsg_bytes) { 304 char *dst; 305 unsigned long size; 306 int hsize; 307 int zipped_len = -1; 308 size_t len; 309 bool compressed = false; 310 size_t total_len; 311 312 if (big_oops_buf && is_locked) { 313 dst = big_oops_buf; 314 size = big_oops_buf_sz; 315 } else { 316 dst = psinfo->buf; 317 size = psinfo->bufsize; 318 } 319 320 hsize = sprintf(dst, "%s#%d Part%u\n", why, oopscount, part); 321 size -= hsize; 322 323 if (!kmsg_dump_get_buffer(dumper, true, dst + hsize, 324 size, &len)) 325 break; 326 327 if (big_oops_buf && is_locked) { 328 zipped_len = pstore_compress(dst, psinfo->buf, 329 hsize + len, psinfo->bufsize); 330 331 if (zipped_len > 0) { 332 compressed = true; 333 total_len = zipped_len; 334 } else { 335 total_len = copy_kmsg_to_buffer(hsize, len); 336 } 337 } else { 338 total_len = hsize + len; 339 } 340 341 ret = psinfo->write(PSTORE_TYPE_DMESG, reason, &id, part, 342 oopscount, compressed, total_len, psinfo); 343 if (ret == 0 && reason == KMSG_DUMP_OOPS && pstore_is_mounted()) 344 pstore_new_entry = 1; 345 346 total += total_len; 347 part++; 348 } 349 if (is_locked) 350 spin_unlock_irqrestore(&psinfo->buf_lock, flags); 351 } 352 353 static struct kmsg_dumper pstore_dumper = { 354 .dump = pstore_dump, 355 }; 356 357 /* 358 * Register with kmsg_dump to save last part of console log on panic. 359 */ 360 static void pstore_register_kmsg(void) 361 { 362 kmsg_dump_register(&pstore_dumper); 363 } 364 365 static void pstore_unregister_kmsg(void) 366 { 367 kmsg_dump_unregister(&pstore_dumper); 368 } 369 370 #ifdef CONFIG_PSTORE_CONSOLE 371 static void pstore_console_write(struct console *con, const char *s, unsigned c) 372 { 373 const char *e = s + c; 374 375 while (s < e) { 376 unsigned long flags; 377 u64 id; 378 379 if (c > psinfo->bufsize) 380 c = psinfo->bufsize; 381 382 if (oops_in_progress) { 383 if (!spin_trylock_irqsave(&psinfo->buf_lock, flags)) 384 break; 385 } else { 386 spin_lock_irqsave(&psinfo->buf_lock, flags); 387 } 388 memcpy(psinfo->buf, s, c); 389 psinfo->write(PSTORE_TYPE_CONSOLE, 0, &id, 0, 0, 0, c, psinfo); 390 spin_unlock_irqrestore(&psinfo->buf_lock, flags); 391 s += c; 392 c = e - s; 393 } 394 } 395 396 static struct console pstore_console = { 397 .name = "pstore", 398 .write = pstore_console_write, 399 .flags = CON_PRINTBUFFER | CON_ENABLED | CON_ANYTIME, 400 .index = -1, 401 }; 402 403 static void pstore_register_console(void) 404 { 405 register_console(&pstore_console); 406 } 407 408 static void pstore_unregister_console(void) 409 { 410 unregister_console(&pstore_console); 411 } 412 #else 413 static void pstore_register_console(void) {} 414 static void pstore_unregister_console(void) {} 415 #endif 416 417 static int pstore_write_compat(enum pstore_type_id type, 418 enum kmsg_dump_reason reason, 419 u64 *id, unsigned int part, int count, 420 bool compressed, size_t size, 421 struct pstore_info *psi) 422 { 423 return psi->write_buf(type, reason, id, part, psinfo->buf, compressed, 424 size, psi); 425 } 426 427 /* 428 * platform specific persistent storage driver registers with 429 * us here. If pstore is already mounted, call the platform 430 * read function right away to populate the file system. If not 431 * then the pstore mount code will call us later to fill out 432 * the file system. 433 */ 434 int pstore_register(struct pstore_info *psi) 435 { 436 struct module *owner = psi->owner; 437 438 if (backend && strcmp(backend, psi->name)) 439 return -EPERM; 440 441 spin_lock(&pstore_lock); 442 if (psinfo) { 443 spin_unlock(&pstore_lock); 444 return -EBUSY; 445 } 446 447 if (!psi->write) 448 psi->write = pstore_write_compat; 449 psinfo = psi; 450 mutex_init(&psinfo->read_mutex); 451 spin_unlock(&pstore_lock); 452 453 if (owner && !try_module_get(owner)) { 454 psinfo = NULL; 455 return -EINVAL; 456 } 457 458 allocate_buf_for_compression(); 459 460 if (pstore_is_mounted()) 461 pstore_get_records(0); 462 463 pstore_register_kmsg(); 464 465 if ((psi->flags & PSTORE_FLAGS_FRAGILE) == 0) { 466 pstore_register_console(); 467 pstore_register_ftrace(); 468 pstore_register_pmsg(); 469 } 470 471 if (pstore_update_ms >= 0) { 472 pstore_timer.expires = jiffies + 473 msecs_to_jiffies(pstore_update_ms); 474 add_timer(&pstore_timer); 475 } 476 477 /* 478 * Update the module parameter backend, so it is visible 479 * through /sys/module/pstore/parameters/backend 480 */ 481 backend = psi->name; 482 483 module_put(owner); 484 485 pr_info("Registered %s as persistent store backend\n", psi->name); 486 487 return 0; 488 } 489 EXPORT_SYMBOL_GPL(pstore_register); 490 491 void pstore_unregister(struct pstore_info *psi) 492 { 493 if ((psi->flags & PSTORE_FLAGS_FRAGILE) == 0) { 494 pstore_unregister_pmsg(); 495 pstore_unregister_ftrace(); 496 pstore_unregister_console(); 497 } 498 pstore_unregister_kmsg(); 499 500 free_buf_for_compression(); 501 502 psinfo = NULL; 503 backend = NULL; 504 } 505 EXPORT_SYMBOL_GPL(pstore_unregister); 506 507 /* 508 * Read all the records from the persistent store. Create 509 * files in our filesystem. Don't warn about -EEXIST errors 510 * when we are re-scanning the backing store looking to add new 511 * error records. 512 */ 513 void pstore_get_records(int quiet) 514 { 515 struct pstore_info *psi = psinfo; 516 char *buf = NULL; 517 ssize_t size; 518 u64 id; 519 int count; 520 enum pstore_type_id type; 521 struct timespec time; 522 int failed = 0, rc; 523 bool compressed; 524 int unzipped_len = -1; 525 526 if (!psi) 527 return; 528 529 mutex_lock(&psi->read_mutex); 530 if (psi->open && psi->open(psi)) 531 goto out; 532 533 while ((size = psi->read(&id, &type, &count, &time, &buf, &compressed, 534 psi)) > 0) { 535 if (compressed && (type == PSTORE_TYPE_DMESG)) { 536 if (big_oops_buf) 537 unzipped_len = pstore_decompress(buf, 538 big_oops_buf, size, 539 big_oops_buf_sz); 540 541 if (unzipped_len > 0) { 542 kfree(buf); 543 buf = big_oops_buf; 544 size = unzipped_len; 545 compressed = false; 546 } else { 547 pr_err("decompression failed;returned %d\n", 548 unzipped_len); 549 compressed = true; 550 } 551 } 552 rc = pstore_mkfile(type, psi->name, id, count, buf, 553 compressed, (size_t)size, time, psi); 554 if (unzipped_len < 0) { 555 /* Free buffer other than big oops */ 556 kfree(buf); 557 buf = NULL; 558 } else 559 unzipped_len = -1; 560 if (rc && (rc != -EEXIST || !quiet)) 561 failed++; 562 } 563 if (psi->close) 564 psi->close(psi); 565 out: 566 mutex_unlock(&psi->read_mutex); 567 568 if (failed) 569 pr_warn("failed to load %d record(s) from '%s'\n", 570 failed, psi->name); 571 } 572 573 static void pstore_dowork(struct work_struct *work) 574 { 575 pstore_get_records(1); 576 } 577 578 static void pstore_timefunc(unsigned long dummy) 579 { 580 if (pstore_new_entry) { 581 pstore_new_entry = 0; 582 schedule_work(&pstore_work); 583 } 584 585 mod_timer(&pstore_timer, jiffies + msecs_to_jiffies(pstore_update_ms)); 586 } 587 588 module_param(backend, charp, 0444); 589 MODULE_PARM_DESC(backend, "Pstore backend to use"); 590