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 char *reason_str[] = { 72 "Oops", "Panic", "Kexec", "Restart", "Halt", "Poweroff", "Emergency" 73 }; 74 75 /* 76 * callback from kmsg_dump. (s2,l2) has the most recently 77 * written bytes, older bytes are in (s1,l1). Save as much 78 * as we can from the end of the buffer. 79 */ 80 static void pstore_dump(struct kmsg_dumper *dumper, 81 enum kmsg_dump_reason reason, 82 const char *s1, unsigned long l1, 83 const char *s2, unsigned long l2) 84 { 85 unsigned long s1_start, s2_start; 86 unsigned long l1_cpy, l2_cpy; 87 unsigned long size, total = 0; 88 char *dst, *why; 89 u64 id; 90 int hsize, ret; 91 unsigned int part = 1; 92 unsigned long flags = 0; 93 int is_locked = 0; 94 95 if (reason < ARRAY_SIZE(reason_str)) 96 why = reason_str[reason]; 97 else 98 why = "Unknown"; 99 100 if (in_nmi()) { 101 is_locked = spin_trylock(&psinfo->buf_lock); 102 if (!is_locked) 103 pr_err("pstore dump routine blocked in NMI, may corrupt error record\n"); 104 } else 105 spin_lock_irqsave(&psinfo->buf_lock, flags); 106 oopscount++; 107 while (total < kmsg_bytes) { 108 dst = psinfo->buf; 109 hsize = sprintf(dst, "%s#%d Part%d\n", why, oopscount, part); 110 size = psinfo->bufsize - hsize; 111 dst += hsize; 112 113 l2_cpy = min(l2, size); 114 l1_cpy = min(l1, size - l2_cpy); 115 116 if (l1_cpy + l2_cpy == 0) 117 break; 118 119 s2_start = l2 - l2_cpy; 120 s1_start = l1 - l1_cpy; 121 122 memcpy(dst, s1 + s1_start, l1_cpy); 123 memcpy(dst + l1_cpy, s2 + s2_start, l2_cpy); 124 125 ret = psinfo->write(PSTORE_TYPE_DMESG, &id, part, 126 hsize + l1_cpy + l2_cpy, psinfo); 127 if (ret == 0 && reason == KMSG_DUMP_OOPS && pstore_is_mounted()) 128 pstore_new_entry = 1; 129 l1 -= l1_cpy; 130 l2 -= l2_cpy; 131 total += l1_cpy + l2_cpy; 132 part++; 133 } 134 if (in_nmi()) { 135 if (is_locked) 136 spin_unlock(&psinfo->buf_lock); 137 } else 138 spin_unlock_irqrestore(&psinfo->buf_lock, flags); 139 } 140 141 static struct kmsg_dumper pstore_dumper = { 142 .dump = pstore_dump, 143 }; 144 145 /* 146 * platform specific persistent storage driver registers with 147 * us here. If pstore is already mounted, call the platform 148 * read function right away to populate the file system. If not 149 * then the pstore mount code will call us later to fill out 150 * the file system. 151 * 152 * Register with kmsg_dump to save last part of console log on panic. 153 */ 154 int pstore_register(struct pstore_info *psi) 155 { 156 struct module *owner = psi->owner; 157 158 spin_lock(&pstore_lock); 159 if (psinfo) { 160 spin_unlock(&pstore_lock); 161 return -EBUSY; 162 } 163 164 if (backend && strcmp(backend, psi->name)) { 165 spin_unlock(&pstore_lock); 166 return -EINVAL; 167 } 168 169 psinfo = psi; 170 spin_unlock(&pstore_lock); 171 172 if (owner && !try_module_get(owner)) { 173 psinfo = NULL; 174 return -EINVAL; 175 } 176 177 if (pstore_is_mounted()) 178 pstore_get_records(0); 179 180 kmsg_dump_register(&pstore_dumper); 181 182 pstore_timer.expires = jiffies + PSTORE_INTERVAL; 183 add_timer(&pstore_timer); 184 185 return 0; 186 } 187 EXPORT_SYMBOL_GPL(pstore_register); 188 189 /* 190 * Read all the records from the persistent store. Create 191 * files in our filesystem. Don't warn about -EEXIST errors 192 * when we are re-scanning the backing store looking to add new 193 * error records. 194 */ 195 void pstore_get_records(int quiet) 196 { 197 struct pstore_info *psi = psinfo; 198 ssize_t size; 199 u64 id; 200 enum pstore_type_id type; 201 struct timespec time; 202 int failed = 0, rc; 203 unsigned long flags; 204 205 if (!psi) 206 return; 207 208 spin_lock_irqsave(&psinfo->buf_lock, flags); 209 rc = psi->open(psi); 210 if (rc) 211 goto out; 212 213 while ((size = psi->read(&id, &type, &time, psi)) > 0) { 214 rc = pstore_mkfile(type, psi->name, id, psi->buf, (size_t)size, 215 time, psi); 216 if (rc && (rc != -EEXIST || !quiet)) 217 failed++; 218 } 219 psi->close(psi); 220 out: 221 spin_unlock_irqrestore(&psinfo->buf_lock, flags); 222 223 if (failed) 224 printk(KERN_WARNING "pstore: failed to load %d record(s) from '%s'\n", 225 failed, psi->name); 226 } 227 228 static void pstore_dowork(struct work_struct *work) 229 { 230 pstore_get_records(1); 231 } 232 233 static void pstore_timefunc(unsigned long dummy) 234 { 235 if (pstore_new_entry) { 236 pstore_new_entry = 0; 237 schedule_work(&pstore_work); 238 } 239 240 mod_timer(&pstore_timer, jiffies + PSTORE_INTERVAL); 241 } 242 243 /* 244 * Call platform driver to write a record to the 245 * persistent store. 246 */ 247 int pstore_write(enum pstore_type_id type, char *buf, size_t size) 248 { 249 u64 id; 250 int ret; 251 unsigned long flags; 252 253 if (!psinfo) 254 return -ENODEV; 255 256 if (size > psinfo->bufsize) 257 return -EFBIG; 258 259 spin_lock_irqsave(&psinfo->buf_lock, flags); 260 memcpy(psinfo->buf, buf, size); 261 ret = psinfo->write(type, &id, 0, size, psinfo); 262 if (ret == 0 && pstore_is_mounted()) 263 pstore_mkfile(PSTORE_TYPE_DMESG, psinfo->name, id, psinfo->buf, 264 size, CURRENT_TIME, psinfo); 265 spin_unlock_irqrestore(&psinfo->buf_lock, flags); 266 267 return 0; 268 } 269 EXPORT_SYMBOL_GPL(pstore_write); 270 271 module_param(backend, charp, 0444); 272 MODULE_PARM_DESC(backend, "Pstore backend to use"); 273