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