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 = 0; 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 oopscount++; 301 while (total < kmsg_bytes) { 302 char *dst; 303 unsigned long size; 304 int hsize; 305 int zipped_len = -1; 306 size_t len; 307 bool compressed; 308 size_t total_len; 309 310 if (big_oops_buf && is_locked) { 311 dst = big_oops_buf; 312 hsize = sprintf(dst, "%s#%d Part%u\n", why, 313 oopscount, part); 314 size = big_oops_buf_sz - hsize; 315 316 if (!kmsg_dump_get_buffer(dumper, true, dst + hsize, 317 size, &len)) 318 break; 319 320 zipped_len = pstore_compress(dst, psinfo->buf, 321 hsize + len, psinfo->bufsize); 322 323 if (zipped_len > 0) { 324 compressed = true; 325 total_len = zipped_len; 326 } else { 327 compressed = false; 328 total_len = copy_kmsg_to_buffer(hsize, len); 329 } 330 } else { 331 dst = psinfo->buf; 332 hsize = sprintf(dst, "%s#%d Part%u\n", why, oopscount, 333 part); 334 size = psinfo->bufsize - hsize; 335 dst += hsize; 336 337 if (!kmsg_dump_get_buffer(dumper, true, dst, 338 size, &len)) 339 break; 340 341 compressed = false; 342 total_len = hsize + len; 343 } 344 345 ret = psinfo->write(PSTORE_TYPE_DMESG, reason, &id, part, 346 oopscount, compressed, total_len, psinfo); 347 if (ret == 0 && reason == KMSG_DUMP_OOPS && pstore_is_mounted()) 348 pstore_new_entry = 1; 349 350 total += total_len; 351 part++; 352 } 353 if (pstore_cannot_block_path(reason)) { 354 if (is_locked) 355 spin_unlock_irqrestore(&psinfo->buf_lock, flags); 356 } else 357 spin_unlock_irqrestore(&psinfo->buf_lock, flags); 358 } 359 360 static struct kmsg_dumper pstore_dumper = { 361 .dump = pstore_dump, 362 }; 363 364 /* 365 * Register with kmsg_dump to save last part of console log on panic. 366 */ 367 static void pstore_register_kmsg(void) 368 { 369 kmsg_dump_register(&pstore_dumper); 370 } 371 372 static void pstore_unregister_kmsg(void) 373 { 374 kmsg_dump_unregister(&pstore_dumper); 375 } 376 377 #ifdef CONFIG_PSTORE_CONSOLE 378 static void pstore_console_write(struct console *con, const char *s, unsigned c) 379 { 380 const char *e = s + c; 381 382 while (s < e) { 383 unsigned long flags; 384 u64 id; 385 386 if (c > psinfo->bufsize) 387 c = psinfo->bufsize; 388 389 if (oops_in_progress) { 390 if (!spin_trylock_irqsave(&psinfo->buf_lock, flags)) 391 break; 392 } else { 393 spin_lock_irqsave(&psinfo->buf_lock, flags); 394 } 395 memcpy(psinfo->buf, s, c); 396 psinfo->write(PSTORE_TYPE_CONSOLE, 0, &id, 0, 0, 0, c, psinfo); 397 spin_unlock_irqrestore(&psinfo->buf_lock, flags); 398 s += c; 399 c = e - s; 400 } 401 } 402 403 static struct console pstore_console = { 404 .name = "pstore", 405 .write = pstore_console_write, 406 .flags = CON_PRINTBUFFER | CON_ENABLED | CON_ANYTIME, 407 .index = -1, 408 }; 409 410 static void pstore_register_console(void) 411 { 412 register_console(&pstore_console); 413 } 414 415 static void pstore_unregister_console(void) 416 { 417 unregister_console(&pstore_console); 418 } 419 #else 420 static void pstore_register_console(void) {} 421 static void pstore_unregister_console(void) {} 422 #endif 423 424 static int pstore_write_compat(enum pstore_type_id type, 425 enum kmsg_dump_reason reason, 426 u64 *id, unsigned int part, int count, 427 bool compressed, size_t size, 428 struct pstore_info *psi) 429 { 430 return psi->write_buf(type, reason, id, part, psinfo->buf, compressed, 431 size, psi); 432 } 433 434 /* 435 * platform specific persistent storage driver registers with 436 * us here. If pstore is already mounted, call the platform 437 * read function right away to populate the file system. If not 438 * then the pstore mount code will call us later to fill out 439 * the file system. 440 */ 441 int pstore_register(struct pstore_info *psi) 442 { 443 struct module *owner = psi->owner; 444 445 if (backend && strcmp(backend, psi->name)) 446 return -EPERM; 447 448 spin_lock(&pstore_lock); 449 if (psinfo) { 450 spin_unlock(&pstore_lock); 451 return -EBUSY; 452 } 453 454 if (!psi->write) 455 psi->write = pstore_write_compat; 456 psinfo = psi; 457 mutex_init(&psinfo->read_mutex); 458 spin_unlock(&pstore_lock); 459 460 if (owner && !try_module_get(owner)) { 461 psinfo = NULL; 462 return -EINVAL; 463 } 464 465 allocate_buf_for_compression(); 466 467 if (pstore_is_mounted()) 468 pstore_get_records(0); 469 470 pstore_register_kmsg(); 471 472 if ((psi->flags & PSTORE_FLAGS_FRAGILE) == 0) { 473 pstore_register_console(); 474 pstore_register_ftrace(); 475 pstore_register_pmsg(); 476 } 477 478 if (pstore_update_ms >= 0) { 479 pstore_timer.expires = jiffies + 480 msecs_to_jiffies(pstore_update_ms); 481 add_timer(&pstore_timer); 482 } 483 484 /* 485 * Update the module parameter backend, so it is visible 486 * through /sys/module/pstore/parameters/backend 487 */ 488 backend = psi->name; 489 490 module_put(owner); 491 492 pr_info("Registered %s as persistent store backend\n", psi->name); 493 494 return 0; 495 } 496 EXPORT_SYMBOL_GPL(pstore_register); 497 498 void pstore_unregister(struct pstore_info *psi) 499 { 500 pstore_unregister_pmsg(); 501 pstore_unregister_ftrace(); 502 pstore_unregister_console(); 503 pstore_unregister_kmsg(); 504 505 free_buf_for_compression(); 506 507 psinfo = NULL; 508 backend = NULL; 509 } 510 EXPORT_SYMBOL_GPL(pstore_unregister); 511 512 /* 513 * Read all the records from the persistent store. Create 514 * files in our filesystem. Don't warn about -EEXIST errors 515 * when we are re-scanning the backing store looking to add new 516 * error records. 517 */ 518 void pstore_get_records(int quiet) 519 { 520 struct pstore_info *psi = psinfo; 521 char *buf = NULL; 522 ssize_t size; 523 u64 id; 524 int count; 525 enum pstore_type_id type; 526 struct timespec time; 527 int failed = 0, rc; 528 bool compressed; 529 int unzipped_len = -1; 530 531 if (!psi) 532 return; 533 534 mutex_lock(&psi->read_mutex); 535 if (psi->open && psi->open(psi)) 536 goto out; 537 538 while ((size = psi->read(&id, &type, &count, &time, &buf, &compressed, 539 psi)) > 0) { 540 if (compressed && (type == PSTORE_TYPE_DMESG)) { 541 if (big_oops_buf) 542 unzipped_len = pstore_decompress(buf, 543 big_oops_buf, size, 544 big_oops_buf_sz); 545 546 if (unzipped_len > 0) { 547 kfree(buf); 548 buf = big_oops_buf; 549 size = unzipped_len; 550 compressed = false; 551 } else { 552 pr_err("decompression failed;returned %d\n", 553 unzipped_len); 554 compressed = true; 555 } 556 } 557 rc = pstore_mkfile(type, psi->name, id, count, buf, 558 compressed, (size_t)size, time, psi); 559 if (unzipped_len < 0) { 560 /* Free buffer other than big oops */ 561 kfree(buf); 562 buf = NULL; 563 } else 564 unzipped_len = -1; 565 if (rc && (rc != -EEXIST || !quiet)) 566 failed++; 567 } 568 if (psi->close) 569 psi->close(psi); 570 out: 571 mutex_unlock(&psi->read_mutex); 572 573 if (failed) 574 pr_warn("failed to load %d record(s) from '%s'\n", 575 failed, psi->name); 576 } 577 578 static void pstore_dowork(struct work_struct *work) 579 { 580 pstore_get_records(1); 581 } 582 583 static void pstore_timefunc(unsigned long dummy) 584 { 585 if (pstore_new_entry) { 586 pstore_new_entry = 0; 587 schedule_work(&pstore_work); 588 } 589 590 mod_timer(&pstore_timer, jiffies + msecs_to_jiffies(pstore_update_ms)); 591 } 592 593 module_param(backend, charp, 0444); 594 MODULE_PARM_DESC(backend, "Pstore backend to use"); 595