X-Git-Url: https://codewiz.org/gitweb?a=blobdiff_plain;f=bertos%2Ffs%2Fbattfs.c;h=ae3cde9ed7940e361a4942bd53548852225e2b66;hb=ebd302f4820855188df16ee8422a947751bf2c50;hp=119085907637112386c7ef5094722166e981e127;hpb=133c08ba914cdfe533693a1633fe4377b6e255f9;p=bertos.git diff --git a/bertos/fs/battfs.c b/bertos/fs/battfs.c index 11908590..ae3cde9e 100644 --- a/bertos/fs/battfs.c +++ b/bertos/fs/battfs.c @@ -155,7 +155,7 @@ static bool readHdr(struct BattFsSuper *disk, pgcnt_t page, struct BattFsPageHea * Header is actually a footer, and so * resides at page end. */ - if (diskRead(disk, page, disk->page_size - BATTFS_HEADER_LEN, buf, BATTFS_HEADER_LEN) + if (diskRead(disk, page, disk->data_size, buf, BATTFS_HEADER_LEN) != BATTFS_HEADER_LEN) { LOG_ERR("page[%d]\n", page); @@ -186,7 +186,7 @@ static bool setBufferHdr(struct BattFsSuper *disk, struct BattFsPageHeader *hdr) * Header is actually a footer, and so * resides at page end. */ - if (disk->bufferWrite(disk, disk->page_size - BATTFS_HEADER_LEN, buf, BATTFS_HEADER_LEN) + if (disk->bufferWrite(disk, disk->data_size, buf, BATTFS_HEADER_LEN) != BATTFS_HEADER_LEN) { LOG_ERR("writing to buffer\n"); @@ -199,7 +199,7 @@ static bool getBufferHdr(struct BattFsSuper *disk, struct BattFsPageHeader *hdr) { uint8_t buf[BATTFS_HEADER_LEN]; - if (disk->bufferRead(disk, disk->page_size - BATTFS_HEADER_LEN, buf, BATTFS_HEADER_LEN) + if (disk->bufferRead(disk, disk->data_size, buf, BATTFS_HEADER_LEN) != BATTFS_HEADER_LEN) { LOG_ERR("reading from buffer\n"); @@ -232,7 +232,7 @@ static pgcnt_t countPages(pgoff_t *filelen_table, inode_t inode) static void movePages(struct BattFsSuper *disk, pgcnt_t src, int offset) { pgcnt_t dst = src + offset; - LOG_INFO("src %d, offset %d, size %ld\n", src, offset, (disk->page_count - MAX(dst, src)) * sizeof(pgcnt_t)); + 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)); if (offset < 0) @@ -264,12 +264,12 @@ static bool countDiskFilePages(struct BattFsSuper *disk, pgoff_t *filelen_table) return false; /* Increase free space */ - disk->free_bytes += disk->page_size - BATTFS_HEADER_LEN; + disk->free_bytes += disk->data_size; /* Check header FCS */ if (hdr.fcs == computeFcs(&hdr)) { - ASSERT(hdr.fill <= disk->page_size - BATTFS_HEADER_LEN); + ASSERT(hdr.fill <= disk->data_size); /* Page is valid and is owned by a file */ filelen_table[hdr.inode]++; @@ -418,7 +418,7 @@ static bool flushBuffer(struct BattFsSuper *disk) static bool loadPage(struct BattFsSuper *disk, pgcnt_t new_page, BattFsPageHeader *new_hdr) { if (disk->curr_page == new_page) - return true; + return getBufferHdr(disk, new_hdr); LOG_INFO("Loading page %d\n", new_page); @@ -438,7 +438,7 @@ static bool loadPage(struct BattFsSuper *disk, pgcnt_t new_page, BattFsPageHeade * \a disk. * \return false on errors, true otherwise. */ -bool battfs_init(struct BattFsSuper *disk) +bool battfs_mount(struct BattFsSuper *disk) { pgoff_t filelen_table[BATTFS_MAX_FILES]; @@ -460,7 +460,9 @@ bool battfs_init(struct BattFsSuper *disk) ASSERT(disk->save); ASSERT(disk->erase); ASSERT(disk->close); - ASSERT(disk->page_size); + ASSERT(disk->page_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); ASSERT(disk->page_array); @@ -468,7 +470,7 @@ bool battfs_init(struct BattFsSuper *disk) memset(filelen_table, 0, BATTFS_MAX_FILES * sizeof(pgoff_t)); disk->free_bytes = 0; - disk->disk_size = (disk_size_t)(disk->page_size - BATTFS_HEADER_LEN) * disk->page_count; + disk->disk_size = (disk_size_t)disk->data_size * disk->page_count; /* Initialize page buffer cache */ disk->cache_dirty = false; @@ -494,18 +496,73 @@ bool battfs_init(struct BattFsSuper *disk) LOG_ERR("filling page array\n"); return false; } - #if LOG_LEVEL > LOG_LVL_INFO - dumpPageArray(disk) + #if LOG_LEVEL >= LOG_LVL_INFO + dumpPageArray(disk); #endif #warning TODO: shuffle free blocks //#if LOG_LEVEL > LOG_LVL_INFO - // dumpPageArray(disk) + // dumpPageArray(disk); //#endif /* Init list for opened files. */ LIST_INIT(&disk->file_opened_list); return true; } +/** + * Check the filesystem. + * \return true if ok, false on errors. + */ +bool battfs_fsck(struct BattFsSuper *disk) +{ + #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_bytes <= disk->disk_size); + + disk_size_t free_bytes = 0; + BattFsPageHeader hdr, prev_hdr; + inode_t files = 0; + pgcnt_t page_used = 0; + + bool start = true; + + for (pgcnt_t page = 0; page < disk->page_count; page++) + { + FSCHECK(readHdr(disk, disk->page_array[page], &hdr)); + free_bytes += disk->data_size; + + if (page < disk->free_page_start) + { + FSCHECK(computeFcs(&hdr) == hdr.fcs); + page_used++; + free_bytes -= hdr.fill; + if (hdr.inode != prev_hdr.inode || start) + { + if (LIKELY(!start)) + FSCHECK(hdr.inode > prev_hdr.inode); + else + start = false; + + FSCHECK(hdr.pgoff == 0); + files++; + } + else + { + FSCHECK(hdr.fill != 0); + FSCHECK(prev_hdr.fill == disk->data_size); + FSCHECK(hdr.pgoff == prev_hdr.pgoff + 1); + } + prev_hdr = hdr; + } + } + + FSCHECK(page_used == disk->free_page_start); + FSCHECK(free_bytes == disk->free_bytes); + + return true; +} + /** * Flush file \a fd. * \return 0 if ok, EOF on errors. @@ -536,10 +593,10 @@ static int battfs_fileclose(struct KFile *fd) static bool getNewPage(struct BattFsSuper *disk, pgcnt_t new_pos, inode_t inode, pgoff_t pgoff, BattFsPageHeader *new_hdr) { - if (disk->free_page_start >= disk->page_count) + if (SPACE_OVER(disk)) { #warning TODO space over! - LOG_INFO("No disk space available\n"); + LOG_ERR("No disk space available!\n"); return false; } flushBuffer(disk); @@ -563,7 +620,7 @@ static bool getNewPage(struct BattFsSuper *disk, pgcnt_t new_pos, inode_t inode, disk->cache_dirty = true; new_hdr->inode = inode; - new_hdr->pgoff = pgoff; + new_hdr->pgoff = pgoff; new_hdr->fill = 0; new_hdr->seq = 0; return setBufferHdr(disk, new_hdr); @@ -576,76 +633,142 @@ static bool getNewPage(struct BattFsSuper *disk, pgcnt_t new_pos, inode_t inode, static size_t battfs_write(struct KFile *fd, const void *_buf, size_t size) { BattFs *fdb = BATTFS_CAST(fd); + BattFsSuper *disk = fdb->disk; const uint8_t *buf = (const uint8_t *)_buf; size_t total_write = 0; pgoff_t pg_offset; pgaddr_t addr_offset; pgaddr_t wr_len; - BattFsPageHeader curr_hdr; - if (!getBufferHdr(fdb->disk, &curr_hdr)) + + if (fd->seek_pos < 0) return total_write; - #warning TODO seek_pos > size? + if (fd->seek_pos > fd->size) + { + /* Handle writing when seek pos if far over EOF */ + if (!loadPage(disk, fdb->start[fdb->max_off], &curr_hdr)) + { + #warning TODO set error? + return total_write; + } + + /* Fill unused space of first page with 0s */ + uint8_t dummy = 0; + pgaddr_t zero_bytes = MIN(fd->seek_pos - fd->size, disk->data_size - curr_hdr.fill); + while (zero_bytes--) + { + if (disk->bufferWrite(disk, curr_hdr.fill, &dummy, 1) != 1) + { + #warning TODO set error? + } + curr_hdr.fill++; + fd->size++; + disk->free_bytes--; + disk->cache_dirty = true; + } + setBufferHdr(disk, &curr_hdr); + + /* 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); + flushBuffer(disk); + + /* Fill page buffer with 0 to avoid filling unused pages with garbage */ + for (pgaddr_t off = 0; off < disk->data_size; off++) + { + if (disk->bufferWrite(disk, off, &dummy, 1) != 1) + { + #warning TODO set error? + } + } + + while (missing_pages--) + { + zero_bytes = MIN((kfile_off_t)disk->data_size, fd->seek_pos - fd->size); + /* Get the new page needed */ + if (!getNewPage(disk, (fdb->start - disk->page_array) + fdb->max_off + 1, fdb->inode, fdb->max_off + 1, &curr_hdr)) + return total_write; + + /* Update size and free space left */ + fd->size += zero_bytes; + disk->free_bytes -= zero_bytes; + + curr_hdr.fill = zero_bytes; + setBufferHdr(disk, &curr_hdr); + + fdb->max_off++; + } + } + } + else if (!getBufferHdr(disk, &curr_hdr)) + return total_write; while (size) { - pg_offset = fd->seek_pos / (fdb->disk->page_size - BATTFS_HEADER_LEN); - addr_offset = fd->seek_pos % (fdb->disk->page_size - BATTFS_HEADER_LEN); - wr_len = MIN(size, (size_t)(fdb->disk->page_size - BATTFS_HEADER_LEN - addr_offset)); + pg_offset = fd->seek_pos / disk->data_size; + addr_offset = fd->seek_pos % disk->data_size; + wr_len = MIN(size, (size_t)(disk->data_size - addr_offset)); /* Handle write outside EOF */ if (pg_offset > fdb->max_off) { - LOG_INFO("New page needed, pg_offset %d, pos %d\n", pg_offset, (fdb->start - fdb->disk->page_array) + pg_offset); - if (!getNewPage(fdb->disk, (fdb->start - fdb->disk->page_array) + pg_offset, fdb->inode, pg_offset, &curr_hdr)) + LOG_INFO("New page needed, pg_offset %d, pos %d\n", pg_offset, (int)((fdb->start - disk->page_array) + pg_offset)); + if (!getNewPage(disk, (fdb->start - disk->page_array) + pg_offset, fdb->inode, pg_offset, &curr_hdr)) return total_write; fdb->max_off = pg_offset; } /* Handle cache load of a new page*/ - else if (fdb->start[pg_offset] != fdb->disk->curr_page) + else if (fdb->start[pg_offset] != disk->curr_page) { - LOG_INFO("Re-writing page %d to %d\n", fdb->start[pg_offset], fdb->disk->page_array[fdb->disk->free_page_start]); - if (!loadPage(fdb->disk, fdb->start[pg_offset], &curr_hdr)) + if (SPACE_OVER(disk)) + { + LOG_ERR("No disk space available!\n"); + return total_write; + } + LOG_INFO("Re-writing page %d to %d\n", fdb->start[pg_offset], disk->page_array[disk->free_page_start]); + if (!loadPage(disk, fdb->start[pg_offset], &curr_hdr)) { #warning TODO set error? return total_write; } /* Get a free page */ - fdb->disk->curr_page = fdb->disk->page_array[fdb->disk->free_page_start]; - movePages(fdb->disk, fdb->disk->free_page_start + 1, -1); + disk->curr_page = disk->page_array[disk->free_page_start]; + movePages(disk, disk->free_page_start + 1, -1); /* Insert previous page in free blocks list */ LOG_INFO("Setting page %d as free\n", fdb->start[pg_offset]); - fdb->disk->page_array[fdb->disk->page_count - 1] = fdb->start[pg_offset]; + disk->page_array[disk->page_count - 1] = fdb->start[pg_offset]; /* Assign new page */ - fdb->start[pg_offset] = fdb->disk->curr_page; + fdb->start[pg_offset] = disk->curr_page; curr_hdr.seq++; } - - //LOG_INFO("writing to buffer for page %d, offset %d, size %d\n", fdb->disk->curr_page, addr_offset, wr_len); - if (fdb->disk->bufferWrite(fdb->disk, addr_offset, buf, wr_len) != wr_len) + //LOG_INFO("writing to buffer for page %d, offset %d, size %d\n", disk->curr_page, addr_offset, wr_len); + if (disk->bufferWrite(disk, addr_offset, buf, wr_len) != wr_len) { #warning TODO set error? } - fdb->disk->cache_dirty = true; + disk->cache_dirty = true; size -= wr_len; fd->seek_pos += wr_len; total_write += wr_len; buf += wr_len; fill_t fill_delta = MAX((int32_t)(addr_offset + wr_len) - curr_hdr.fill, (int32_t)0); - fdb->disk->free_bytes -= fill_delta; + disk->free_bytes -= fill_delta; fd->size += fill_delta; curr_hdr.fill += fill_delta; - if (!setBufferHdr(fdb->disk, &curr_hdr)) + if (!setBufferHdr(disk, &curr_hdr)) return total_write; - //LOG_INFO("free_bytes %d, seek_pos %d, size %d, curr_hdr.fill %d\n", fdb->disk->free_bytes, fd->seek_pos, fd->size, curr_hdr.fill); + //LOG_INFO("free_bytes %d, seek_pos %d, size %d, curr_hdr.fill %d\n", disk->free_bytes, fd->seek_pos, fd->size, curr_hdr.fill); } return total_write; } @@ -658,6 +781,7 @@ static size_t battfs_write(struct KFile *fd, const void *_buf, size_t size) static size_t battfs_read(struct KFile *fd, void *_buf, size_t size) { BattFs *fdb = BATTFS_CAST(fd); + BattFsSuper *disk = fdb->disk; uint8_t *buf = (uint8_t *)_buf; size_t total_read = 0; @@ -665,23 +789,27 @@ static size_t battfs_read(struct KFile *fd, void *_buf, size_t size) pgaddr_t addr_offset; pgaddr_t read_len; + if (fd->seek_pos < 0) + return total_read; + size = MIN((kfile_off_t)size, MAX(fd->size - fd->seek_pos, 0)); while (size) { - pg_offset = fd->seek_pos / (fdb->disk->page_size - BATTFS_HEADER_LEN); - addr_offset = fd->seek_pos % (fdb->disk->page_size - BATTFS_HEADER_LEN); - read_len = MIN(size, (size_t)(fdb->disk->page_size - BATTFS_HEADER_LEN - addr_offset)); + pg_offset = fd->seek_pos / disk->data_size; + addr_offset = fd->seek_pos % disk->data_size; + read_len = MIN(size, (size_t)(disk->data_size - addr_offset)); + //LOG_INFO("reading from page %d, offset %d, size %d\n", fdb->start[pg_offset], addr_offset, read_len); /* Read from disk */ - if (diskRead(fdb->disk, fdb->start[pg_offset], addr_offset, buf, read_len) != read_len) + if (diskRead(disk, fdb->start[pg_offset], addr_offset, buf, read_len) != read_len) { #warning TODO set error? } #if _DEBUG BattFsPageHeader hdr; - readHdr(fdb->disk, fdb->start[pg_offset], &hdr); + readHdr(disk, fdb->start[pg_offset], &hdr); ASSERT(hdr.inode == fdb->inode); #endif @@ -792,7 +920,7 @@ bool battfs_fileopen(BattFsSuper *disk, BattFs *fd, inode_t inode, filemode_t mo /* Fill file size */ if ((fd->fd.size = countFileSize(disk, fd->start, inode)) == EOF) return false; - fd->max_off = fd->fd.size / (disk->page_size - BATTFS_HEADER_LEN); + fd->max_off = fd->fd.size / disk->data_size; /* Reset seek position */ fd->fd.seek_pos = 0; @@ -830,9 +958,9 @@ bool battfs_fileopen(BattFsSuper *disk, BattFs *fd, inode_t inode, filemode_t mo } /** - * Close \a disk. + * Umount \a disk. */ -bool battfs_close(struct BattFsSuper *disk) +bool battfs_umount(struct BattFsSuper *disk) { Node *n; int res = 0;