On Thu, Jul 02, 2020 at 04:28:26PM +0200, Ahmad Fatoum wrote: > > > On 6/15/20 8:02 AM, Sascha Hauer wrote: > > This changes the way ramfs stores its data. So far we used equally sized > > chunks, this patch changes it to use chunks in a size that fits our > > needs. The chunks are always allocated in the size they are needed for > > the current truncation. Only if we fail to allocate all desired memory > > at once we fall back to allocating smaller chunks. Together with using > > the generic list implementation this results in smaller code and has > > the advantage that many image files end up being contiguously in memory > > and thus we can provide a memmap for them. Files will end up > > contiguously in memory when they are first created, then truncated to > > the final size and then filled up with data. This is something which > > is normally easily achievable when desired. > > > > Signed-off-by: Sascha Hauer <[email protected]> > > --- > > fs/ramfs.c | 307 +++++++++++++++++++++++++++-------------------------- > > 1 file changed, 159 insertions(+), 148 deletions(-) > > > > diff --git a/fs/ramfs.c b/fs/ramfs.c > > index 2b6df07996..ebe03de736 100644 > > --- a/fs/ramfs.c > > +++ b/fs/ramfs.c > > @@ -23,12 +23,15 @@ > > #include <errno.h> > > #include <linux/stat.h> > > #include <xfuncs.h> > > +#include <linux/sizes.h> > > > > #define CHUNK_SIZE (4096 * 2) > > > > struct ramfs_chunk { > > char *data; > > - struct ramfs_chunk *next; > > + unsigned long ofs; > > + int size; > > + struct list_head list; > > }; > > > > struct ramfs_inode { > > @@ -37,12 +40,14 @@ struct ramfs_inode { > > char *symlink; > > ulong mode; > > > > - ulong size; > > - struct ramfs_chunk *data; > > + /* bytes used in this inode */ > > + unsigned long size; > > + /* bytes currently allocated for this inode */ > > + unsigned long alloc_size; > > + > > + struct list_head data; > > > > - /* Points to recently used chunk */ > > - int recent_chunk; > > - struct ramfs_chunk *recent_chunkp; > > + struct ramfs_chunk *current_chunk; > > }; > > > > static inline struct ramfs_inode *to_ramfs_inode(struct inode *inode) > > @@ -89,18 +94,25 @@ static struct inode *ramfs_get_inode(struct super_block > > *sb, const struct inode > > return inode; > > } > > > > -static struct ramfs_chunk *ramfs_get_chunk(void) > > +#define MIN_SIZE SZ_8K > > + > > +static struct ramfs_chunk *ramfs_get_chunk(unsigned long size) > > { > > struct ramfs_chunk *data = malloc(sizeof(struct ramfs_chunk)); > > + > > if (!data) > > return NULL; > > > > - data->data = calloc(CHUNK_SIZE, 1); > > + if (size < MIN_SIZE) > > + size = MIN_SIZE; > > + > > + data->data = calloc(size, 1); > > if (!data->data) { > > free(data); > > return NULL; > > } > > - data->next = NULL; > > + > > + data->size = size; > > > > return data; > > } > > @@ -160,23 +172,6 @@ static int ramfs_symlink(struct inode *dir, struct > > dentry *dentry, > > > > static int ramfs_unlink(struct inode *dir, struct dentry *dentry) > > { > > - struct inode *inode = d_inode(dentry); > > - > > - if (inode) { > > - struct ramfs_inode *node = to_ramfs_inode(inode); > > - struct ramfs_chunk *chunk = node->data; > > - > > - node->data = NULL; > > - > > - while (chunk) { > > - struct ramfs_chunk *tmp = chunk; > > - > > - chunk = chunk->next; > > - > > - ramfs_put_chunk(tmp); > > - } > > - } > > - > > return simple_unlink(dir, dentry); > > } > > > > @@ -200,80 +195,57 @@ static const struct inode_operations > > ramfs_dir_inode_operations = > > .create = ramfs_create, > > }; > > > > -static struct ramfs_chunk *ramfs_find_chunk(struct ramfs_inode *node, int > > chunk) > > +static struct ramfs_chunk *ramfs_find_chunk(struct ramfs_inode *node, > > + unsigned long pos, int *ofs, int > > *len) > > { > > - struct ramfs_chunk *data; > > - int left = chunk; > > + struct ramfs_chunk *data, *cur = node->current_chunk; > > > > - if (chunk == 0) > > - return node->data; > > + if (cur && pos >= cur->ofs) > > + data = cur; > > + else > > + data = list_first_entry(&node->data, struct ramfs_chunk, list); > > > > - if (node->recent_chunk == chunk) > > - return node->recent_chunkp; > > + list_for_each_entry_from(data, &node->data, list) { > > + if (data->ofs + data->size > pos) { > > + *ofs = pos - data->ofs; > > + *len = data->ofs + data->size - pos; > > > > - if (node->recent_chunk < chunk && node->recent_chunk != 0) { > > - /* Start at last known chunk */ > > - data = node->recent_chunkp; > > - left -= node->recent_chunk; > > - } else { > > - /* Start at first chunk */ > > - data = node->data; > > - } > > + node->current_chunk = data; > > > > - while (left--) > > - data = data->next; > > + return data; > > + } > > + } > > > > - node->recent_chunkp = data; > > - node->recent_chunk = chunk; > > + pr_err("%s: no chunk for pos %ld found\n", __func__, pos); > > > > - return data; > > + return NULL; > > } > > > > static int ramfs_read(struct device_d *_dev, FILE *f, void *buf, size_t > > insize) > > { > > struct inode *inode = f->f_inode; > > struct ramfs_inode *node = to_ramfs_inode(inode); > > - int chunk; > > struct ramfs_chunk *data; > > - int ofs; > > - int now; > > - int pos = f->pos; > > + int ofs, len, now; > > + unsigned long pos = f->pos; > > int size = insize; > > > > - chunk = pos / CHUNK_SIZE; > > - debug("%s: reading from chunk %d\n", __FUNCTION__, chunk); > > + debug("%s: %p %d @ %lld\n", __func__, node, insize, f->pos); > > + > > + while (size) { > > + data = ramfs_find_chunk(node, pos, &ofs, &len); > > + if (!data) > > + return -EINVAL; > > > > - /* Position ourself in stream */ > > - data = ramfs_find_chunk(node, chunk); > > - ofs = pos % CHUNK_SIZE; > > + debug("%s: pos: %ld ofs: %d len: %d\n", __func__, pos, ofs, > > len); > > + > > + now = min(size, len); > > > > - /* Read till end of current chunk */ > > - if (ofs) { > > - now = min(size, CHUNK_SIZE - ofs); > > - debug("Reading till end of node. size: %d\n", size); > > memcpy(buf, data->data + ofs, now); > > + > > size -= now; > > - pos += now; > > buf += now; > > - if (pos > node->size) > > - node->size = now; > > - data = data->next; > > - } > > - > > - /* Do full chunks */ > > - while (size >= CHUNK_SIZE) { > > - debug("do full chunk. size: %d\n", size); > > - memcpy(buf, data->data, CHUNK_SIZE); > > - data = data->next; > > - size -= CHUNK_SIZE; > > - pos += CHUNK_SIZE; > > - buf += CHUNK_SIZE; > > - } > > - > > - /* And the rest */ > > - if (size) { > > - debug("do rest. size: %d\n", size); > > - memcpy(buf, data->data, size); > > + pos += now; > > } > > > > return insize; > > @@ -283,100 +255,135 @@ static int ramfs_write(struct device_d *_dev, FILE > > *f, const void *buf, size_t i > > { > > struct inode *inode = f->f_inode; > > struct ramfs_inode *node = to_ramfs_inode(inode); > > - int chunk; > > struct ramfs_chunk *data; > > - int ofs; > > - int now; > > - int pos = f->pos; > > + int ofs, len, now; > > + unsigned long pos = f->pos; > > On 32-bit systems, you are truncating a 64-bit pos to 32-bit here. Is this > intended?
It's a RAM filesystem, so we can't handle files that are bigger than the address space here. Yes, this is intended, I wanted to avoid the burden of doing 64bit math on 32bit systems. Sascha -- Pengutronix e.K. | | Steuerwalder Str. 21 | http://www.pengutronix.de/ | 31137 Hildesheim, Germany | Phone: +49-5121-206917-0 | Amtsgericht Hildesheim, HRA 2686 | Fax: +49-5121-206917-5555 | _______________________________________________ barebox mailing list [email protected] http://lists.infradead.org/mailman/listinfo/barebox
