IB/mlx4: Fix shutdown crash accessing a non-existent bitmap
[linux-2.6.git] / fs / romfs / storage.c
1 /* RomFS storage access routines
2  *
3  * Copyright © 2007 Red Hat, Inc. All Rights Reserved.
4  * Written by David Howells (dhowells@redhat.com)
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version
9  * 2 of the License, or (at your option) any later version.
10  */
11
12 #include <linux/fs.h>
13 #include <linux/mtd/super.h>
14 #include <linux/buffer_head.h>
15 #include "internal.h"
16
17 #if !defined(CONFIG_ROMFS_ON_MTD) && !defined(CONFIG_ROMFS_ON_BLOCK)
18 #error no ROMFS backing store interface configured
19 #endif
20
21 #ifdef CONFIG_ROMFS_ON_MTD
22 #define ROMFS_MTD_READ(sb, ...) ((sb)->s_mtd->read((sb)->s_mtd, ##__VA_ARGS__))
23
24 /*
25  * read data from an romfs image on an MTD device
26  */
27 static int romfs_mtd_read(struct super_block *sb, unsigned long pos,
28                           void *buf, size_t buflen)
29 {
30         size_t rlen;
31         int ret;
32
33         ret = ROMFS_MTD_READ(sb, pos, buflen, &rlen, buf);
34         return (ret < 0 || rlen != buflen) ? -EIO : 0;
35 }
36
37 /*
38  * determine the length of a string in a romfs image on an MTD device
39  */
40 static ssize_t romfs_mtd_strnlen(struct super_block *sb,
41                                  unsigned long pos, size_t maxlen)
42 {
43         ssize_t n = 0;
44         size_t segment;
45         u_char buf[16], *p;
46         size_t len;
47         int ret;
48
49         /* scan the string up to 16 bytes at a time */
50         while (maxlen > 0) {
51                 segment = min_t(size_t, maxlen, 16);
52                 ret = ROMFS_MTD_READ(sb, pos, segment, &len, buf);
53                 if (ret < 0)
54                         return ret;
55                 p = memchr(buf, 0, len);
56                 if (p)
57                         return n + (p - buf);
58                 maxlen -= len;
59                 pos += len;
60                 n += len;
61         }
62
63         return n;
64 }
65
66 /*
67  * compare a string to one in a romfs image on MTD
68  * - return 1 if matched, 0 if differ, -ve if error
69  */
70 static int romfs_mtd_strcmp(struct super_block *sb, unsigned long pos,
71                             const char *str, size_t size)
72 {
73         u_char buf[17];
74         size_t len, segment;
75         int ret;
76
77         /* scan the string up to 16 bytes at a time, and attempt to grab the
78          * trailing NUL whilst we're at it */
79         buf[0] = 0xff;
80
81         while (size > 0) {
82                 segment = min_t(size_t, size + 1, 17);
83                 ret = ROMFS_MTD_READ(sb, pos, segment, &len, buf);
84                 if (ret < 0)
85                         return ret;
86                 len--;
87                 if (memcmp(buf, str, len) != 0)
88                         return 0;
89                 buf[0] = buf[len];
90                 size -= len;
91                 pos += len;
92                 str += len;
93         }
94
95         /* check the trailing NUL was */
96         if (buf[0])
97                 return 0;
98
99         return 1;
100 }
101 #endif /* CONFIG_ROMFS_ON_MTD */
102
103 #ifdef CONFIG_ROMFS_ON_BLOCK
104 /*
105  * read data from an romfs image on a block device
106  */
107 static int romfs_blk_read(struct super_block *sb, unsigned long pos,
108                           void *buf, size_t buflen)
109 {
110         struct buffer_head *bh;
111         unsigned long offset;
112         size_t segment;
113
114         /* copy the string up to blocksize bytes at a time */
115         while (buflen > 0) {
116                 offset = pos & (ROMBSIZE - 1);
117                 segment = min_t(size_t, buflen, ROMBSIZE - offset);
118                 bh = sb_bread(sb, pos >> ROMBSBITS);
119                 if (!bh)
120                         return -EIO;
121                 memcpy(buf, bh->b_data + offset, segment);
122                 brelse(bh);
123                 buf += segment;
124                 buflen -= segment;
125                 pos += segment;
126         }
127
128         return 0;
129 }
130
131 /*
132  * determine the length of a string in romfs on a block device
133  */
134 static ssize_t romfs_blk_strnlen(struct super_block *sb,
135                                  unsigned long pos, size_t limit)
136 {
137         struct buffer_head *bh;
138         unsigned long offset;
139         ssize_t n = 0;
140         size_t segment;
141         u_char *buf, *p;
142
143         /* scan the string up to blocksize bytes at a time */
144         while (limit > 0) {
145                 offset = pos & (ROMBSIZE - 1);
146                 segment = min_t(size_t, limit, ROMBSIZE - offset);
147                 bh = sb_bread(sb, pos >> ROMBSBITS);
148                 if (!bh)
149                         return -EIO;
150                 buf = bh->b_data + offset;
151                 p = memchr(buf, 0, segment);
152                 brelse(bh);
153                 if (p)
154                         return n + (p - buf);
155                 limit -= segment;
156                 pos += segment;
157                 n += segment;
158         }
159
160         return n;
161 }
162
163 /*
164  * compare a string to one in a romfs image on a block device
165  * - return 1 if matched, 0 if differ, -ve if error
166  */
167 static int romfs_blk_strcmp(struct super_block *sb, unsigned long pos,
168                             const char *str, size_t size)
169 {
170         struct buffer_head *bh;
171         unsigned long offset;
172         size_t segment;
173         bool matched, terminated = false;
174
175         /* compare string up to a block at a time */
176         while (size > 0) {
177                 offset = pos & (ROMBSIZE - 1);
178                 segment = min_t(size_t, size, ROMBSIZE - offset);
179                 bh = sb_bread(sb, pos >> ROMBSBITS);
180                 if (!bh)
181                         return -EIO;
182                 matched = (memcmp(bh->b_data + offset, str, segment) == 0);
183
184                 size -= segment;
185                 pos += segment;
186                 str += segment;
187                 if (matched && size == 0 && offset + segment < ROMBSIZE) {
188                         if (!bh->b_data[offset + segment])
189                                 terminated = true;
190                         else
191                                 matched = false;
192                 }
193                 brelse(bh);
194                 if (!matched)
195                         return 0;
196         }
197
198         if (!terminated) {
199                 /* the terminating NUL must be on the first byte of the next
200                  * block */
201                 BUG_ON((pos & (ROMBSIZE - 1)) != 0);
202                 bh = sb_bread(sb, pos >> ROMBSBITS);
203                 if (!bh)
204                         return -EIO;
205                 matched = !bh->b_data[0];
206                 brelse(bh);
207                 if (!matched)
208                         return 0;
209         }
210
211         return 1;
212 }
213 #endif /* CONFIG_ROMFS_ON_BLOCK */
214
215 /*
216  * read data from the romfs image
217  */
218 int romfs_dev_read(struct super_block *sb, unsigned long pos,
219                    void *buf, size_t buflen)
220 {
221         size_t limit;
222
223         limit = romfs_maxsize(sb);
224         if (pos >= limit)
225                 return -EIO;
226         if (buflen > limit - pos)
227                 buflen = limit - pos;
228
229 #ifdef CONFIG_ROMFS_ON_MTD
230         if (sb->s_mtd)
231                 return romfs_mtd_read(sb, pos, buf, buflen);
232 #endif
233 #ifdef CONFIG_ROMFS_ON_BLOCK
234         if (sb->s_bdev)
235                 return romfs_blk_read(sb, pos, buf, buflen);
236 #endif
237         return -EIO;
238 }
239
240 /*
241  * determine the length of a string in romfs
242  */
243 ssize_t romfs_dev_strnlen(struct super_block *sb,
244                           unsigned long pos, size_t maxlen)
245 {
246         size_t limit;
247
248         limit = romfs_maxsize(sb);
249         if (pos >= limit)
250                 return -EIO;
251         if (maxlen > limit - pos)
252                 maxlen = limit - pos;
253
254 #ifdef CONFIG_ROMFS_ON_MTD
255         if (sb->s_mtd)
256                 return romfs_mtd_strnlen(sb, pos, maxlen);
257 #endif
258 #ifdef CONFIG_ROMFS_ON_BLOCK
259         if (sb->s_bdev)
260                 return romfs_blk_strnlen(sb, pos, maxlen);
261 #endif
262         return -EIO;
263 }
264
265 /*
266  * compare a string to one in romfs
267  * - the string to be compared to, str, may not be NUL-terminated; instead the
268  *   string is of the specified size
269  * - return 1 if matched, 0 if differ, -ve if error
270  */
271 int romfs_dev_strcmp(struct super_block *sb, unsigned long pos,
272                      const char *str, size_t size)
273 {
274         size_t limit;
275
276         limit = romfs_maxsize(sb);
277         if (pos >= limit)
278                 return -EIO;
279         if (size > ROMFS_MAXFN)
280                 return -ENAMETOOLONG;
281         if (size + 1 > limit - pos)
282                 return -EIO;
283
284 #ifdef CONFIG_ROMFS_ON_MTD
285         if (sb->s_mtd)
286                 return romfs_mtd_strcmp(sb, pos, str, size);
287 #endif
288 #ifdef CONFIG_ROMFS_ON_BLOCK
289         if (sb->s_bdev)
290                 return romfs_blk_strcmp(sb, pos, str, size);
291 #endif
292         return -EIO;
293 }