LXR linux/fs/romfs/storage.c

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