*
* \brief BattFS: a filesystem for embedded platforms (implementation).
*
- * \version $Id$
*
* \author Francesco Sacchi <batt@develer.com>
*
static void dumpPageArray(struct BattFsSuper *disk)
{
kprintf("Page array dump, free_page_start %d:", disk->free_page_start);
- for (pgcnt_t i = 0; i < disk->page_count; i++)
+ for (pgcnt_t i = 0; i < disk->dev->blk_cnt; i++)
{
if (!(i % 16))
kputchar('\n');
static void movePages(struct BattFsSuper *disk, pgcnt_t src, int offset)
{
pgcnt_t dst = src + offset;
- LOG_INFO("src %d, offset %d, size %d\n", src, offset, (unsigned int)((disk->page_count - MAX(dst, src)) * sizeof(pgcnt_t)));
- memmove(&disk->page_array[dst], &disk->page_array[src], (disk->page_count - MAX(dst, src)) * sizeof(pgcnt_t));
+ LOG_INFO("src %d, offset %d, size %d\n", src, offset, (unsigned int)((disk->dev->blk_cnt - MAX(dst, src)) * sizeof(pgcnt_t)));
+ memmove(&disk->page_array[dst], &disk->page_array[src], (disk->dev->blk_cnt - MAX(dst, src)) * sizeof(pgcnt_t));
if (offset < 0)
{
/* Fill empty space in array with sentinel */
- for (pgcnt_t page = disk->page_count + offset; page < disk->page_count; page++)
+ for (pgcnt_t page = disk->dev->blk_cnt + offset; page < disk->dev->blk_cnt; page++)
disk->page_array[page] = PAGE_UNSET_SENTINEL;
}
}
disk->free_page_start = 0;
/* Count the number of disk page per file */
- for (pgcnt_t page = 0; page < disk->page_count; page++)
+ for (pgcnt_t page = 0; page < disk->dev->blk_cnt; page++)
{
if (!readHdr(disk, page, &hdr))
return false;
BattFsPageHeader hdr;
pgcnt_t curr_free_page = disk->free_page_start;
/* Fill page allocation array */
- for (pgcnt_t page = 0; page < disk->page_count; page++)
+ for (pgcnt_t page = 0; page < disk->dev->blk_cnt; page++)
{
if (!readHdr(disk, page, &hdr))
return false;
pgoff_t filelen_table[BATTFS_MAX_FILES];
ASSERT(dev);
+ ASSERT(kblock_partialWrite(dev));
disk->dev = dev;
- disk->page_size = dev->blk_size;
- disk->page_count = dev->blk_cnt;
- ASSERT(disk->page_size > BATTFS_HEADER_LEN);
+ ASSERT(disk->dev->blk_size > BATTFS_HEADER_LEN);
/* Fill page_size with the usable space */
- disk->data_size = disk->page_size - BATTFS_HEADER_LEN;
- ASSERT(disk->page_count);
- ASSERT(disk->page_count < PAGE_UNSET_SENTINEL - 1);
+ disk->data_size = disk->dev->blk_size - BATTFS_HEADER_LEN;
+ ASSERT(disk->dev->blk_cnt);
+ ASSERT(disk->dev->blk_cnt < PAGE_UNSET_SENTINEL - 1);
ASSERT(page_array);
disk->page_array = page_array;
- ASSERT(array_size >= disk->page_count * sizeof(pgcnt_t));
+ ASSERT(array_size >= disk->dev->blk_cnt * sizeof(pgcnt_t));
memset(filelen_table, 0, BATTFS_MAX_FILES * sizeof(pgoff_t));
disk->free_bytes = 0;
- disk->disk_size = (disk_size_t)disk->data_size * disk->page_count;
+ disk->disk_size = (disk_size_t)disk->data_size * disk->dev->blk_cnt;
/* Count pages per file */
if (!countDiskFilePages(disk, filelen_table))
/* Once here, we have filelen_table filled with file lengths */
/* Fill page array with sentinel */
- for (pgcnt_t page = 0; page < disk->page_count; page++)
+ for (pgcnt_t page = 0; page < disk->dev->blk_cnt; page++)
disk->page_array[page] = PAGE_UNSET_SENTINEL;
/* Fill page allocation array using filelen_table */
dumpPageArray(disk);
#endif
#if CONFIG_BATTFS_SHUFFLE_FREE_PAGES
- SHUFFLE(&disk->page_array[disk->free_page_start], disk->page_count - disk->free_page_start);
+ SHUFFLE(&disk->page_array[disk->free_page_start], disk->dev->blk_cnt - disk->free_page_start);
LOG_INFO("Page array after shuffle:\n");
#if LOG_LEVEL >= LOG_LVL_INFO
{
#define FSCHECK(cond) do { if(!(cond)) { LOG_ERR("\"" #cond "\"\n"); return false; } } while (0)
- FSCHECK(disk->free_page_start <= disk->page_count);
- FSCHECK(disk->data_size < disk->page_size);
+ FSCHECK(disk->free_page_start <= disk->dev->blk_cnt);
+ FSCHECK(disk->data_size < disk->dev->blk_size);
FSCHECK(disk->free_bytes <= disk->disk_size);
disk_size_t free_bytes = 0;
/* Uneeded, the first time will be overwritten but useful to silence
* the warning for uninitialized value */
FSCHECK(readHdr(disk, 0, &prev_hdr));
- for (pgcnt_t page = 0; page < disk->page_count; page++)
+ for (pgcnt_t page = 0; page < disk->dev->blk_cnt; page++)
{
FSCHECK(readHdr(disk, disk->page_array[page], &hdr));
free_bytes += disk->data_size;
if (SPACE_OVER(disk))
{
LOG_ERR("No disk space available!\n");
- return PAGE_UNSET_SENTINEL;
+ return NO_SPACE;
}
/* Get a free page */
/* Insert previous page in free blocks list */
LOG_INFO("Setting page %d as free\n", old_pos);
- disk->page_array[disk->page_count - 1] = old_pos;
+ disk->page_array[disk->dev->blk_cnt - 1] = old_pos;
return new_page;
}
return total_write;
}
- new_page = renewPage(disk, fdb->start[fdb->max_off]);
- if (new_page == NO_SPACE)
+ /*
+ * Renew page only if is not in cache.
+ * This avoids rewriting the same page continuously
+ * if the user code keeps writing in the same portion
+ * of the file.
+ */
+ if (kblock_buffered(disk->dev)
+ && ((fdb->start[fdb->max_off] != kblock_cachedBlock(disk->dev)) || !kblock_cacheDirty(disk->dev)))
{
- fdb->errors |= BATTFS_DISK_SPACEOVER_ERR;
- return total_write;
- }
+ new_page = renewPage(disk, fdb->start[fdb->max_off]);
+ if (new_page == NO_SPACE)
+ {
+ fdb->errors |= BATTFS_DISK_SPACEOVER_ERR;
+ return total_write;
+ }
- kblock_copy(disk->dev, fdb->start[fdb->max_off], new_page);
- fdb->start[fdb->max_off] = new_page;
+ kblock_copy(disk->dev, fdb->start[fdb->max_off], new_page);
+ fdb->start[fdb->max_off] = new_page;
+ }
+ else
+ new_page = fdb->start[fdb->max_off];
/* Fill unused space of first page with 0s */
uint8_t dummy = 0;
+ // TODO: write in blocks to speed up things
pgaddr_t zero_bytes = MIN(fd->seek_pos - fd->size, (kfile_off_t)(disk->data_size - curr_hdr.fill));
while (zero_bytes--)
{
/* Allocate the missing pages first. */
pgoff_t missing_pages = fd->seek_pos / disk->data_size - fdb->max_off;
- if (missing_pages)
+ LOG_INFO("missing pages: %d\n", missing_pages);
+
+ while (missing_pages--)
{
- LOG_INFO("missing pages: %d\n", missing_pages);
+ zero_bytes = MIN((kfile_off_t)disk->data_size, fd->seek_pos - fd->size);
- while (missing_pages--)
+ new_page = allocateNewPage(disk, (fdb->start - disk->page_array) + fdb->max_off + 1, fdb->inode);
+ if (new_page == NO_SPACE)
{
- zero_bytes = MIN((kfile_off_t)disk->data_size, fd->seek_pos - fd->size);
-
- new_page = allocateNewPage(disk, (fdb->start - disk->page_array) + fdb->max_off + 1, fdb->inode);
- if (new_page == NO_SPACE)
- {
- fdb->errors |= BATTFS_DISK_SPACEOVER_ERR;
- return total_write;
- }
-
+ fdb->errors |= BATTFS_DISK_SPACEOVER_ERR;
+ return total_write;
+ }
- /* Fill page buffer with 0 to avoid filling unused pages with garbage */
- for (pgaddr_t off = 0; off < disk->data_size; off++)
- {
- if (kblock_write(disk->dev, new_page, &dummy, off, 1) != 1)
- {
- fdb->errors |= BATTFS_DISK_WRITE_ERR;
- return total_write;
- }
- }
- curr_hdr.inode = fdb->inode;
- curr_hdr.pgoff = ++fdb->max_off;
- curr_hdr.fill = zero_bytes;
- curr_hdr.seq = 0;
- if (!writeHdr(disk, new_page, &curr_hdr))
+ // TODO: write in blocks to speed up things
+ /* Fill page buffer with 0 to avoid filling unused pages with garbage */
+ for (pgaddr_t off = 0; off < disk->data_size; off++)
+ {
+ if (kblock_write(disk->dev, new_page, &dummy, off, 1) != 1)
{
fdb->errors |= BATTFS_DISK_WRITE_ERR;
return total_write;
}
+ }
+ curr_hdr.inode = fdb->inode;
+ curr_hdr.pgoff = ++fdb->max_off;
+ curr_hdr.fill = zero_bytes;
+ curr_hdr.seq = 0;
- /* Update size and free space left */
- fd->size += zero_bytes;
- disk->free_bytes -= zero_bytes;
+ if (!writeHdr(disk, new_page, &curr_hdr))
+ {
+ fdb->errors |= BATTFS_DISK_WRITE_ERR;
+ return total_write;
}
+
+ /* Update size and free space left */
+ fd->size += zero_bytes;
+ disk->free_bytes -= zero_bytes;
}
}
return total_write;
}
- new_page = renewPage(disk, fdb->start[pg_offset]);
- if (new_page == NO_SPACE)
+ /* Renew page only if is not in cache. */
+ if (kblock_buffered(disk->dev)
+ && ((fdb->start[fdb->max_off] != kblock_cachedBlock(disk->dev)) || !kblock_cacheDirty(disk->dev)))
{
- fdb->errors |= BATTFS_DISK_SPACEOVER_ERR;
- return total_write;
- }
+ new_page = renewPage(disk, fdb->start[pg_offset]);
+ if (new_page == NO_SPACE)
+ {
+ fdb->errors |= BATTFS_DISK_SPACEOVER_ERR;
+ return total_write;
+ }
- LOG_INFO("Re-writing page %d to %d\n", fdb->start[pg_offset], new_page);
- if (kblock_copy(disk->dev, fdb->start[pg_offset], new_page) != 0)
+ LOG_INFO("Re-writing page %d to %d\n", fdb->start[pg_offset], new_page);
+ if (kblock_copy(disk->dev, fdb->start[pg_offset], new_page) != 0)
+ {
+ fdb->errors |= BATTFS_DISK_WRITE_ERR;
+ return total_write;
+ }
+ fdb->start[pg_offset] = new_page;
+ }
+ else
{
- fdb->errors |= BATTFS_DISK_WRITE_ERR;
- return total_write;
+ LOG_INFO("Using cached block %d\n", fdb->start[pg_offset]);
+ new_page = fdb->start[pg_offset];
}
- fdb->start[pg_offset] = new_page;
+
curr_hdr.seq++;
}
//LOG_INFO("writing to buffer for page %d, offset %d, size %d\n", disk->curr_page, addr_offset, wr_len);
projects / bertos.git / blobdiff