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 size_t size; 156 u64 id; 157 enum pstore_type_id type; 158 struct timespec time; 159 int failed = 0; 160 161 if (!psi) 162 return; 163 164 mutex_lock(&psinfo->buf_mutex); 165 while ((size = psi->read(&id, &type, &time)) > 0) { 166 if (pstore_mkfile(type, psi->name, id, psi->buf, size, 167 time, psi->erase)) 168 failed++; 169 } 170 mutex_unlock(&psinfo->buf_mutex); 171 172 if (failed) 173 printk(KERN_WARNING "pstore: failed to load %d record(s) from '%s'\n", 174 failed, psi->name); 175 } 176 177 /* 178 * Call platform driver to write a record to the 179 * persistent store. 180 */ 181 int pstore_write(enum pstore_type_id type, char *buf, size_t size) 182 { 183 u64 id; 184 185 if (!psinfo) 186 return -ENODEV; 187 188 if (size > psinfo->bufsize) 189 return -EFBIG; 190 191 mutex_lock(&psinfo->buf_mutex); 192 memcpy(psinfo->buf, buf, size); 193 id = psinfo->write(type, size); 194 if (pstore_is_mounted()) 195 pstore_mkfile(PSTORE_TYPE_DMESG, psinfo->name, id, psinfo->buf, 196 size, CURRENT_TIME, psinfo->erase); 197 mutex_unlock(&psinfo->buf_mutex); 198 199 return 0; 200 } 201 EXPORT_SYMBOL_GPL(pstore_write); 202