1 /* 2 * Persistent Storage - pstore.h 3 * 4 * Copyright (C) 2010 Intel Corporation <tony.luck@intel.com> 5 * 6 * This code is the generic layer to export data records from platform 7 * level persistent storage via a file system. 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License version 2 as 11 * published by the Free Software Foundation. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 21 */ 22 #ifndef _LINUX_PSTORE_H 23 #define _LINUX_PSTORE_H 24 25 #include <linux/compiler.h> 26 #include <linux/errno.h> 27 #include <linux/kmsg_dump.h> 28 #include <linux/mutex.h> 29 #include <linux/spinlock.h> 30 #include <linux/time.h> 31 #include <linux/types.h> 32 33 struct module; 34 35 /* pstore record types (see fs/pstore/inode.c for filename templates) */ 36 enum pstore_type_id { 37 PSTORE_TYPE_DMESG = 0, 38 PSTORE_TYPE_MCE = 1, 39 PSTORE_TYPE_CONSOLE = 2, 40 PSTORE_TYPE_FTRACE = 3, 41 /* PPC64 partition types */ 42 PSTORE_TYPE_PPC_RTAS = 4, 43 PSTORE_TYPE_PPC_OF = 5, 44 PSTORE_TYPE_PPC_COMMON = 6, 45 PSTORE_TYPE_PMSG = 7, 46 PSTORE_TYPE_PPC_OPAL = 8, 47 PSTORE_TYPE_UNKNOWN = 255 48 }; 49 50 struct pstore_info; 51 /** 52 * struct pstore_record - details of a pstore record entry 53 * @psi: pstore backend driver information 54 * @type: pstore record type 55 * @id: per-type unique identifier for record 56 * @time: timestamp of the record 57 * @buf: pointer to record contents 58 * @size: size of @buf 59 * @ecc_notice_size: 60 * ECC information for @buf 61 * 62 * Valid for PSTORE_TYPE_DMESG @type: 63 * 64 * @count: Oops count since boot 65 * @reason: kdump reason for notification 66 * @part: position in a multipart record 67 * @compressed: whether the buffer is compressed 68 * 69 */ 70 struct pstore_record { 71 struct pstore_info *psi; 72 enum pstore_type_id type; 73 u64 id; 74 struct timespec time; 75 char *buf; 76 ssize_t size; 77 ssize_t ecc_notice_size; 78 79 int count; 80 enum kmsg_dump_reason reason; 81 unsigned int part; 82 bool compressed; 83 }; 84 85 /** 86 * struct pstore_info - backend pstore driver structure 87 * 88 * @owner: module which is repsonsible for this backend driver 89 * @name: name of the backend driver 90 * 91 * @buf_lock: spinlock to serialize access to @buf 92 * @buf: preallocated crash dump buffer 93 * @bufsize: size of @buf available for crash dump writes 94 * 95 * @read_mutex: serializes @open, @read, @close, and @erase callbacks 96 * @flags: bitfield of frontends the backend can accept writes for 97 * @data: backend-private pointer passed back during callbacks 98 * 99 * Callbacks: 100 * 101 * @open: 102 * Notify backend that pstore is starting a full read of backend 103 * records. Followed by one or more @read calls, and a final @close. 104 * 105 * @psi: in: pointer to the struct pstore_info for the backend 106 * 107 * Returns 0 on success, and non-zero on error. 108 * 109 * @close: 110 * Notify backend that pstore has finished a full read of backend 111 * records. Always preceded by an @open call and one or more @read 112 * calls. 113 * 114 * @psi: in: pointer to the struct pstore_info for the backend 115 * 116 * Returns 0 on success, and non-zero on error. (Though pstore will 117 * ignore the error.) 118 * 119 * @read: 120 * Read next available backend record. Called after a successful 121 * @open. 122 * 123 * @record: 124 * pointer to record to populate. @buf should be allocated 125 * by the backend and filled. At least @type and @id should 126 * be populated, since these are used when creating pstorefs 127 * file names. 128 * 129 * Returns record size on success, zero when no more records are 130 * available, or negative on error. 131 * 132 * @write: 133 * A newly generated record needs to be written to backend storage. 134 * 135 * @record: 136 * pointer to record metadata. When @type is PSTORE_TYPE_DMESG, 137 * @buf will be pointing to the preallocated @psi.buf, since 138 * memory allocation may be broken during an Oops. Regardless, 139 * @buf must be proccesed or copied before returning. The 140 * backend is also expected to write @id with something that 141 * can help identify this record to a future @erase callback. 142 * The @time field will be prepopulated with the current time, 143 * when available. The @size field will have the size of data 144 * in @buf. 145 * 146 * Returns 0 on success, and non-zero on error. 147 * 148 * @write_user: 149 * Perform a frontend write to a backend record, using a specified 150 * buffer that is coming directly from userspace, instead of the 151 * @record @buf. 152 * 153 * @record: pointer to record metadata. 154 * @buf: pointer to userspace contents to write to backend 155 * 156 * Returns 0 on success, and non-zero on error. 157 * 158 * @erase: 159 * Delete a record from backend storage. Different backends 160 * identify records differently, so entire original record is 161 * passed back to assist in identification of what the backend 162 * should remove from storage. 163 * 164 * @record: pointer to record metadata. 165 * 166 * Returns 0 on success, and non-zero on error. 167 * 168 */ 169 struct pstore_info { 170 struct module *owner; 171 char *name; 172 173 spinlock_t buf_lock; 174 char *buf; 175 size_t bufsize; 176 177 struct mutex read_mutex; 178 179 int flags; 180 void *data; 181 182 int (*open)(struct pstore_info *psi); 183 int (*close)(struct pstore_info *psi); 184 ssize_t (*read)(struct pstore_record *record); 185 int (*write)(struct pstore_record *record); 186 int (*write_user)(struct pstore_record *record, 187 const char __user *buf); 188 int (*erase)(struct pstore_record *record); 189 }; 190 191 /* Supported frontends */ 192 #define PSTORE_FLAGS_DMESG (1 << 0) 193 #define PSTORE_FLAGS_CONSOLE (1 << 1) 194 #define PSTORE_FLAGS_FTRACE (1 << 2) 195 #define PSTORE_FLAGS_PMSG (1 << 3) 196 197 extern int pstore_register(struct pstore_info *); 198 extern void pstore_unregister(struct pstore_info *); 199 extern bool pstore_cannot_block_path(enum kmsg_dump_reason reason); 200 201 struct pstore_ftrace_record { 202 unsigned long ip; 203 unsigned long parent_ip; 204 u64 ts; 205 }; 206 207 /* 208 * ftrace related stuff: Both backends and frontends need these so expose 209 * them here. 210 */ 211 212 #if NR_CPUS <= 2 && defined(CONFIG_ARM_THUMB) 213 #define PSTORE_CPU_IN_IP 0x1 214 #elif NR_CPUS <= 4 && defined(CONFIG_ARM) 215 #define PSTORE_CPU_IN_IP 0x3 216 #endif 217 218 #define TS_CPU_SHIFT 8 219 #define TS_CPU_MASK (BIT(TS_CPU_SHIFT) - 1) 220 221 /* 222 * If CPU number can be stored in IP, store it there, otherwise store it in 223 * the time stamp. This means more timestamp resolution is available when 224 * the CPU can be stored in the IP. 225 */ 226 #ifdef PSTORE_CPU_IN_IP 227 static inline void 228 pstore_ftrace_encode_cpu(struct pstore_ftrace_record *rec, unsigned int cpu) 229 { 230 rec->ip |= cpu; 231 } 232 233 static inline unsigned int 234 pstore_ftrace_decode_cpu(struct pstore_ftrace_record *rec) 235 { 236 return rec->ip & PSTORE_CPU_IN_IP; 237 } 238 239 static inline u64 240 pstore_ftrace_read_timestamp(struct pstore_ftrace_record *rec) 241 { 242 return rec->ts; 243 } 244 245 static inline void 246 pstore_ftrace_write_timestamp(struct pstore_ftrace_record *rec, u64 val) 247 { 248 rec->ts = val; 249 } 250 #else 251 static inline void 252 pstore_ftrace_encode_cpu(struct pstore_ftrace_record *rec, unsigned int cpu) 253 { 254 rec->ts &= ~(TS_CPU_MASK); 255 rec->ts |= cpu; 256 } 257 258 static inline unsigned int 259 pstore_ftrace_decode_cpu(struct pstore_ftrace_record *rec) 260 { 261 return rec->ts & TS_CPU_MASK; 262 } 263 264 static inline u64 265 pstore_ftrace_read_timestamp(struct pstore_ftrace_record *rec) 266 { 267 return rec->ts >> TS_CPU_SHIFT; 268 } 269 270 static inline void 271 pstore_ftrace_write_timestamp(struct pstore_ftrace_record *rec, u64 val) 272 { 273 rec->ts = (rec->ts & TS_CPU_MASK) | (val << TS_CPU_SHIFT); 274 } 275 #endif 276 277 #endif /*_LINUX_PSTORE_H*/ 278