cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

storage.c (6271B)


      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}