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, reason, &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 mutex_init(&psinfo->read_mutex); 171 spin_unlock(&pstore_lock); 172 173 if (owner && !try_module_get(owner)) { 174 psinfo = NULL; 175 return -EINVAL; 176 } 177 178 if (pstore_is_mounted()) 179 pstore_get_records(0); 180 181 kmsg_dump_register(&pstore_dumper); 182 183 pstore_timer.expires = jiffies + PSTORE_INTERVAL; 184 add_timer(&pstore_timer); 185 186 return 0; 187 } 188 EXPORT_SYMBOL_GPL(pstore_register); 189 190 /* 191 * Read all the records from the persistent store. Create 192 * files in our filesystem. Don't warn about -EEXIST errors 193 * when we are re-scanning the backing store looking to add new 194 * error records. 195 */ 196 void pstore_get_records(int quiet) 197 { 198 struct pstore_info *psi = psinfo; 199 char *buf = NULL; 200 ssize_t size; 201 u64 id; 202 enum pstore_type_id type; 203 struct timespec time; 204 int failed = 0, rc; 205 206 if (!psi) 207 return; 208 209 mutex_lock(&psi->read_mutex); 210 if (psi->open && psi->open(psi)) 211 goto out; 212 213 while ((size = psi->read(&id, &type, &time, &buf, psi)) > 0) { 214 rc = pstore_mkfile(type, psi->name, id, buf, (size_t)size, 215 time, psi); 216 kfree(buf); 217 buf = NULL; 218 if (rc && (rc != -EEXIST || !quiet)) 219 failed++; 220 } 221 if (psi->close) 222 psi->close(psi); 223 out: 224 mutex_unlock(&psi->read_mutex); 225 226 if (failed) 227 printk(KERN_WARNING "pstore: failed to load %d record(s) from '%s'\n", 228 failed, psi->name); 229 } 230 231 static void pstore_dowork(struct work_struct *work) 232 { 233 pstore_get_records(1); 234 } 235 236 static void pstore_timefunc(unsigned long dummy) 237 { 238 if (pstore_new_entry) { 239 pstore_new_entry = 0; 240 schedule_work(&pstore_work); 241 } 242 243 mod_timer(&pstore_timer, jiffies + PSTORE_INTERVAL); 244 } 245 246 module_param(backend, charp, 0444); 247 MODULE_PARM_DESC(backend, "Pstore backend to use"); 248