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, ...) 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 } 294