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/slab.h> 29 #include <linux/uaccess.h> 30 31 #include "internal.h" 32 33 /* 34 * pstore_lock just protects "psinfo" during 35 * calls to pstore_register() 36 */ 37 static DEFINE_SPINLOCK(pstore_lock); 38 static struct pstore_info *psinfo; 39 40 /* How much of the console log to snapshot */ 41 static unsigned long kmsg_bytes = 10240; 42 43 void pstore_set_kmsg_bytes(int bytes) 44 { 45 kmsg_bytes = bytes; 46 } 47 48 /* Tag each group of saved records with a sequence number */ 49 static int oopscount; 50 51 static char *reason_str[] = { 52 "Oops", "Panic", "Kexec", "Restart", "Halt", "Poweroff", "Emergency" 53 }; 54 55 /* 56 * callback from kmsg_dump. (s2,l2) has the most recently 57 * written bytes, older bytes are in (s1,l1). Save as much 58 * as we can from the end of the buffer. 59 */ 60 static void pstore_dump(struct kmsg_dumper *dumper, 61 enum kmsg_dump_reason reason, 62 const char *s1, unsigned long l1, 63 const char *s2, unsigned long l2) 64 { 65 unsigned long s1_start, s2_start; 66 unsigned long l1_cpy, l2_cpy; 67 unsigned long size, total = 0; 68 char *dst, *why; 69 u64 id; 70 int hsize, part = 1; 71 72 if (reason < ARRAY_SIZE(reason_str)) 73 why = reason_str[reason]; 74 else 75 why = "Unknown"; 76 77 mutex_lock(&psinfo->buf_mutex); 78 oopscount++; 79 while (total < kmsg_bytes) { 80 dst = psinfo->buf; 81 hsize = sprintf(dst, "%s#%d Part%d\n", why, oopscount, part++); 82 size = psinfo->bufsize - hsize; 83 dst += hsize; 84 85 l2_cpy = min(l2, size); 86 l1_cpy = min(l1, size - l2_cpy); 87 88 if (l1_cpy + l2_cpy == 0) 89 break; 90 91 s2_start = l2 - l2_cpy; 92 s1_start = l1 - l1_cpy; 93 94 memcpy(dst, s1 + s1_start, l1_cpy); 95 memcpy(dst + l1_cpy, s2 + s2_start, l2_cpy); 96 97 id = psinfo->write(PSTORE_TYPE_DMESG, hsize + l1_cpy + l2_cpy); 98 if (reason == KMSG_DUMP_OOPS && pstore_is_mounted()) 99 pstore_mkfile(PSTORE_TYPE_DMESG, psinfo->name, id, 100 psinfo->buf, hsize + l1_cpy + l2_cpy, 101 CURRENT_TIME, psinfo->erase); 102 l1 -= l1_cpy; 103 l2 -= l2_cpy; 104 total += l1_cpy + l2_cpy; 105 } 106 mutex_unlock(&psinfo->buf_mutex); 107 } 108 109 static struct kmsg_dumper pstore_dumper = { 110 .dump = pstore_dump, 111 }; 112 113 /* 114 * platform specific persistent storage driver registers with 115 * us here. If pstore is already mounted, call the platform 116 * read function right away to populate the file system. If not 117 * then the pstore mount code will call us later to fill out 118 * the file system. 119 * 120 * Register with kmsg_dump to save last part of console log on panic. 121 */ 122 int pstore_register(struct pstore_info *psi) 123 { 124 struct module *owner = psi->owner; 125 126 spin_lock(&pstore_lock); 127 if (psinfo) { 128 spin_unlock(&pstore_lock); 129 return -EBUSY; 130 } 131 psinfo = psi; 132 spin_unlock(&pstore_lock); 133 134 if (owner && !try_module_get(owner)) { 135 psinfo = NULL; 136 return -EINVAL; 137 } 138 139 if (pstore_is_mounted()) 140 pstore_get_records(); 141 142 kmsg_dump_register(&pstore_dumper); 143 144 return 0; 145 } 146 EXPORT_SYMBOL_GPL(pstore_register); 147 148 /* 149 * Read all the records from the persistent store. Create and 150 * file files in our filesystem. 151 */ 152 void pstore_get_records(void) 153 { 154 struct pstore_info *psi = psinfo; 155 ssize_t size; 156 u64 id; 157 enum pstore_type_id type; 158 struct timespec time; 159 int failed = 0, rc; 160 161 if (!psi) 162 return; 163 164 mutex_lock(&psinfo->buf_mutex); 165 rc = psi->open(psi); 166 if (rc) 167 goto out; 168 169 while ((size = psi->read(&id, &type, &time)) > 0) { 170 if (pstore_mkfile(type, psi->name, id, psi->buf, (size_t)size, 171 time, psi->erase)) 172 failed++; 173 } 174 psi->close(psi); 175 out: 176 mutex_unlock(&psinfo->buf_mutex); 177 178 if (failed) 179 printk(KERN_WARNING "pstore: failed to load %d record(s) from '%s'\n", 180 failed, psi->name); 181 } 182 183 /* 184 * Call platform driver to write a record to the 185 * persistent store. 186 */ 187 int pstore_write(enum pstore_type_id type, char *buf, size_t size) 188 { 189 u64 id; 190 191 if (!psinfo) 192 return -ENODEV; 193 194 if (size > psinfo->bufsize) 195 return -EFBIG; 196 197 mutex_lock(&psinfo->buf_mutex); 198 memcpy(psinfo->buf, buf, size); 199 id = psinfo->write(type, size); 200 if (pstore_is_mounted()) 201 pstore_mkfile(PSTORE_TYPE_DMESG, psinfo->name, id, psinfo->buf, 202 size, CURRENT_TIME, psinfo->erase); 203 mutex_unlock(&psinfo->buf_mutex); 204 205 return 0; 206 } 207 EXPORT_SYMBOL_GPL(pstore_write); 208