1 /* 2 * Persistent Storage - platform driver interface parts. 3 * 4 * Copyright (C) 2010 Intel Corporation <tony.luck@intel.com> 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License version 2 as 8 * published by the Free Software Foundation. 9 * 10 * This program is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU General Public License for more details. 14 * 15 * You should have received a copy of the GNU General Public License 16 * along with this program; if not, write to the Free Software 17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 18 */ 19 20 #include <linux/atomic.h> 21 #include <linux/types.h> 22 #include <linux/errno.h> 23 #include <linux/init.h> 24 #include <linux/kmsg_dump.h> 25 #include <linux/module.h> 26 #include <linux/pstore.h> 27 #include <linux/string.h> 28 #include <linux/timer.h> 29 #include <linux/slab.h> 30 #include <linux/uaccess.h> 31 #include <linux/hardirq.h> 32 #include <linux/workqueue.h> 33 34 #include "internal.h" 35 36 /* 37 * We defer making "oops" entries appear in pstore - see 38 * whether the system is actually still running well enough 39 * to let someone see the entry 40 */ 41 #define PSTORE_INTERVAL (60 * HZ) 42 43 static int pstore_new_entry; 44 45 static void pstore_timefunc(unsigned long); 46 static DEFINE_TIMER(pstore_timer, pstore_timefunc, 0, 0); 47 48 static void pstore_dowork(struct work_struct *); 49 static DECLARE_WORK(pstore_work, pstore_dowork); 50 51 /* 52 * pstore_lock just protects "psinfo" during 53 * calls to pstore_register() 54 */ 55 static DEFINE_SPINLOCK(pstore_lock); 56 static struct pstore_info *psinfo; 57 58 static char *backend; 59 60 /* How much of the console log to snapshot */ 61 static unsigned long kmsg_bytes = 10240; 62 63 void pstore_set_kmsg_bytes(int bytes) 64 { 65 kmsg_bytes = bytes; 66 } 67 68 /* Tag each group of saved records with a sequence number */ 69 static int oopscount; 70 71 static const char *get_reason_str(enum kmsg_dump_reason reason) 72 { 73 switch (reason) { 74 case KMSG_DUMP_PANIC: 75 return "Panic"; 76 case KMSG_DUMP_OOPS: 77 return "Oops"; 78 case KMSG_DUMP_EMERG: 79 return "Emergency"; 80 case KMSG_DUMP_RESTART: 81 return "Restart"; 82 case KMSG_DUMP_HALT: 83 return "Halt"; 84 case KMSG_DUMP_POWEROFF: 85 return "Poweroff"; 86 default: 87 return "Unknown"; 88 } 89 } 90 91 /* 92 * callback from kmsg_dump. (s2,l2) has the most recently 93 * written bytes, older bytes are in (s1,l1). Save as much 94 * as we can from the end of the buffer. 95 */ 96 static void pstore_dump(struct kmsg_dumper *dumper, 97 enum kmsg_dump_reason reason) 98 { 99 unsigned long total = 0; 100 const char *why; 101 u64 id; 102 unsigned int part = 1; 103 unsigned long flags = 0; 104 int is_locked = 0; 105 int ret; 106 107 why = get_reason_str(reason); 108 109 if (in_nmi()) { 110 is_locked = spin_trylock(&psinfo->buf_lock); 111 if (!is_locked) 112 pr_err("pstore dump routine blocked in NMI, may corrupt error record\n"); 113 } else 114 spin_lock_irqsave(&psinfo->buf_lock, flags); 115 oopscount++; 116 while (total < kmsg_bytes) { 117 char *dst; 118 unsigned long size; 119 int hsize; 120 size_t len; 121 122 dst = psinfo->buf; 123 hsize = sprintf(dst, "%s#%d Part%d\n", why, oopscount, part); 124 size = psinfo->bufsize - hsize; 125 dst += hsize; 126 127 if (!kmsg_dump_get_buffer(dumper, true, dst, size, &len)) 128 break; 129 130 ret = psinfo->write(PSTORE_TYPE_DMESG, reason, &id, part, 131 hsize + len, psinfo); 132 if (ret == 0 && reason == KMSG_DUMP_OOPS && pstore_is_mounted()) 133 pstore_new_entry = 1; 134 135 total += hsize + len; 136 part++; 137 } 138 if (in_nmi()) { 139 if (is_locked) 140 spin_unlock(&psinfo->buf_lock); 141 } else 142 spin_unlock_irqrestore(&psinfo->buf_lock, flags); 143 } 144 145 static struct kmsg_dumper pstore_dumper = { 146 .dump = pstore_dump, 147 }; 148 149 /* 150 * platform specific persistent storage driver registers with 151 * us here. If pstore is already mounted, call the platform 152 * read function right away to populate the file system. If not 153 * then the pstore mount code will call us later to fill out 154 * the file system. 155 * 156 * Register with kmsg_dump to save last part of console log on panic. 157 */ 158 int pstore_register(struct pstore_info *psi) 159 { 160 struct module *owner = psi->owner; 161 162 spin_lock(&pstore_lock); 163 if (psinfo) { 164 spin_unlock(&pstore_lock); 165 return -EBUSY; 166 } 167 168 if (backend && strcmp(backend, psi->name)) { 169 spin_unlock(&pstore_lock); 170 return -EINVAL; 171 } 172 173 psinfo = psi; 174 mutex_init(&psinfo->read_mutex); 175 spin_unlock(&pstore_lock); 176 177 if (owner && !try_module_get(owner)) { 178 psinfo = NULL; 179 return -EINVAL; 180 } 181 182 if (pstore_is_mounted()) 183 pstore_get_records(0); 184 185 kmsg_dump_register(&pstore_dumper); 186 187 pstore_timer.expires = jiffies + PSTORE_INTERVAL; 188 add_timer(&pstore_timer); 189 190 return 0; 191 } 192 EXPORT_SYMBOL_GPL(pstore_register); 193 194 /* 195 * Read all the records from the persistent store. Create 196 * files in our filesystem. Don't warn about -EEXIST errors 197 * when we are re-scanning the backing store looking to add new 198 * error records. 199 */ 200 void pstore_get_records(int quiet) 201 { 202 struct pstore_info *psi = psinfo; 203 char *buf = NULL; 204 ssize_t size; 205 u64 id; 206 enum pstore_type_id type; 207 struct timespec time; 208 int failed = 0, rc; 209 210 if (!psi) 211 return; 212 213 mutex_lock(&psi->read_mutex); 214 if (psi->open && psi->open(psi)) 215 goto out; 216 217 while ((size = psi->read(&id, &type, &time, &buf, psi)) > 0) { 218 rc = pstore_mkfile(type, psi->name, id, buf, (size_t)size, 219 time, psi); 220 kfree(buf); 221 buf = NULL; 222 if (rc && (rc != -EEXIST || !quiet)) 223 failed++; 224 } 225 if (psi->close) 226 psi->close(psi); 227 out: 228 mutex_unlock(&psi->read_mutex); 229 230 if (failed) 231 printk(KERN_WARNING "pstore: failed to load %d record(s) from '%s'\n", 232 failed, psi->name); 233 } 234 235 static void pstore_dowork(struct work_struct *work) 236 { 237 pstore_get_records(1); 238 } 239 240 static void pstore_timefunc(unsigned long dummy) 241 { 242 if (pstore_new_entry) { 243 pstore_new_entry = 0; 244 schedule_work(&pstore_work); 245 } 246 247 mod_timer(&pstore_timer, jiffies + PSTORE_INTERVAL); 248 } 249 250 module_param(backend, charp, 0444); 251 MODULE_PARM_DESC(backend, "Pstore backend to use"); 252