Merge tag 'pstore-v4.20-rc5' of git://git.kernel.org/pub/scm/linux/kernel/git/kees...
[sfrench/cifs-2.6.git] / include / linux / pstore.h
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 timespec64       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 bytes (must match
94  *              smallest number of bytes available for writing to a
95  *              backend entry, since compressed bytes don't take kindly
96  *              to being truncated)
97  *
98  * @read_mutex: serializes @open, @read, @close, and @erase callbacks
99  * @flags:      bitfield of frontends the backend can accept writes for
100  * @data:       backend-private pointer passed back during callbacks
101  *
102  * Callbacks:
103  *
104  * @open:
105  *      Notify backend that pstore is starting a full read of backend
106  *      records. Followed by one or more @read calls, and a final @close.
107  *
108  *      @psi:   in: pointer to the struct pstore_info for the backend
109  *
110  *      Returns 0 on success, and non-zero on error.
111  *
112  * @close:
113  *      Notify backend that pstore has finished a full read of backend
114  *      records. Always preceded by an @open call and one or more @read
115  *      calls.
116  *
117  *      @psi:   in: pointer to the struct pstore_info for the backend
118  *
119  *      Returns 0 on success, and non-zero on error. (Though pstore will
120  *      ignore the error.)
121  *
122  * @read:
123  *      Read next available backend record. Called after a successful
124  *      @open.
125  *
126  *      @record:
127  *              pointer to record to populate. @buf should be allocated
128  *              by the backend and filled. At least @type and @id should
129  *              be populated, since these are used when creating pstorefs
130  *              file names.
131  *
132  *      Returns record size on success, zero when no more records are
133  *      available, or negative on error.
134  *
135  * @write:
136  *      A newly generated record needs to be written to backend storage.
137  *
138  *      @record:
139  *              pointer to record metadata. When @type is PSTORE_TYPE_DMESG,
140  *              @buf will be pointing to the preallocated @psi.buf, since
141  *              memory allocation may be broken during an Oops. Regardless,
142  *              @buf must be proccesed or copied before returning. The
143  *              backend is also expected to write @id with something that
144  *              can help identify this record to a future @erase callback.
145  *              The @time field will be prepopulated with the current time,
146  *              when available. The @size field will have the size of data
147  *              in @buf.
148  *
149  *      Returns 0 on success, and non-zero on error.
150  *
151  * @write_user:
152  *      Perform a frontend write to a backend record, using a specified
153  *      buffer that is coming directly from userspace, instead of the
154  *      @record @buf.
155  *
156  *      @record:        pointer to record metadata.
157  *      @buf:           pointer to userspace contents to write to backend
158  *
159  *      Returns 0 on success, and non-zero on error.
160  *
161  * @erase:
162  *      Delete a record from backend storage.  Different backends
163  *      identify records differently, so entire original record is
164  *      passed back to assist in identification of what the backend
165  *      should remove from storage.
166  *
167  *      @record:        pointer to record metadata.
168  *
169  *      Returns 0 on success, and non-zero on error.
170  *
171  */
172 struct pstore_info {
173         struct module   *owner;
174         char            *name;
175
176         spinlock_t      buf_lock;
177         char            *buf;
178         size_t          bufsize;
179
180         struct mutex    read_mutex;
181
182         int             flags;
183         void            *data;
184
185         int             (*open)(struct pstore_info *psi);
186         int             (*close)(struct pstore_info *psi);
187         ssize_t         (*read)(struct pstore_record *record);
188         int             (*write)(struct pstore_record *record);
189         int             (*write_user)(struct pstore_record *record,
190                                       const char __user *buf);
191         int             (*erase)(struct pstore_record *record);
192 };
193
194 /* Supported frontends */
195 #define PSTORE_FLAGS_DMESG      (1 << 0)
196 #define PSTORE_FLAGS_CONSOLE    (1 << 1)
197 #define PSTORE_FLAGS_FTRACE     (1 << 2)
198 #define PSTORE_FLAGS_PMSG       (1 << 3)
199
200 extern int pstore_register(struct pstore_info *);
201 extern void pstore_unregister(struct pstore_info *);
202 extern bool pstore_cannot_block_path(enum kmsg_dump_reason reason);
203
204 struct pstore_ftrace_record {
205         unsigned long ip;
206         unsigned long parent_ip;
207         u64 ts;
208 };
209
210 /*
211  * ftrace related stuff: Both backends and frontends need these so expose
212  * them here.
213  */
214
215 #if NR_CPUS <= 2 && defined(CONFIG_ARM_THUMB)
216 #define PSTORE_CPU_IN_IP 0x1
217 #elif NR_CPUS <= 4 && defined(CONFIG_ARM)
218 #define PSTORE_CPU_IN_IP 0x3
219 #endif
220
221 #define TS_CPU_SHIFT 8
222 #define TS_CPU_MASK (BIT(TS_CPU_SHIFT) - 1)
223
224 /*
225  * If CPU number can be stored in IP, store it there, otherwise store it in
226  * the time stamp. This means more timestamp resolution is available when
227  * the CPU can be stored in the IP.
228  */
229 #ifdef PSTORE_CPU_IN_IP
230 static inline void
231 pstore_ftrace_encode_cpu(struct pstore_ftrace_record *rec, unsigned int cpu)
232 {
233         rec->ip |= cpu;
234 }
235
236 static inline unsigned int
237 pstore_ftrace_decode_cpu(struct pstore_ftrace_record *rec)
238 {
239         return rec->ip & PSTORE_CPU_IN_IP;
240 }
241
242 static inline u64
243 pstore_ftrace_read_timestamp(struct pstore_ftrace_record *rec)
244 {
245         return rec->ts;
246 }
247
248 static inline void
249 pstore_ftrace_write_timestamp(struct pstore_ftrace_record *rec, u64 val)
250 {
251         rec->ts = val;
252 }
253 #else
254 static inline void
255 pstore_ftrace_encode_cpu(struct pstore_ftrace_record *rec, unsigned int cpu)
256 {
257         rec->ts &= ~(TS_CPU_MASK);
258         rec->ts |= cpu;
259 }
260
261 static inline unsigned int
262 pstore_ftrace_decode_cpu(struct pstore_ftrace_record *rec)
263 {
264         return rec->ts & TS_CPU_MASK;
265 }
266
267 static inline u64
268 pstore_ftrace_read_timestamp(struct pstore_ftrace_record *rec)
269 {
270         return rec->ts >> TS_CPU_SHIFT;
271 }
272
273 static inline void
274 pstore_ftrace_write_timestamp(struct pstore_ftrace_record *rec, u64 val)
275 {
276         rec->ts = (rec->ts & TS_CPU_MASK) | (val << TS_CPU_SHIFT);
277 }
278 #endif
279
280 #endif /*_LINUX_PSTORE_H*/