TBM
/
tbm-mcu
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

mufs: clean up code by embedding struct mufs into struct mufs_tree

Browse Source
tags/0.1.0
S.J.R. van Schaik 8 years ago
parent 7212269675
commit 99e2229bbb
3 changed files with 70 additions and 48 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 14
      include/fs/mufs.h
  2. 88
      source/fs/mufs/tree.c
  3. 16
      source/fs/mufs/tree.h

14
include/fs/mufs.h
Unescape View File

@ -1,8 +1,11 @@
#pragma once #pragma once
struct flash_dev; struct flash_dev;
struct mufs;
struct mufs_dir;
struct mufs_tree { struct mufs_tree {
struct mufs *fs;
uint32_t file_size; uint32_t file_size;
uint32_t root; uint32_t root;
uint8_t depth; uint8_t depth;
@ -15,5 +18,16 @@ struct mufs {
uint8_t log2_nentries; uint8_t log2_nentries;
}; };
struct mufs_dirent {
char path[256];
struct mufs_tree tree;
uint8_t type;
};
int mufs_mount(struct mufs *fs, struct flash_dev *dev); int mufs_mount(struct mufs *fs, struct flash_dev *dev);
int mufs_format(struct flash_dev *dev); int mufs_format(struct flash_dev *dev);
struct mufs_dir *mufs_opendir(struct mufs *fs, const char *path);
void mufs_closedir(struct mufs_dir *dir);
int mufs_readdir(struct mufs_dir *dir, struct mufs_dirent *dirent);
int mufs_mkdir(struct mufs *fs, const char *path);

88
source/fs/mufs/tree.c
Unescape View File

@ -14,7 +14,8 @@
static int mufs_do_lookup(struct mufs *fs, uint32_t *page, static int mufs_do_lookup(struct mufs *fs, uint32_t *page,
uint32_t base, uint8_t depth, uint32_t va, unsigned alloc) uint32_t base, uint8_t depth, uint32_t va, unsigned alloc)
{ {
char data[1 << fs->dev->log2_block_size]; struct flash_dev *dev = fs->dev;
char data[1 << dev->log2_block_size];
uint32_t *table = (uint32_t *)data; uint32_t *table = (uint32_t *)data;
size_t index; size_t index;
@ -26,7 +27,7 @@ static int mufs_do_lookup(struct mufs *fs, uint32_t *page,
return 0; return 0;
} }
if (flash_read(fs->dev, base << fs->dev->log2_block_size, data, if (flash_read(dev, base << dev->log2_block_size, data,
sizeof data) == 0) sizeof data) == 0)
return -1; return -1;
@ -36,7 +37,7 @@ static int mufs_do_lookup(struct mufs *fs, uint32_t *page,
if (!alloc || mufs_alloc_block(fs, &table[index]) < 0) if (!alloc || mufs_alloc_block(fs, &table[index]) < 0)
return -1; return -1;
if (flash_write(fs->dev, base << fs->dev->log2_block_size, data, if (flash_write(dev, base << dev->log2_block_size, data,
sizeof data) == 0) sizeof data) == 0)
return -1; return -1;
} }
@ -44,15 +45,17 @@ static int mufs_do_lookup(struct mufs *fs, uint32_t *page,
return mufs_do_lookup(fs, page, table[index], depth - 1, va, alloc); return mufs_do_lookup(fs, page, table[index], depth - 1, va, alloc);
} }
int mufs_lookup_page(struct mufs *fs, struct mufs_tree *tree, uint32_t *page, int mufs_lookup_page(struct mufs_tree *tree, uint32_t *page,
uint32_t va) uint32_t va)
{ {
return mufs_do_lookup(fs, page, tree->root, tree->depth, va, 0); return mufs_do_lookup(tree->fs, page, tree->root, tree->depth, va, 0);
} }
int mufs_alloc_page(struct mufs *fs, struct mufs_tree *tree, uint32_t *page, int mufs_alloc_page(struct mufs_tree *tree, uint32_t *page,
uint32_t va) uint32_t va)
{ {
struct mufs *fs = tree->fs;
if (!tree->root && mufs_alloc_block(fs, &tree->root) < 0) if (!tree->root && mufs_alloc_block(fs, &tree->root) < 0)
return -1; return -1;
@ -62,6 +65,7 @@ int mufs_alloc_page(struct mufs *fs, struct mufs_tree *tree, uint32_t *page,
static int mufs_do_free_page(struct mufs *fs, uint32_t base, static int mufs_do_free_page(struct mufs *fs, uint32_t base,
uint8_t depth, uint32_t va) uint8_t depth, uint32_t va)
{ {
struct flash_dev *dev = fs->dev;
char data[1 << fs->dev->log2_block_size]; char data[1 << fs->dev->log2_block_size];
uint32_t *table = (uint32_t *)data; uint32_t *table = (uint32_t *)data;
size_t index; size_t index;
@ -74,7 +78,7 @@ static int mufs_do_free_page(struct mufs *fs, uint32_t base,
return 0; return 0;
} }
if (flash_read(fs->dev, base << fs->dev->log2_block_size, data, if (flash_read(fs->dev, base << dev->log2_block_size, data,
sizeof data) == 0) sizeof data) == 0)
return -1; return -1;
@ -89,7 +93,7 @@ static int mufs_do_free_page(struct mufs *fs, uint32_t base,
if (!table[index]) if (!table[index])
continue; continue;
if (flash_write(fs->dev, base << fs->dev->log2_block_size, data, if (flash_write(dev, base << dev->log2_block_size, data,
sizeof data) == 0) sizeof data) == 0)
return -1; return -1;
@ -99,13 +103,15 @@ static int mufs_do_free_page(struct mufs *fs, uint32_t base,
return mufs_free_block(fs, base); return mufs_free_block(fs, base);
} }
void mufs_free_page(struct mufs *fs, struct mufs_tree *tree, uint32_t va) void mufs_free_page(struct mufs_tree *tree, uint32_t va)
{ {
mufs_do_free_page(fs, tree->root, tree->depth, va); mufs_do_free_page(tree->fs, tree->root, tree->depth, va);
} }
int mufs_extend_tree(struct mufs *fs, struct mufs_tree *tree, uint8_t depth) int mufs_extend_tree(struct mufs_tree *tree, uint8_t depth)
{ {
struct mufs *fs = tree->fs;
struct flash_dev *dev = fs->dev;
uint32_t root; uint32_t root;
for (; tree->depth <= depth; ++tree->depth) { for (; tree->depth <= depth; ++tree->depth) {
@ -115,7 +121,7 @@ int mufs_extend_tree(struct mufs *fs, struct mufs_tree *tree, uint8_t depth)
if (!root) if (!root)
continue; continue;
if (flash_write(fs->dev, root << fs->dev->log2_block_size, &tree->root, if (flash_write(dev, root << dev->log2_block_size, &tree->root,
sizeof tree->root) == 0) { sizeof tree->root) == 0) {
mufs_free_block(fs, root); mufs_free_block(fs, root);
return -1; return -1;
@ -127,9 +133,11 @@ int mufs_extend_tree(struct mufs *fs, struct mufs_tree *tree, uint8_t depth)
return 0; return 0;
} }
int mufs_shrink_tree(struct mufs *fs, struct mufs_tree *tree, uint32_t max_size) int mufs_shrink_tree(struct mufs_tree *tree, uint32_t max_size)
{ {
char data[1 << fs->dev->log2_block_size]; struct mufs *fs = tree->fs;
struct flash_dev *dev = fs->dev;
char data[1 << dev->log2_block_size];
uint32_t *table = (uint32_t *)data; uint32_t *table = (uint32_t *)data;
size_t index; size_t index;
uint32_t base, size; uint32_t base, size;
@ -138,15 +146,15 @@ int mufs_shrink_tree(struct mufs *fs, struct mufs_tree *tree, uint32_t max_size)
base = tree->root; base = tree->root;
for (depth = tree->depth; depth; --depth) { for (depth = tree->depth; depth; --depth) {
size = 1 << (depth * fs->log2_nentries + fs->dev->log2_block_size); size = 1 << (depth * fs->log2_nentries + dev->log2_block_size);
if (size < max_size) if (size < max_size)
return 0; return 0;
index = max_size >> ((depth - 1) * fs->log2_nentries + index = max_size >> ((depth - 1) * fs->log2_nentries +
fs->dev->log2_block_size); dev->log2_block_size);
if (flash_read(fs->dev, base, data, sizeof data) == 0) if (flash_read(dev, base, data, sizeof data) == 0)
return -1; return -1;
if (index <= 1) { if (index <= 1) {
@ -162,7 +170,7 @@ int mufs_shrink_tree(struct mufs *fs, struct mufs_tree *tree, uint32_t max_size)
table[index] = 0; table[index] = 0;
} }
if (flash_write(fs->dev, base << fs->dev->log2_block_size, data, if (flash_write(dev, base << dev->log2_block_size, data,
sizeof data) == 0) sizeof data) == 0)
return -1; return -1;
} }
@ -170,32 +178,32 @@ int mufs_shrink_tree(struct mufs *fs, struct mufs_tree *tree, uint32_t max_size)
return 0; return 0;
} }
static size_t mufs_do_read(struct mufs *fs, struct mufs_tree *tree, static size_t mufs_do_read(struct mufs_tree *tree, void *data, uint32_t va,
void *data, uint32_t va, size_t len) size_t len)
{ {
struct mufs *fs = tree->fs;
struct flash_dev *dev = fs->dev;
uint32_t page, offset; uint32_t page, offset;
offset = va & ((UINT32_C(1) << fs->dev->log2_block_size) - 1); offset = va & ((UINT32_C(1) << dev->log2_block_size) - 1);
va = align(va, fs->dev->log2_block_size); va = align(va, dev->log2_block_size);
memset(data, 0, len); memset(data, 0, len);
len = min(len, (UINT32_C(1) << fs->dev->log2_block_size) - offset); len = min(len, (UINT32_C(1) << dev->log2_block_size) - offset);
if (mufs_lookup_page(fs, tree, &page, va) < 0) if (mufs_lookup_page(tree, &page, va) < 0)
return 0; return 0;
return flash_read(fs->dev, (page << fs->dev->log2_block_size) + offset, return flash_read(dev, (page << dev->log2_block_size) + offset, data, len);
data, len);
} }
size_t mufs_read(struct mufs *fs, struct mufs_tree *tree, void *data, size_t mufs_read(struct mufs_tree *tree, void *data, uint32_t va, size_t len)
uint32_t va, size_t len)
{ {
uint8_t *buf = data; uint8_t *buf = data;
size_t ret, nbytes = 0; size_t ret, nbytes = 0;
while (len) { while (len) {
if ((ret = mufs_do_read(fs, tree, buf, va, len)) == 0) if ((ret = mufs_do_read(tree, buf, va, len)) == 0)
return nbytes; return nbytes;
buf += ret; buf += ret;
@ -207,33 +215,35 @@ size_t mufs_read(struct mufs *fs, struct mufs_tree *tree, void *data,
return nbytes; return nbytes;
} }
static size_t mufs_do_write(struct mufs *fs, struct mufs_tree *tree, static size_t mufs_do_write(struct mufs_tree *tree,
void *data, uint32_t va, size_t len) void *data, uint32_t va, size_t len)
{ {
struct mufs *fs = tree->fs;
struct flash_dev *dev = fs->dev;
uint32_t page, offset; uint32_t page, offset;
offset = va & ((UINT32_C(1) << fs->dev->log2_block_size) - 1); offset = va & ((UINT32_C(1) << dev->log2_block_size) - 1);
va = align(va, fs->dev->log2_block_size); va = align(va, dev->log2_block_size);
len = min(len, (UINT32_C(1) << fs->dev->log2_block_size) - offset); len = min(len, (UINT32_C(1) << dev->log2_block_size) - offset);
if (mufs_extend_tree(fs, tree, 1) < 0) if (mufs_extend_tree(tree, 1) < 0)
return 0; return 0;
if (mufs_alloc_page(fs, tree, &page, va) < 0) if (mufs_alloc_page(tree, &page, va) < 0)
return 0; return 0;
return flash_write(fs->dev, (page << fs->dev->log2_block_size) + offset, return flash_write(dev, (page << dev->log2_block_size) + offset, data,
data, len); len);
} }
size_t mufs_write(struct mufs *fs, struct mufs_tree *tree, void *data, size_t mufs_write(struct mufs_tree *tree, void *data,
uint32_t va, size_t len) uint32_t va, size_t len)
{ {
uint8_t *buf = data; uint8_t *buf = data;
size_t ret, nbytes = 0; size_t ret, nbytes = 0;
while (len) { while (len) {
if ((ret = mufs_do_write(fs, tree, buf, va, len)) == 0) if ((ret = mufs_do_write(tree, buf, va, len)) == 0)
return nbytes; return nbytes;
buf += ret; buf += ret;

16
source/fs/mufs/tree.h
Unescape View File

@ -1,13 +1,11 @@
#pragma once #pragma once
int mufs_lookup_page(struct mufs *fs, struct mufs_tree *tree, uint32_t *page, int mufs_lookup_page(struct mufs_tree *tree, uint32_t *page,
uint32_t va); uint32_t va);
int mufs_alloc_page(struct mufs *fs, struct mufs_tree *tree, uint32_t *page, int mufs_alloc_page(struct mufs_tree *tree, uint32_t *page,
uint32_t va); uint32_t va);
void mufs_free_page(struct mufs *fs, struct mufs_tree *tree, uint32_t va); void mufs_free_page(struct mufs_tree *tree, uint32_t va);
int mufs_extend_tree(struct mufs *fs, struct mufs_tree *tree, uint8_t depth); int mufs_extend_tree(struct mufs_tree *tree, uint8_t depth);
int mufs_shrink_tree(struct mufs *fs, struct mufs_tree *tree, uint32_t max_size); int mufs_shrink_tree(struct mufs_tree *tree, uint32_t max_size);
size_t mufs_read(struct mufs *fs, struct mufs_tree *tree, void *data, size_t mufs_read(struct mufs_tree *tree, void *data, uint32_t va, size_t len);
uint32_t va, size_t len); size_t mufs_write(struct mufs_tree *tree, void *data, uint32_t va, size_t len);
size_t mufs_write(struct mufs *fs, struct mufs_tree *tree, void *data,
uint32_t va, size_t len);

Write Preview
Loading…
Cancel
Save